yr_ac_automaton_create: 732| 1.72k|{ 733| 1.72k| YR_AC_AUTOMATON* new_automaton; 734| 1.72k| YR_AC_STATE* root_state; 735| | 736| 1.72k| new_automaton = (YR_AC_AUTOMATON*) yr_malloc(sizeof(YR_AC_AUTOMATON)); 737| 1.72k| root_state = (YR_AC_STATE*) yr_malloc(sizeof(YR_AC_STATE)); 738| | 739| 1.72k| if (new_automaton == NULL || root_state == NULL) ------------------ | Branch (739:7): [True: 0, False: 1.72k] | Branch (739:32): [True: 0, False: 1.72k] ------------------ 740| 0| { 741| 0| yr_free(new_automaton); 742| 0| yr_free(root_state); 743| | 744| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 745| 0| } 746| | 747| 1.72k| root_state->depth = 0; 748| 1.72k| root_state->matches_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 1.72k| (YR_ARENA_REF) \ | | 44| 1.72k| { \ | | 45| 1.72k| UINT32_MAX, UINT32_MAX \ | | 46| 1.72k| } ------------------ 749| 1.72k| root_state->failure = NULL; 750| 1.72k| root_state->first_child = NULL; 751| 1.72k| root_state->siblings = NULL; 752| 1.72k| root_state->t_table_slot = 0; 753| | 754| 1.72k| new_automaton->arena = arena; 755| 1.72k| new_automaton->root = root_state; 756| 1.72k| new_automaton->bitmask = NULL; 757| 1.72k| new_automaton->tables_size = 0; 758| | 759| 1.72k| *automaton = new_automaton; 760| | 761| 1.72k| return ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 762| 1.72k|} yr_ac_automaton_destroy: 768| 1.72k|{ 769| 1.72k| _yr_ac_state_destroy(automaton->root); 770| | 771| 1.72k| yr_free(automaton->bitmask); 772| 1.72k| yr_free(automaton); 773| | 774| 1.72k| return ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 775| 1.72k|} yr_ac_add_string: 787| 22.2k|{ 788| 4.84M| while (atom != NULL) ------------------ | Branch (788:10): [True: 4.82M, False: 22.2k] ------------------ 789| 4.82M| { 790| 4.82M| YR_AC_STATE* state = automaton->root; 791| | 792| 23.7M| for (int i = 0; i < atom->atom.length; i++) ------------------ | Branch (792:21): [True: 18.9M, False: 4.82M] ------------------ 793| 18.9M| { 794| 18.9M| YR_AC_STATE* next_state = _yr_ac_next_state(state, atom->atom.bytes[i]); 795| | 796| 18.9M| if (next_state == NULL) ------------------ | Branch (796:11): [True: 451k, False: 18.4M] ------------------ 797| 451k| { 798| 451k| next_state = _yr_ac_state_create(state, atom->atom.bytes[i]); 799| | 800| 451k| if (next_state == NULL) ------------------ | Branch (800:13): [True: 0, False: 451k] ------------------ 801| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 802| 451k| } 803| | 804| 18.9M| state = next_state; 805| 18.9M| } 806| | 807| 4.82M| YR_ARENA_REF new_match_ref; 808| | 809| 4.82M| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 4.82M| { \ | | 135| 4.82M| int __error = (x); \ | | 136| 4.82M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.82M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 4.82M] | | ------------------ | | 137| 4.82M| return __error; \ | | 138| 4.82M| } ------------------ 810| 4.82M| arena, 811| 4.82M| YR_AC_STATE_MATCHES_POOL, 812| 4.82M| sizeof(YR_AC_MATCH), 813| 4.82M| &new_match_ref, 814| 4.82M| offsetof(YR_AC_MATCH, string), 815| 4.82M| offsetof(YR_AC_MATCH, forward_code), 816| 4.82M| offsetof(YR_AC_MATCH, backward_code), 817| 4.82M| offsetof(YR_AC_MATCH, next), 818| 4.82M| EOL)); 819| | 820| 4.82M| YR_AC_MATCH* new_match = yr_arena_ref_to_ptr(arena, &new_match_ref); 821| | 822| 4.82M| new_match->backtrack = state->depth + atom->backtrack; 823| 4.82M| new_match->string = yr_arena_get_ptr( 824| 4.82M| arena, YR_STRINGS_TABLE, string_idx * sizeof(struct YR_STRING)); ------------------ | | 60| 4.82M|#define YR_STRINGS_TABLE 3 ------------------ 825| | 826| 4.82M| new_match->forward_code = yr_arena_ref_to_ptr( 827| 4.82M| arena, &atom->forward_code_ref); 828| | 829| 4.82M| new_match->backward_code = yr_arena_ref_to_ptr( 830| 4.82M| arena, &atom->backward_code_ref); 831| | 832| | // Add newly created match to the list of matches for the state. 833| 4.82M| new_match->next = yr_arena_ref_to_ptr(arena, &state->matches_ref); 834| 4.82M| state->matches_ref = new_match_ref; 835| | 836| 4.82M| atom = atom->next; 837| 4.82M| } 838| | 839| 22.2k| return ERROR_SUCCESS; ------------------ | | 40| 22.2k|#define ERROR_SUCCESS 0 ------------------ 840| 22.2k|} yr_ac_compile: 847| 112|{ 848| 112| FAIL_ON_ERROR(_yr_ac_create_failure_links(automaton)); ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 849| 112| FAIL_ON_ERROR(_yr_ac_optimize_failure_links(automaton)); ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 850| 112| FAIL_ON_ERROR(_yr_ac_build_transition_table(automaton)); ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 851| | 852| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 853| 112|} ahocorasick.c:_yr_ac_state_destroy: 196| 452k|{ 197| 452k| YR_AC_STATE* child_state = state->first_child; 198| | 199| 904k| while (child_state != NULL) ------------------ | Branch (199:10): [True: 451k, False: 452k] ------------------ 200| 451k| { 201| 451k| YR_AC_STATE* next_child_state = child_state->siblings; 202| 451k| _yr_ac_state_destroy(child_state); 203| 451k| child_state = next_child_state; 204| 451k| } 205| | 206| 452k| yr_free(state); 207| | 208| 452k| return ERROR_SUCCESS; ------------------ | | 40| 452k|#define ERROR_SUCCESS 0 ------------------ 209| 452k|} ahocorasick.c:_yr_ac_next_state: 147| 19.2M|{ 148| 19.2M| YR_AC_STATE* next_state = state->first_child; 149| | 150| 735M| while (next_state != NULL) ------------------ | Branch (150:10): [True: 734M, False: 587k] ------------------ 151| 734M| { 152| 734M| if (next_state->input == input) ------------------ | Branch (152:9): [True: 18.6M, False: 715M] ------------------ 153| 18.6M| return next_state; 154| | 155| 715M| next_state = next_state->siblings; 156| 715M| } 157| | 158| 587k| return NULL; 159| 19.2M|} ahocorasick.c:_yr_ac_state_create: 174| 451k|{ 175| 451k| YR_AC_STATE* new_state = (YR_AC_STATE*) yr_malloc(sizeof(YR_AC_STATE)); 176| | 177| 451k| if (new_state == NULL) ------------------ | Branch (177:7): [True: 0, False: 451k] ------------------ 178| 0| return NULL; 179| | 180| 451k| new_state->input = input; 181| 451k| new_state->depth = state->depth + 1; 182| 451k| new_state->matches_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 451k| (YR_ARENA_REF) \ | | 44| 451k| { \ | | 45| 451k| UINT32_MAX, UINT32_MAX \ | | 46| 451k| } ------------------ 183| 451k| new_state->failure = NULL; 184| 451k| new_state->t_table_slot = 0; 185| 451k| new_state->first_child = NULL; 186| 451k| new_state->siblings = state->first_child; 187| 451k| state->first_child = new_state; 188| | 189| 451k| return new_state; 190| 451k|} ahocorasick.c:_yr_ac_create_failure_links: 218| 112|{ 219| 112| YR_AC_STATE* current_state; 220| 112| YR_AC_STATE* failure_state; 221| 112| YR_AC_STATE* temp_state; 222| 112| YR_AC_STATE* state; 223| 112| YR_AC_STATE* transition_state; 224| 112| YR_AC_STATE* root_state; 225| 112| YR_AC_MATCH* match; 226| | 227| 112| QUEUE queue; 228| | 229| 112| queue.head = NULL; 230| 112| queue.tail = NULL; 231| | 232| 112| root_state = automaton->root; 233| | 234| | // Set the failure link of root state to itself. 235| 112| root_state->failure = root_state; 236| | 237| | // Push root's children and set their failure link to root. 238| 112| state = root_state->first_child; 239| | 240| 702| while (state != NULL) ------------------ | Branch (240:10): [True: 590, False: 112] ------------------ 241| 590| { 242| 590| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 590| { \ | | 135| 590| int __error = (x); \ | | 136| 590| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 590|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 590] | | ------------------ | | 137| 590| return __error; \ | | 138| 590| } ------------------ 243| 590| state->failure = root_state; 244| 590| state = state->siblings; 245| 590| } 246| | 247| | // Traverse the trie in BFS order calculating the failure link 248| | // for each state. 249| 252k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (249:10): [True: 252k, False: 112] ------------------ 250| 252k| { 251| 252k| current_state = _yr_ac_queue_pop(&queue); 252| 252k| match = yr_arena_ref_to_ptr(automaton->arena, ¤t_state->matches_ref); 253| | 254| 252k| if (match != NULL) ------------------ | Branch (254:9): [True: 166k, False: 86.0k] ------------------ 255| 166k| { 256| | // Find the last match in the list of matches. 257| 4.55M| while (match->next != NULL) match = match->next; ------------------ | Branch (257:14): [True: 4.39M, False: 166k] ------------------ 258| | 259| 166k| if (match->backtrack > 0) ------------------ | Branch (259:11): [True: 164k, False: 2.41k] ------------------ 260| 164k| match->next = yr_arena_ref_to_ptr( 261| 164k| automaton->arena, &root_state->matches_ref); 262| 166k| } 263| 86.0k| else 264| 86.0k| { 265| | // This state doesn't have any matches, its matches will be those 266| | // in the root state, if any. 267| 86.0k| current_state->matches_ref = root_state->matches_ref; 268| 86.0k| } 269| | 270| | // Iterate over all the states that the current state can transition to. 271| 252k| transition_state = current_state->first_child; 272| | 273| 504k| while (transition_state != NULL) ------------------ | Branch (273:12): [True: 252k, False: 252k] ------------------ 274| 252k| { 275| 252k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, transition_state)); ------------------ | | 134| 252k| { \ | | 135| 252k| int __error = (x); \ | | 136| 252k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 252k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 252k] | | ------------------ | | 137| 252k| return __error; \ | | 138| 252k| } ------------------ 276| 252k| failure_state = current_state->failure; 277| | 278| 323k| while (1) ------------------ | Branch (278:14): [Folded - Ignored] ------------------ 279| 323k| { 280| 323k| temp_state = _yr_ac_next_state(failure_state, transition_state->input); 281| | 282| 323k| if (temp_state != NULL) ------------------ | Branch (282:13): [True: 187k, False: 135k] ------------------ 283| 187k| { 284| 187k| transition_state->failure = temp_state; 285| | 286| 187k| if (YR_ARENA_IS_NULL_REF(transition_state->matches_ref)) ------------------ | | 49| 187k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 187k| (YR_ARENA_REF) \ | | | | 44| 187k| { \ | | | | 45| 187k| UINT32_MAX, UINT32_MAX \ | | | | 46| 187k| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 187k| (YR_ARENA_REF) \ | | | | 44| 187k| { \ | | | | 45| 187k| UINT32_MAX, UINT32_MAX \ | | | | 46| 187k| } | | ------------------ | | | Branch (49:3): [True: 48.6k, False: 139k] | | ------------------ ------------------ 287| 48.6k| { 288| 48.6k| transition_state->matches_ref = temp_state->matches_ref; 289| 48.6k| } 290| 139k| else 291| 139k| { 292| 139k| match = yr_arena_ref_to_ptr( 293| 139k| automaton->arena, &transition_state->matches_ref); 294| | 295| 139k| assert(match != NULL); 296| | 297| | // Find the last match in the list of matches. 298| 4.17M| while (match->next != NULL) match = match->next; ------------------ | Branch (298:20): [True: 4.03M, False: 139k] ------------------ 299| | 300| 139k| match->next = yr_arena_ref_to_ptr( 301| 139k| automaton->arena, &temp_state->matches_ref); 302| 139k| } 303| | 304| 187k| break; 305| 187k| } 306| 135k| else 307| 135k| { 308| 135k| if (failure_state == root_state) ------------------ | Branch (308:15): [True: 64.1k, False: 71.7k] ------------------ 309| 64.1k| { 310| 64.1k| transition_state->failure = root_state; 311| 64.1k| break; 312| 64.1k| } 313| 71.7k| else 314| 71.7k| { 315| 71.7k| failure_state = failure_state->failure; 316| 71.7k| } 317| 135k| } 318| 323k| } // while(1) 319| | 320| 252k| transition_state = transition_state->siblings; 321| 252k| } 322| | 323| 252k| } // while(!__yr_ac_queue_is_empty(&queue)) 324| | 325| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 326| 112|} ahocorasick.c:_yr_ac_queue_push: 68| 758k|{ 69| 758k| QUEUE_NODE* pushed_node; 70| | 71| 758k| pushed_node = (QUEUE_NODE*) yr_malloc(sizeof(QUEUE_NODE)); 72| | 73| 758k| if (pushed_node == NULL) ------------------ | Branch (73:7): [True: 0, False: 758k] ------------------ 74| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 75| | 76| 758k| pushed_node->previous = queue->tail; 77| 758k| pushed_node->next = NULL; 78| 758k| pushed_node->value = state; 79| | 80| 758k| if (queue->tail != NULL) ------------------ | Branch (80:7): [True: 758k, False: 123] ------------------ 81| 758k| queue->tail->next = pushed_node; 82| 123| else // queue is empty 83| 123| queue->head = pushed_node; 84| | 85| 758k| queue->tail = pushed_node; 86| | 87| 758k| return ERROR_SUCCESS; ------------------ | | 40| 758k|#define ERROR_SUCCESS 0 ------------------ 88| 758k|} ahocorasick.c:_yr_ac_queue_is_empty: 131| 758k|{ 132| 758k| return queue->head == NULL; 133| 758k|} ahocorasick.c:_yr_ac_queue_pop: 100| 758k|{ 101| 758k| YR_AC_STATE* result; 102| 758k| QUEUE_NODE* popped_node; 103| | 104| 758k| if (queue->head == NULL) ------------------ | Branch (104:7): [True: 0, False: 758k] ------------------ 105| 0| return NULL; 106| | 107| 758k| popped_node = queue->head; 108| 758k| queue->head = popped_node->next; 109| | 110| 758k| if (queue->head) ------------------ | Branch (110:7): [True: 758k, False: 123] ------------------ 111| 758k| queue->head->previous = NULL; 112| 123| else // queue is empty 113| 123| queue->tail = NULL; 114| | 115| 758k| result = popped_node->value; 116| | 117| 758k| yr_free(popped_node); 118| 758k| return result; 119| 758k|} ahocorasick.c:_yr_ac_optimize_failure_links: 364| 112|{ 365| 112| QUEUE queue = {NULL, NULL}; 366| | 367| | // Push root's children. 368| 112| YR_AC_STATE* root_state = automaton->root; 369| 112| YR_AC_STATE* state = root_state->first_child; 370| | 371| 702| while (state != NULL) ------------------ | Branch (371:10): [True: 590, False: 112] ------------------ 372| 590| { 373| 590| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 590| { \ | | 135| 590| int __error = (x); \ | | 136| 590| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 590|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 590] | | ------------------ | | 137| 590| return __error; \ | | 138| 590| } ------------------ 374| 590| state = state->siblings; 375| 590| } 376| | 377| 252k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (377:10): [True: 252k, False: 112] ------------------ 378| 252k| { 379| 252k| YR_AC_STATE* current_state = _yr_ac_queue_pop(&queue); 380| | 381| 252k| if (current_state->failure != root_state) ------------------ | Branch (381:9): [True: 187k, False: 64.7k] ------------------ 382| 187k| { 383| 187k| if (_yr_ac_transitions_subset(current_state, current_state->failure)) ------------------ | Branch (383:11): [True: 24.2k, False: 163k] ------------------ 384| 24.2k| current_state->failure = current_state->failure->failure; 385| 187k| } 386| | 387| | // Push children of current_state 388| 252k| state = current_state->first_child; 389| | 390| 504k| while (state != NULL) ------------------ | Branch (390:12): [True: 252k, False: 252k] ------------------ 391| 252k| { 392| 252k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 252k| { \ | | 135| 252k| int __error = (x); \ | | 136| 252k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 252k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 252k] | | ------------------ | | 137| 252k| return __error; \ | | 138| 252k| } ------------------ 393| 252k| state = state->siblings; 394| 252k| } 395| 252k| } 396| | 397| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 398| 112|} ahocorasick.c:_yr_ac_transitions_subset: 334| 187k|{ 335| 187k| uint8_t set[32]; 336| | 337| 187k| YR_AC_STATE* state = s1->first_child; 338| | 339| 187k| memset(set, 0, 32); 340| | 341| 334k| while (state != NULL) ------------------ | Branch (341:10): [True: 146k, False: 187k] ------------------ 342| 146k| { 343| 146k| set[state->input / 8] |= 1 << state->input % 8; 344| 146k| state = state->siblings; 345| 146k| } 346| | 347| 187k| state = s2->first_child; 348| | 349| 238k| while (state != NULL) ------------------ | Branch (349:10): [True: 214k, False: 24.2k] ------------------ 350| 214k| { 351| 214k| if (!(set[state->input / 8] & 1 << state->input % 8)) ------------------ | Branch (351:9): [True: 163k, False: 50.3k] ------------------ 352| 163k| return false; 353| | 354| 50.3k| state = state->siblings; 355| 50.3k| } 356| | 357| 24.2k| return true; 358| 187k|} ahocorasick.c:_yr_ac_build_transition_table: 526| 112|{ 527| 112| YR_AC_TRANSITION* t_table; 528| 112| uint32_t* m_table; 529| 112| YR_AC_STATE* state; 530| 112| YR_AC_STATE* child_state; 531| 112| YR_AC_STATE* root_state = automaton->root; 532| | 533| 112| uint32_t slot; 534| | 535| 112| QUEUE queue = {NULL, NULL}; 536| | 537| | // Both t_table and m_table have 512 slots initially, which is enough for the 538| | // root node's transition table. 539| 112| automaton->tables_size = 512; 540| | 541| 112| automaton->bitmask = yr_calloc( 542| 112| YR_BITMASK_SIZE(automaton->tables_size), sizeof(YR_BITMASK)); ------------------ | | 57| 112|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 112|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 543| | 544| 112| if (automaton->bitmask == NULL) ------------------ | Branch (544:7): [True: 0, False: 112] ------------------ 545| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 546| | 547| 112| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 548| 112| automaton->arena, 549| 112| YR_AC_TRANSITION_TABLE, 550| 112| automaton->tables_size * sizeof(YR_AC_TRANSITION), 551| 112| NULL)); 552| | 553| 112| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 554| 112| automaton->arena, 555| 112| YR_AC_STATE_MATCHES_TABLE, 556| 112| automaton->tables_size * sizeof(uint32_t), 557| 112| NULL)); 558| | 559| 112| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 112|#define YR_AC_TRANSITION_TABLE 8 ------------------ 560| 112| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 112|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 561| | 562| | // The failure link for the root node points to itself. 563| 112| t_table[0] = YR_AC_MAKE_TRANSITION(0, 0); ------------------ | | 50| 112| ((YR_AC_TRANSITION)( \ | | 51| 112| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 112|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 564| | 565| | // Initialize the entry corresponding to the root node in the match table. 566| | // Entries in this table are the index within YR_AC_MATCH_POOL where resides 567| | // the YR_AC_MATCH structure that corresponds to the head of the matches list 568| | // for the node. The indexes start counting at 1, the zero is used for 569| | // indicating that the node has no associated matches. 570| 112| if (!YR_ARENA_IS_NULL_REF(root_state->matches_ref)) ------------------ | | 49| 112| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 112| (YR_ARENA_REF) \ | | | | 44| 112| { \ | | | | 45| 112| UINT32_MAX, UINT32_MAX \ | | | | 46| 112| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 112| (YR_ARENA_REF) \ | | | | 44| 112| { \ | | | | 45| 112| UINT32_MAX, UINT32_MAX \ | | | | 46| 112| } | | ------------------ ------------------ | Branch (570:7): [True: 4, False: 108] ------------------ 571| 4| m_table[0] = root_state->matches_ref.offset / sizeof(YR_AC_MATCH) + 1; 572| | 573| | // Mark the first slot in the transition table as used. 574| 112| yr_bitmask_set(automaton->bitmask, 0); ------------------ | | 60| 112| do \ | | 61| 112| { \ | | 62| 112| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 112|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 112|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 112| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 575| | 576| | // Index 0 is for root node. Unused indexes start at 1. 577| 112| automaton->t_table_unused_candidate = 1; 578| | 579| 112| child_state = root_state->first_child; 580| | 581| 702| while (child_state != NULL) ------------------ | Branch (581:10): [True: 590, False: 112] ------------------ 582| 590| { 583| | // Each state stores its slot number. 584| 590| child_state->t_table_slot = child_state->input + 1; 585| | 586| 590| t_table[child_state->input + 1] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 590| ((YR_AC_TRANSITION)( \ | | 51| 590| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 590|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 587| 590| 0, child_state->input + 1); 588| | 589| 590| yr_bitmask_set(automaton->bitmask, child_state->input + 1); ------------------ | | 60| 590| do \ | | 61| 590| { \ | | 62| 590| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 590|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 590|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 590| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 590| | 591| 590| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 134| 590| { \ | | 135| 590| int __error = (x); \ | | 136| 590| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 590|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 590] | | ------------------ | | 137| 590| return __error; \ | | 138| 590| } ------------------ 592| 590| child_state = child_state->siblings; 593| 590| } 594| | 595| 252k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (595:10): [True: 252k, False: 112] ------------------ 596| 252k| { 597| 252k| state = _yr_ac_queue_pop(&queue); 598| | 599| 252k| FAIL_ON_ERROR(_yr_ac_find_suitable_transition_table_slot( ------------------ | | 134| 252k| { \ | | 135| 252k| int __error = (x); \ | | 136| 252k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 252k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 252k] | | ------------------ | | 137| 252k| return __error; \ | | 138| 252k| } ------------------ 600| 252k| automaton, automaton->arena, state, &slot)); 601| | 602| | // _yr_ac_find_suitable_transition_table_slot can allocate more space in 603| | // both tables and cause the tables to be moved to a different memory 604| | // location, we must get their up-to-date addresses. 605| 252k| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 252k|#define YR_AC_TRANSITION_TABLE 8 ------------------ 606| 252k| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 252k|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 607| | 608| 252k| t_table[state->t_table_slot] |= (slot << YR_AC_SLOT_OFFSET_BITS); ------------------ | | 39| 252k|#define YR_AC_SLOT_OFFSET_BITS 9 ------------------ 609| 252k| t_table[slot] = YR_AC_MAKE_TRANSITION(state->failure->t_table_slot, 0); ------------------ | | 50| 252k| ((YR_AC_TRANSITION)( \ | | 51| 252k| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 252k|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 610| | 611| | // The match table is an array of indexes within YR_AC_MATCHES_POOL. The 612| | // N-th item in the array is the index for the YR_AC_MATCH structure that 613| | // represents the head of the matches list for state N. The indexes start 614| | // at 1, the 0 indicates that there are no matches for the state. 615| 252k| if (YR_ARENA_IS_NULL_REF(state->matches_ref)) ------------------ | | 49| 252k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 252k| (YR_ARENA_REF) \ | | | | 44| 252k| { \ | | | | 45| 252k| UINT32_MAX, UINT32_MAX \ | | | | 46| 252k| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 252k| (YR_ARENA_REF) \ | | | | 44| 252k| { \ | | | | 45| 252k| UINT32_MAX, UINT32_MAX \ | | | | 46| 252k| } | | ------------------ | | | Branch (49:3): [True: 83.5k, False: 169k] | | ------------------ ------------------ 616| 83.5k| m_table[slot] = 0; 617| 169k| else 618| 169k| m_table[slot] = state->matches_ref.offset / sizeof(YR_AC_MATCH) + 1; 619| | 620| 252k| state->t_table_slot = slot; 621| | 622| 252k| yr_bitmask_set(automaton->bitmask, slot); ------------------ | | 60| 252k| do \ | | 61| 252k| { \ | | 62| 252k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 252k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 623| | 624| | // Push children of current_state 625| 252k| child_state = state->first_child; 626| | 627| 504k| while (child_state != NULL) ------------------ | Branch (627:12): [True: 252k, False: 252k] ------------------ 628| 252k| { 629| 252k| child_state->t_table_slot = slot + child_state->input + 1; 630| | 631| 252k| t_table[child_state->t_table_slot] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 252k| ((YR_AC_TRANSITION)( \ | | 51| 252k| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 252k|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 632| 252k| 0, child_state->input + 1); 633| | 634| 252k| yr_bitmask_set(automaton->bitmask, child_state->t_table_slot); ------------------ | | 60| 252k| do \ | | 61| 252k| { \ | | 62| 252k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 252k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 635| | 636| 252k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 134| 252k| { \ | | 135| 252k| int __error = (x); \ | | 136| 252k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 252k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 252k] | | ------------------ | | 137| 252k| return __error; \ | | 138| 252k| } ------------------ 637| | 638| 252k| child_state = child_state->siblings; 639| 252k| } 640| 252k| } 641| | 642| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 643| 112|} ahocorasick.c:_yr_ac_find_suitable_transition_table_slot: 411| 252k|{ 412| | // The state's transition table has 257 entries, 1 for the failure link and 413| | // 256 for each possible input byte, so the state's bitmask has 257 bits. 414| 252k| YR_BITMASK state_bitmask[YR_BITMASK_SIZE(257)]; ------------------ | | 54| 252k|#define YR_BITMASK unsigned long ------------------ 415| | 416| 252k| YR_AC_STATE* child_state = state->first_child; 417| | 418| | // Start with all bits set to zero. 419| 252k| yr_bitmask_clear_all(state_bitmask); ------------------ | | 72| 252k|#define yr_bitmask_clear_all(bm) memset(bm, 0, sizeof(bm)) ------------------ 420| | 421| | // The first slot in the transition table is for the state's failure link, 422| | // so the first bit in the bitmask must be set to one. 423| 252k| yr_bitmask_set(state_bitmask, 0); ------------------ | | 60| 252k| do \ | | 61| 252k| { \ | | 62| 252k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 252k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 424| | 425| 504k| while (child_state != NULL) ------------------ | Branch (425:10): [True: 252k, False: 252k] ------------------ 426| 252k| { 427| 252k| yr_bitmask_set(state_bitmask, child_state->input + 1); ------------------ | | 60| 252k| do \ | | 61| 252k| { \ | | 62| 252k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 252k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 428| 252k| child_state = child_state->siblings; 429| 252k| } 430| | 431| 252k| *slot = yr_bitmask_find_non_colliding_offset( 432| 252k| automaton->bitmask, 433| 252k| state_bitmask, 434| 252k| automaton->tables_size, 435| 252k| 257, 436| 252k| &automaton->t_table_unused_candidate); 437| | 438| | // Make sure that we are not going beyond the maximum size of the transition 439| | // table, starting at the slot found there must be at least 257 other slots 440| | // for accommodating the state's transition table. 441| 252k| assert(*slot + 257 < YR_AC_MAX_TRANSITION_TABLE_SIZE); 442| | 443| 252k| if (*slot > automaton->tables_size - 257) ------------------ | Branch (443:7): [True: 1.95k, False: 250k] ------------------ 444| 1.95k| { 445| 1.95k| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 1.95k| { \ | | 135| 1.95k| int __error = (x); \ | | 136| 1.95k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.95k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.95k] | | ------------------ | | 137| 1.95k| return __error; \ | | 138| 1.95k| } ------------------ 446| 1.95k| arena, YR_AC_TRANSITION_TABLE, 257 * sizeof(YR_AC_TRANSITION), NULL)); 447| | 448| 1.95k| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 1.95k| { \ | | 135| 1.95k| int __error = (x); \ | | 136| 1.95k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.95k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.95k] | | ------------------ | | 137| 1.95k| return __error; \ | | 138| 1.95k| } ------------------ 449| 1.95k| arena, YR_AC_STATE_MATCHES_TABLE, 257 * sizeof(uint8_t*), NULL)); 450| | 451| 1.95k| size_t bm_len = YR_BITMASK_SIZE(automaton->tables_size) * ------------------ | | 57| 1.95k|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1.95k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 452| 1.95k| sizeof(YR_BITMASK); 453| | 454| 1.95k| size_t bm_len_incr = YR_BITMASK_SIZE(257) * sizeof(YR_BITMASK); ------------------ | | 57| 1.95k|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1.95k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 455| | 456| 1.95k| automaton->bitmask = yr_realloc(automaton->bitmask, bm_len + bm_len_incr); 457| | 458| 1.95k| if (automaton->bitmask == NULL) ------------------ | Branch (458:9): [True: 0, False: 1.95k] ------------------ 459| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 460| | 461| 1.95k| memset((uint8_t*) automaton->bitmask + bm_len, 0, bm_len_incr); 462| | 463| 1.95k| automaton->tables_size += 257; 464| 1.95k| } 465| | 466| 252k| return ERROR_SUCCESS; ------------------ | | 40| 252k|#define ERROR_SUCCESS 0 ------------------ 467| 252k|} yr_arena_create: 237| 1.72k|{ 238| 1.72k| YR_ARENA* new_arena = (YR_ARENA*) yr_calloc(1, sizeof(YR_ARENA)); 239| | 240| 1.72k| if (new_arena == NULL) ------------------ | Branch (240:7): [True: 0, False: 1.72k] ------------------ 241| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 242| | 243| 1.72k| new_arena->xrefs = 1; 244| 1.72k| new_arena->num_buffers = num_buffers; 245| 1.72k| new_arena->initial_buffer_size = initial_buffer_size; 246| | 247| 1.72k| *arena = new_arena; 248| | 249| 1.72k| return ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 250| 1.72k|} yr_arena_acquire: 253| 112|{ 254| 112| arena->xrefs++; 255| 112|} yr_arena_release: 272| 1.83k|{ 273| 1.83k| arena->xrefs--; 274| | 275| 1.83k| if (arena->xrefs > 0) ------------------ | Branch (275:7): [True: 112, False: 1.72k] ------------------ 276| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 277| | 278| 22.4k| for (uint32_t i = 0; i < arena->num_buffers; i++) ------------------ | Branch (278:24): [True: 20.6k, False: 1.72k] ------------------ 279| 20.6k| { 280| 20.6k| if (arena->buffers[i].data != NULL) ------------------ | Branch (280:9): [True: 8.88k, False: 11.8k] ------------------ 281| 8.88k| yr_free(arena->buffers[i].data); 282| 20.6k| } 283| | 284| 1.72k| YR_RELOC* reloc = arena->reloc_list_head; 285| | 286| 20.1M| while (reloc != NULL) ------------------ | Branch (286:10): [True: 20.1M, False: 1.72k] ------------------ 287| 20.1M| { 288| 20.1M| YR_RELOC* next = reloc->next; 289| 20.1M| yr_free(reloc); 290| 20.1M| reloc = next; 291| 20.1M| } 292| | 293| 1.72k| yr_free(arena); 294| | 295| 1.72k| return ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 296| 1.83k|} yr_arena_allocate_zeroed_memory: 342| 4.13k|{ 343| 4.13k| return _yr_arena_allocate_memory( 344| 4.13k| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, ref); ------------------ | | 114| 4.13k|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 345| 4.13k|} yr_arena_allocate_struct: 386| 4.86M|{ 387| 4.86M| YR_ARENA_REF r; 388| | 389| 4.86M| int result = _yr_arena_allocate_memory( 390| 4.86M| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, &r); ------------------ | | 114| 4.86M|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 391| | 392| 4.86M| if (result != ERROR_SUCCESS) ------------------ | | 40| 4.86M|#define ERROR_SUCCESS 0 ------------------ | Branch (392:7): [True: 0, False: 4.86M] ------------------ 393| 0| return result; 394| | 395| 4.86M| va_list field_offsets; 396| 4.86M| va_start(field_offsets, ref); 397| | 398| 4.86M| result = _yr_arena_make_ptr_relocatable( 399| 4.86M| arena, buffer_id, r.offset, field_offsets); 400| | 401| 4.86M| va_end(field_offsets); 402| | 403| 4.86M| if (result == ERROR_SUCCESS && ref != NULL) ------------------ | | 40| 9.72M|#define ERROR_SUCCESS 0 ------------------ | Branch (403:7): [True: 4.86M, False: 0] | Branch (403:34): [True: 4.86M, False: 0] ------------------ 404| 4.86M| { 405| 4.86M| ref->buffer_id = r.buffer_id; 406| 4.86M| ref->offset = r.offset; 407| 4.86M| } 408| | 409| 4.86M| return result; 410| 4.86M|} yr_arena_get_ptr: 416| 39.3M|{ 417| 39.3M| assert(buffer_id < arena->num_buffers); 418| 39.3M| assert(offset <= arena->buffers[buffer_id].used); 419| | 420| 39.3M| if (arena->buffers[buffer_id].data == NULL) ------------------ | Branch (420:7): [True: 1.88k, False: 39.3M] ------------------ 421| 1.88k| return NULL; 422| | 423| 39.3M| return arena->buffers[buffer_id].data + offset; 424| 39.3M|} yr_arena_get_current_offset: 427| 61.4M|{ 428| 61.4M| assert(buffer_id < arena->num_buffers); 429| | 430| 61.4M| return (yr_arena_off_t) arena->buffers[buffer_id].used; 431| 61.4M|} yr_arena_ptr_to_ref: 434| 10.1k|{ 435| 10.1k| *ref = YR_ARENA_NULL_REF; ------------------ | | 43| 10.1k| (YR_ARENA_REF) \ | | 44| 10.1k| { \ | | 45| 10.1k| UINT32_MAX, UINT32_MAX \ | | 46| 10.1k| } ------------------ 436| | 437| 10.1k| if (address == NULL) ------------------ | Branch (437:7): [True: 0, False: 10.1k] ------------------ 438| 0| return 1; 439| | 440| 67.6k| for (uint32_t i = 0; i < arena->num_buffers; ++i) ------------------ | Branch (440:24): [True: 67.6k, False: 0] ------------------ 441| 67.6k| { 442| | // If the buffer is completetly empty, skip it. 443| 67.6k| if (arena->buffers[i].data == NULL) ------------------ | Branch (443:9): [True: 26.2k, False: 41.3k] ------------------ 444| 26.2k| continue; 445| | 446| | // If the address falls within the limits of the buffer, then we found 447| | // the buffer that contains the data and return a reference to it. 448| 41.3k| if ((uint8_t*) address >= arena->buffers[i].data && ------------------ | Branch (448:9): [True: 23.4k, False: 17.9k] ------------------ 449| 41.3k| (uint8_t*) address < arena->buffers[i].data + arena->buffers[i].used) ------------------ | Branch (449:9): [True: 10.1k, False: 13.3k] ------------------ 450| 10.1k| { 451| 10.1k| ref->buffer_id = i; 452| 10.1k| ref->offset = 453| 10.1k| (yr_arena_off_t) ((uint8_t*) address - arena->buffers[i].data); 454| | 455| 10.1k| return 1; 456| 10.1k| } 457| 41.3k| } 458| | 459| 0| return 0; 460| 10.1k|} yr_arena_ref_to_ptr: 463| 34.9M|{ 464| 34.9M| if (YR_ARENA_IS_NULL_REF(*ref)) ------------------ | | 49| 34.9M| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 34.9M| (YR_ARENA_REF) \ | | | | 44| 34.9M| { \ | | | | 45| 34.9M| UINT32_MAX, UINT32_MAX \ | | | | 46| 34.9M| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 34.9M| (YR_ARENA_REF) \ | | | | 44| 34.9M| { \ | | | | 45| 34.9M| UINT32_MAX, UINT32_MAX \ | | | | 46| 34.9M| } | | ------------------ | | | Branch (49:3): [True: 1.07M, False: 33.9M] | | ------------------ ------------------ 465| 1.07M| return NULL; 466| | 467| |#if defined(__arm__) 468| | YR_ARENA_REF tmp_ref; 469| | memcpy(&tmp_ref, ref, sizeof(YR_ARENA_REF)); 470| | ref = &tmp_ref; 471| |#endif 472| | 473| 33.9M| return yr_arena_get_ptr(arena, ref->buffer_id, ref->offset); 474| 34.9M|} yr_arena_make_ptr_relocatable: 488| 749k|{ 489| 749k| int result; 490| | 491| 749k| va_list offsets; 492| 749k| va_start(offsets, buffer_id); 493| | 494| 749k| result = _yr_arena_make_ptr_relocatable(arena, buffer_id, 0, offsets); 495| | 496| 749k| va_end(offsets); 497| | 498| 749k| return result; 499| 749k|} yr_arena_write_data: 507| 324M|{ 508| 324M| YR_ARENA_REF r; 509| | 510| | // Allocate space in the buffer. 511| 324M| FAIL_ON_ERROR(_yr_arena_allocate_memory(arena, 0, buffer_id, size, &r)); ------------------ | | 134| 324M| { \ | | 135| 324M| int __error = (x); \ | | 136| 324M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 324M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 324M] | | ------------------ | | 137| 324M| return __error; \ | | 138| 324M| } ------------------ 512| | 513| | // Copy the data into the allocated space. 514| 324M| memcpy(arena->buffers[buffer_id].data + r.offset, data, size); 515| | 516| 324M| if (ref != NULL) ------------------ | Branch (516:7): [True: 148M, False: 176M] ------------------ 517| 148M| { 518| 148M| ref->buffer_id = r.buffer_id; 519| 148M| ref->offset = r.offset; 520| 148M| } 521| | 522| 324M| return ERROR_SUCCESS; ------------------ | | 40| 324M|#define ERROR_SUCCESS 0 ------------------ 523| 324M|} yr_arena_write_string: 530| 633|{ 531| 633| return yr_arena_write_data(arena, buffer_id, string, strlen(string) + 1, ref); 532| 633|} arena.c:_yr_arena_allocate_memory: 138| 329M|{ 139| 329M| if (buffer_id > arena->num_buffers) ------------------ | Branch (139:7): [True: 0, False: 329M] ------------------ 140| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 141| | 142| 329M| YR_ARENA_BUFFER* b = &arena->buffers[buffer_id]; 143| | 144| | // If the new data doesn't fit in the remaining space the buffer must be 145| | // re-sized. This implies moving the buffer to a different memory location 146| | // and adjusting the pointers listed in the relocation list. 147| | 148| 329M| if (b->size - b->used < size) ------------------ | Branch (148:7): [True: 9.06k, False: 329M] ------------------ 149| 9.06k| { 150| 9.06k| size_t new_size = (b->size == 0) ? arena->initial_buffer_size : b->size * 2; ------------------ | Branch (150:23): [True: 8.88k, False: 189] ------------------ 151| | 152| 9.06k| while (new_size < b->used + size) new_size *= 2; ------------------ | Branch (152:12): [True: 0, False: 9.06k] ------------------ 153| | 154| | // Make sure that buffer size if not larger than 4GB. 155| 9.06k| if (new_size > 1ULL << 32) ------------------ | Branch (155:9): [True: 0, False: 9.06k] ------------------ 156| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 157| | 158| 9.06k| uint8_t* new_data = yr_realloc(b->data, new_size); 159| | 160| 9.06k| if (new_data == NULL) ------------------ | Branch (160:9): [True: 0, False: 9.06k] ------------------ 161| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 162| | 163| |// When yr_realloc uses the Windows API (HeapAlloc, HeapReAlloc) it is not 164| |// necessary to set the memory to zero because the API is called with the 165| |// HEAP_ZERO_MEMORY flag. 166| 9.06k|#if !defined(_WIN32) && !defined(__CYGWIN__) 167| 9.06k| if (flags & YR_ARENA_ZERO_MEMORY) ------------------ | | 114| 9.06k|#define YR_ARENA_ZERO_MEMORY 1 ------------------ | Branch (167:9): [True: 4.98k, False: 4.08k] ------------------ 168| 4.98k| memset(new_data + b->used, 0, new_size - b->used); 169| 9.06k|#endif 170| | 171| | // Fix pointers in the relocation list if the old buffer was not empty 172| | // and it was actually moved by yr_realloc. 173| 9.06k| if (b->data != NULL && b->data != new_data) ------------------ | Branch (173:9): [True: 189, False: 8.88k] | Branch (173:28): [True: 145, False: 44] ------------------ 174| 145| { 175| 145| YR_RELOC* reloc = arena->reloc_list_head; 176| | 177| 23.4M| while (reloc != NULL) ------------------ | Branch (177:14): [True: 23.4M, False: 145] ------------------ 178| 23.4M| { 179| | // If the reloc entry is for the same buffer that is being relocated, 180| | // the base pointer that we use to access the buffer must be new_data 181| | // as arena->buffers[reloc->buffer_id].data (which is the same than 182| | // b->data) can't be accessed anymore after the call to yr_realloc. 183| 23.4M| uint8_t* base = buffer_id == reloc->buffer_id ------------------ | Branch (183:25): [True: 23.4M, False: 30.5k] ------------------ 184| 23.4M| ? new_data 185| 23.4M| : arena->buffers[reloc->buffer_id].data; 186| | 187| | // reloc_address holds the address inside the buffer where the pointer 188| | // to be relocated resides. 189| 23.4M| void** reloc_address = (void**) (base + reloc->offset); 190| | 191| | // reloc_target is the value of the relocatable pointer. 192| 23.4M| void* reloc_target = *reloc_address; 193| | 194| 23.4M| if ((uint8_t*) reloc_target >= b->data && ------------------ | Branch (194:13): [True: 8.60M, False: 14.8M] ------------------ 195| 23.4M| (uint8_t*) reloc_target < b->data + b->used) ------------------ | Branch (195:13): [True: 5.37M, False: 3.23M] ------------------ 196| 5.37M| { 197| | // reloc_target points to some data inside the buffer being moved, so 198| | // the pointer needs to be adjusted. 199| 5.37M| *reloc_address = (uint8_t*) reloc_target - b->data + new_data; 200| 5.37M| } 201| | 202| 23.4M| reloc = reloc->next; 203| 23.4M| } 204| 145| } 205| | 206| 9.06k| b->size = new_size; 207| 9.06k| b->data = new_data; 208| 9.06k| } 209| | 210| 329M| if (ref != NULL) ------------------ | Branch (210:7): [True: 329M, False: 4.13k] ------------------ 211| 329M| { 212| 329M| ref->buffer_id = buffer_id; 213| 329M| ref->offset = (uint32_t) b->used; 214| 329M| } 215| | 216| 329M| b->used += size; 217| | 218| 329M| return ERROR_SUCCESS; ------------------ | | 40| 329M|#define ERROR_SUCCESS 0 ------------------ 219| 329M|} arena.c:_yr_arena_make_ptr_relocatable: 80| 5.61M|{ 81| 5.61M| size_t offset; 82| | 83| 5.61M| int result = ERROR_SUCCESS; ------------------ | | 40| 5.61M|#define ERROR_SUCCESS 0 ------------------ 84| | 85| | // The argument to va_arg is size_t because the offsets passed to this 86| | // function are obtained with offsetof(). 87| 5.61M| offset = va_arg(offsets, size_t); 88| | 89| 25.7M| while (offset != EOL) ------------------ | | 38| 25.7M|#define EOL ((size_t) -1) ------------------ | Branch (89:10): [True: 20.1M, False: 5.61M] ------------------ 90| 20.1M| { 91| 20.1M| YR_RELOC* reloc = (YR_RELOC*) yr_malloc(sizeof(YR_RELOC)); 92| | 93| 20.1M| if (reloc == NULL) ------------------ | Branch (93:9): [True: 0, False: 20.1M] ------------------ 94| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 95| | 96| 20.1M| reloc->buffer_id = buffer_id; 97| 20.1M| reloc->offset = base_offset + (yr_arena_off_t) offset; 98| 20.1M| reloc->next = NULL; 99| | 100| 20.1M| if (arena->reloc_list_head == NULL) ------------------ | Branch (100:9): [True: 1.72k, False: 20.1M] ------------------ 101| 1.72k| arena->reloc_list_head = reloc; 102| | 103| 20.1M| if (arena->reloc_list_tail != NULL) ------------------ | Branch (103:9): [True: 20.1M, False: 1.72k] ------------------ 104| 20.1M| arena->reloc_list_tail->next = reloc; 105| | 106| 20.1M| arena->reloc_list_tail = reloc; 107| 20.1M| offset = va_arg(offsets, size_t); 108| 20.1M| } 109| | 110| 5.61M| return result; 111| 5.61M|} yr_atoms_heuristic_quality: 107| 5.37M|{ 108| 5.37M| YR_BITMASK seen_bytes[YR_BITMASK_SIZE(256)]; ------------------ | | 54| 5.37M|#define YR_BITMASK unsigned long ------------------ 109| | 110| 5.37M| int quality = 0; 111| 5.37M| int unique_bytes = 0; 112| | 113| 5.37M| assert(atom->length <= YR_MAX_ATOM_LENGTH); 114| | 115| 5.37M| yr_bitmask_clear_all(seen_bytes); ------------------ | | 72| 5.37M|#define yr_bitmask_clear_all(bm) memset(bm, 0, sizeof(bm)) ------------------ 116| | 117| | // Each byte in the atom contributes a certain amount of points to the 118| | // quality. Bytes [a-zA-Z] contribute 18 points each, common bytes like 119| | // 0x00, 0x20 and 0xFF contribute only 12 points, and the rest of the 120| | // bytes contribute 20 points. The ?? mask substracts 10 points, and masks 121| | // X? and ?X contribute 4 points. An additional boost consisting in 2x the 122| | // number of unique bytes in the atom is added to the quality. This are 123| | // some examples of the quality of atoms: 124| | // 125| | // 01 02 03 04 quality = 20 + 20 + 20 + 20 + 8 = 88 126| | // 01 ?? 03 04 quality = 20 - 10 + 20 + 20 + 6 = 56 127| | // 01 0? 03 quality = 20 + 4 + 20 + 4 = 48 128| | // 01 02 quality = 20 + 20 + 4 = 44 129| | // 01 ?? ?3 04 quality = 20 - 10 + 2 + 20 + 4 = 36 130| | // 61 62 quality = 18 + 18 + 4 = 40 131| | // 61 61 quality = 18 + 18 + 2 = 38 <- warning threshold 132| | // 00 01 quality = 12 + 20 + 4 = 36 133| | // 01 ?? 02 quality = 20 - 10 + 20 + 4 = 34 134| | // 01 quality = 20 + 1 = 21 135| | 136| 26.2M| for (int i = 0; i < atom->length; i++) ------------------ | Branch (136:19): [True: 20.8M, False: 5.37M] ------------------ 137| 20.8M| { 138| 20.8M| switch (atom->mask[i]) ------------------ | Branch (138:13): [True: 0, False: 20.8M] ------------------ 139| 20.8M| { 140| 104k| case 0x00: ------------------ | Branch (140:5): [True: 104k, False: 20.7M] ------------------ 141| 104k| quality -= 10; 142| 104k| break; 143| 1.01k| case 0x0F: ------------------ | Branch (143:5): [True: 1.01k, False: 20.8M] ------------------ 144| 1.01k| quality += 4; 145| 1.01k| break; 146| 2.91k| case 0xF0: ------------------ | Branch (146:5): [True: 2.91k, False: 20.8M] ------------------ 147| 2.91k| quality += 4; 148| 2.91k| break; 149| 20.7M| case 0xFF: ------------------ | Branch (149:5): [True: 20.7M, False: 108k] ------------------ 150| 20.7M| switch (atom->bytes[i]) 151| 20.7M| { 152| 3.66M| case 0x00: ------------------ | Branch (152:7): [True: 3.66M, False: 17.0M] ------------------ 153| 3.66M| case 0x20: ------------------ | Branch (153:7): [True: 4.90k, False: 20.7M] ------------------ 154| 3.67M| case 0xCC: ------------------ | Branch (154:7): [True: 2.75k, False: 20.7M] ------------------ 155| 8.45M| case 0xFF: ------------------ | Branch (155:7): [True: 4.78M, False: 15.9M] ------------------ 156| | // Common bytes contribute less to the quality than the rest. 157| 8.45M| quality += 12; 158| 8.45M| break; 159| 12.2M| default: ------------------ | Branch (159:7): [True: 12.2M, False: 8.45M] ------------------ 160| | // Bytes in the a-z and A-Z ranges have a slightly lower quality 161| | // than the rest. We want to favor atoms that contain bytes outside 162| | // those ranges because they generate less additional atoms during 163| | // calls to _yr_atoms_case_combinations. 164| 12.2M| if (yr_lowercase[atom->bytes[i]] >= 'a' && ------------------ | Branch (164:13): [True: 10.4M, False: 1.82M] ------------------ 165| 12.2M| yr_lowercase[atom->bytes[i]] <= 'z') ------------------ | Branch (165:13): [True: 7.49M, False: 2.97M] ------------------ 166| 7.49M| quality += 18; 167| 4.79M| else 168| 4.79M| quality += 20; 169| 20.7M| } 170| | 171| 20.7M| if (!yr_bitmask_is_set(seen_bytes, atom->bytes[i])) ------------------ | | 75| 20.7M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 20.7M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 20.7M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ | Branch (171:11): [True: 13.9M, False: 6.76M] ------------------ 172| 13.9M| { 173| 13.9M| yr_bitmask_set(seen_bytes, atom->bytes[i]); ------------------ | | 60| 13.9M| do \ | | 61| 13.9M| { \ | | 62| 13.9M| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 13.9M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 13.9M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 13.9M| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 174| 13.9M| unique_bytes++; 175| 13.9M| } 176| 20.8M| } 177| 20.8M| } 178| | 179| | // If all the bytes in the atom are equal and very common, let's penalize 180| | // it heavily. 181| 5.37M| if (unique_bytes == 1 && (yr_bitmask_is_set(seen_bytes, 0x00) || ------------------ | | 75| 2.46M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 497, False: 1.23M] | | ------------------ ------------------ | Branch (181:7): [True: 1.23M, False: 4.13M] ------------------ 182| 1.23M| yr_bitmask_is_set(seen_bytes, 0x20) || ------------------ | | 75| 2.46M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 53, False: 1.23M] | | ------------------ ------------------ 183| 1.23M| yr_bitmask_is_set(seen_bytes, 0x90) || ------------------ | | 75| 2.46M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 111, False: 1.23M] | | ------------------ ------------------ 184| 1.23M| yr_bitmask_is_set(seen_bytes, 0xCC) || ------------------ | | 75| 2.46M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 74, False: 1.23M] | | ------------------ ------------------ 185| 1.23M| yr_bitmask_is_set(seen_bytes, 0xFF))) ------------------ | | 75| 1.23M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 1.23M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 750k, False: 483k] | | ------------------ ------------------ 186| 750k| { 187| 750k| quality -= 10 * atom->length; 188| 750k| } 189| | // In general atoms with more unique bytes have a better quality, so let's 190| | // boost the quality in the amount of unique bytes. 191| 4.61M| else 192| 4.61M| { 193| 4.61M| quality += 2 * unique_bytes; 194| 4.61M| } 195| | 196| | // The final quality is not zero-based, we start at YR_MAX_ATOM_QUALITY 197| | // for the best possible atom and substract from there. The best possible 198| | // quality is 21 * YR_MAX_ATOM_LENGTH (20 points per byte + 2 additional point 199| | // per unique byte, with a maximum of 2*YR_MAX_ATOM_LENGTH unique bytes). 200| | 201| 5.37M| return YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + quality; ------------------ | | 71| 5.37M|#define YR_MAX_ATOM_QUALITY 255 ------------------ return YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + quality; ------------------ | | 67| 5.37M|#define YR_MAX_ATOM_LENGTH 4 ------------------ 202| 5.37M|} yr_atoms_list_destroy: 410| 58.7k|{ 411| 58.7k| YR_ATOM_LIST_ITEM* item = list_head; 412| 58.7k| YR_ATOM_LIST_ITEM* next; 413| | 414| 4.89M| while (item != NULL) ------------------ | Branch (414:10): [True: 4.83M, False: 58.7k] ------------------ 415| 4.83M| { 416| 4.83M| next = item->next; 417| 4.83M| yr_free(item); 418| 4.83M| item = next; 419| 4.83M| } 420| 58.7k|} _yr_atoms_trim: 458| 5.11M|{ 459| 5.11M| int mask_00 = 0; 460| 5.11M| int mask_ff = 0; 461| | 462| 5.11M| int trim_left = 0; 463| | 464| 5.19M| while (trim_left < atom->length && atom->mask[trim_left] == 0) trim_left++; ------------------ | Branch (464:10): [True: 5.15M, False: 40.1k] | Branch (464:38): [True: 89.3k, False: 5.07M] ------------------ 465| | 466| 5.15M| while (atom->length > trim_left && atom->mask[atom->length - 1] == 0) ------------------ | Branch (466:10): [True: 5.11M, False: 40.1k] | Branch (466:38): [True: 46.0k, False: 5.07M] ------------------ 467| 46.0k| atom->length--; 468| | 469| 5.11M| atom->length -= trim_left; 470| | 471| 5.11M| if (atom->length == 0) ------------------ | Branch (471:7): [True: 40.1k, False: 5.07M] ------------------ 472| 40.1k| return 0; 473| | 474| | // The trimmed atom goes from trim_left to trim_left + atom->length and the 475| | // first and last byte in the atom are known (mask == 0xFF). Now count the 476| | // number of known and unknown bytes in the atom (mask == 0xFF and 477| | // mask == 0x00 respectively). 478| | 479| 25.1M| for (int i = 0; i < atom->length; i++) ------------------ | Branch (479:19): [True: 20.0M, False: 5.07M] ------------------ 480| 20.0M| { 481| 20.0M| if (atom->mask[trim_left + i] == 0xFF) ------------------ | Branch (481:9): [True: 19.9M, False: 109k] ------------------ 482| 19.9M| mask_ff++; 483| 109k| else if (atom->mask[trim_left + i] == 0x00) ------------------ | Branch (483:14): [True: 105k, False: 4.71k] ------------------ 484| 105k| mask_00++; 485| 20.0M| } 486| | 487| | // If the number of unknown bytes is >= than the number of known bytes 488| | // it doesn't make sense the to use this atom, so we use a single byte atom 489| | // containing the first known byte. If YR_MAX_ATOM_LENGTH == 4 this happens 490| | // only when the atom is like { XX ?? ?? YY }, so using the first known 491| | // byte is good enough. For larger values of YR_MAX_ATOM_LENGTH this is not 492| | // the most efficient solution, as better atoms could be choosen. For 493| | // example, in { XX ?? ?? ?? YY ZZ } the best atom is { YY ZZ } not { XX }. 494| | // But let's keep it like this for simplicity. 495| | 496| 5.07M| if (mask_00 >= mask_ff) ------------------ | Branch (496:7): [True: 2.41k, False: 5.06M] ------------------ 497| 2.41k| atom->length = 1; 498| | 499| 5.07M| if (trim_left == 0) ------------------ | Branch (499:7): [True: 5.01M, False: 50.6k] ------------------ 500| 5.01M| return 0; 501| | 502| | // Shift bytes and mask trim_left positions to the left. 503| | 504| 202k| for (int i = 0; i < YR_MAX_ATOM_LENGTH - trim_left; i++) ------------------ | | 67| 202k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (504:19): [True: 151k, False: 50.6k] ------------------ 505| 151k| { 506| 151k| atom->bytes[i] = atom->bytes[trim_left + i]; 507| 151k| atom->mask[i] = atom->mask[trim_left + i]; 508| 151k| } 509| | 510| 50.6k| return trim_left; 511| 5.07M|} yr_atoms_extract_from_re: 1281| 8.78k|{ 1282| 8.78k| YR_ATOM_TREE* atom_tree = (YR_ATOM_TREE*) yr_malloc(sizeof(YR_ATOM_TREE)); 1283| | 1284| 8.78k| YR_ATOM_LIST_ITEM* wide_atoms; 1285| 8.78k| YR_ATOM_LIST_ITEM* case_insensitive_atoms; 1286| | 1287| 8.78k| if (atom_tree == NULL) ------------------ | Branch (1287:7): [True: 0, False: 8.78k] ------------------ 1288| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1289| | 1290| 8.78k| atom_tree->root_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 8.78k|#define ATOM_TREE_OR 3 ------------------ 1291| | 1292| 8.78k| if (atom_tree->root_node == NULL) ------------------ | Branch (1292:7): [True: 0, False: 8.78k] ------------------ 1293| 0| { 1294| 0| _yr_atoms_tree_destroy(atom_tree); 1295| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1296| 0| } 1297| | 1298| 8.78k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 8.78k| { \ | | 143| 8.78k| int __error = (x); \ | | 144| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 8.78k] | | ------------------ | | 145| 8.78k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 8.78k| } ------------------ 1299| 8.78k| _yr_atoms_extract_from_re(config, re_ast, atom_tree->root_node), 1300| 8.78k| _yr_atoms_tree_destroy(atom_tree)); 1301| | 1302| | // Initialize atom list 1303| 8.78k| *atoms = NULL; 1304| | 1305| | // Choose the atoms that will be used. 1306| 8.78k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 8.78k| { \ | | 143| 8.78k| int __error = (x); \ | | 144| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 8.78k] | | ------------------ | | 145| 8.78k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 8.78k| } ------------------ 1307| 8.78k| _yr_atoms_choose(config, atom_tree->root_node, atoms, min_atom_quality), 1308| 8.78k| _yr_atoms_tree_destroy(atom_tree)); 1309| | 1310| 8.78k| _yr_atoms_tree_destroy(atom_tree); 1311| | 1312| 8.78k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 8.78k| { \ | | 143| 8.78k| int __error = (x); \ | | 144| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 8.78k] | | ------------------ | | 145| 8.78k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 8.78k| } ------------------ 1313| 8.78k| _yr_atoms_expand_wildcards(*atoms), 1314| 8.78k| { // Cleanup 1315| 8.78k| yr_atoms_list_destroy(*atoms); 1316| 8.78k| *atoms = NULL; 1317| 8.78k| }); 1318| | 1319| | // Don't do convert atoms to wide here if either base64 modifier is used. 1320| | // This is to avoid the situation where we have "base64 wide" because 1321| | // the wide has already been applied BEFORE the base64 encoding. 1322| 8.78k| if (modifier.flags & STRING_FLAGS_WIDE && ------------------ | | 70| 17.5k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (1322:7): [True: 1.80k, False: 6.97k] ------------------ 1323| 8.78k| !(modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 3.61k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (1323:9): [True: 73, False: 1.73k] ------------------ 1324| 1.80k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 1.73k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (1324:9): [True: 321, False: 1.41k] ------------------ 1325| 1.41k| { 1326| 1.41k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.41k| { \ | | 143| 1.41k| int __error = (x); \ | | 144| 1.41k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.41k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.41k] | | ------------------ | | 145| 1.41k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.41k| } ------------------ 1327| 1.41k| _yr_atoms_wide(*atoms, &wide_atoms), 1328| 1.41k| { // Cleanup 1329| 1.41k| yr_atoms_list_destroy(*atoms); 1330| 1.41k| yr_atoms_list_destroy(wide_atoms); 1331| 1.41k| *atoms = NULL; 1332| 1.41k| }); 1333| | 1334| 1.41k| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 1.41k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (1334:9): [True: 462, False: 953] ------------------ 1335| 462| { 1336| 462| *atoms = _yr_atoms_list_concat(*atoms, wide_atoms); 1337| 462| } 1338| 953| else 1339| 953| { 1340| 953| yr_atoms_list_destroy(*atoms); 1341| 953| *atoms = wide_atoms; 1342| 953| } 1343| 1.41k| } 1344| | 1345| 8.78k| if (modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 8.78k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (1345:7): [True: 1.91k, False: 6.86k] ------------------ 1346| 1.91k| { 1347| 1.91k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.91k| { \ | | 143| 1.91k| int __error = (x); \ | | 144| 1.91k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.91k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.91k] | | ------------------ | | 145| 1.91k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.91k| } ------------------ 1348| 1.91k| _yr_atoms_case_insensitive(*atoms, &case_insensitive_atoms), 1349| 1.91k| { // Cleanup 1350| 1.91k| yr_atoms_list_destroy(*atoms); 1351| 1.91k| yr_atoms_list_destroy(case_insensitive_atoms); 1352| 1.91k| *atoms = NULL; 1353| 1.91k| }); 1354| | 1355| 1.91k| *atoms = _yr_atoms_list_concat(*atoms, case_insensitive_atoms); 1356| 1.91k| } 1357| | 1358| 8.78k| return ERROR_SUCCESS; ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ 1359| 8.78k|} yr_atoms_extract_from_string: 1371| 13.5k|{ 1372| 13.5k| YR_ATOM_LIST_ITEM* item; 1373| 13.5k| YR_ATOM_LIST_ITEM* case_insensitive_atoms; 1374| 13.5k| YR_ATOM_LIST_ITEM* xor_atoms; 1375| 13.5k| YR_ATOM_LIST_ITEM* wide_atoms; 1376| | 1377| 13.5k| YR_ATOM atom; 1378| | 1379| 13.5k| int quality, max_quality; 1380| 13.5k| int i; 1381| | 1382| 13.5k| item = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 1383| | 1384| 13.5k| if (item == NULL) ------------------ | Branch (1384:7): [True: 0, False: 13.5k] ------------------ 1385| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1386| | 1387| 13.5k| item->forward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 13.5k| (YR_ARENA_REF) \ | | 44| 13.5k| { \ | | 45| 13.5k| UINT32_MAX, UINT32_MAX \ | | 46| 13.5k| } ------------------ 1388| 13.5k| item->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 13.5k| (YR_ARENA_REF) \ | | 44| 13.5k| { \ | | 45| 13.5k| UINT32_MAX, UINT32_MAX \ | | 46| 13.5k| } ------------------ 1389| 13.5k| item->next = NULL; 1390| 13.5k| item->backtrack = 0; 1391| | 1392| 13.5k| item->atom.length = yr_min(string_length, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 13.5k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 9.29k, False: 4.21k] | | ------------------ ------------------ 1393| | 1394| 47.4k| for (i = 0; i < item->atom.length; i++) ------------------ | Branch (1394:15): [True: 33.9k, False: 13.5k] ------------------ 1395| 33.9k| { 1396| 33.9k| item->atom.bytes[i] = string[i]; 1397| 33.9k| item->atom.mask[i] = 0xFF; 1398| 33.9k| } 1399| | 1400| 13.5k| max_quality = config->get_atom_quality(config, &item->atom); 1401| | 1402| 13.5k| atom.length = YR_MAX_ATOM_LENGTH; ------------------ | | 67| 13.5k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1403| 13.5k| memset(atom.mask, 0xFF, atom.length); 1404| | 1405| 13.5k| for (i = YR_MAX_ATOM_LENGTH; ------------------ | | 67| 13.5k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1406| 44.3k| i < string_length && max_quality < YR_MAX_ATOM_QUALITY; ------------------ | | 71| 31.9k|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (1406:8): [True: 31.9k, False: 12.3k] | Branch (1406:29): [True: 30.8k, False: 1.17k] ------------------ 1407| 30.8k| i++) 1408| 30.8k| { 1409| 30.8k| atom.length = YR_MAX_ATOM_LENGTH; ------------------ | | 67| 30.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1410| 30.8k| memcpy(atom.bytes, string + i - YR_MAX_ATOM_LENGTH + 1, atom.length); ------------------ | | 67| 30.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1411| | 1412| 30.8k| quality = config->get_atom_quality(config, &atom); 1413| | 1414| 30.8k| if (quality > max_quality) ------------------ | Branch (1414:9): [True: 3.41k, False: 27.3k] ------------------ 1415| 3.41k| { 1416| 3.41k| memcpy(&item->atom, &atom, sizeof(atom)); 1417| 3.41k| item->backtrack = i - YR_MAX_ATOM_LENGTH + 1; ------------------ | | 67| 3.41k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1418| 3.41k| max_quality = quality; 1419| 3.41k| } 1420| 30.8k| } 1421| | 1422| 13.5k| *atoms = item; 1423| 13.5k| *min_atom_quality = max_quality; 1424| | 1425| 13.5k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 13.5k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (1425:7): [True: 1.49k, False: 12.0k] ------------------ 1426| 1.49k| { 1427| 1.49k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.49k| { \ | | 143| 1.49k| int __error = (x); \ | | 144| 1.49k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.49k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.49k] | | ------------------ | | 145| 1.49k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.49k| } ------------------ 1428| 1.49k| _yr_atoms_wide(*atoms, &wide_atoms), 1429| 1.49k| { // Cleanup 1430| 1.49k| yr_atoms_list_destroy(*atoms); 1431| 1.49k| yr_atoms_list_destroy(wide_atoms); 1432| 1.49k| *atoms = NULL; 1433| 1.49k| }); 1434| | 1435| 1.49k| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 1.49k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (1435:9): [True: 806, False: 689] ------------------ 1436| 806| { 1437| 806| *atoms = _yr_atoms_list_concat(*atoms, wide_atoms); 1438| 806| } 1439| 689| else 1440| 689| { 1441| 689| yr_atoms_list_destroy(*atoms); 1442| 689| *atoms = wide_atoms; 1443| 689| } 1444| 1.49k| } 1445| | 1446| 13.5k| if (modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 13.5k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (1446:7): [True: 2.99k, False: 10.5k] ------------------ 1447| 2.99k| { 1448| 2.99k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 2.99k| { \ | | 143| 2.99k| int __error = (x); \ | | 144| 2.99k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.99k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 2.99k] | | ------------------ | | 145| 2.99k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 2.99k| } ------------------ 1449| 2.99k| _yr_atoms_case_insensitive(*atoms, &case_insensitive_atoms), 1450| 2.99k| { // Cleanup 1451| 2.99k| yr_atoms_list_destroy(*atoms); 1452| 2.99k| yr_atoms_list_destroy(case_insensitive_atoms); 1453| 2.99k| *atoms = NULL; 1454| 2.99k| }); 1455| | 1456| 2.99k| *atoms = _yr_atoms_list_concat(*atoms, case_insensitive_atoms); 1457| 2.99k| } 1458| | 1459| 13.5k| if (modifier.flags & STRING_FLAGS_XOR) ------------------ | | 85| 13.5k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (1459:7): [True: 1.50k, False: 12.0k] ------------------ 1460| 1.50k| { 1461| 1.50k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.50k| { \ | | 143| 1.50k| int __error = (x); \ | | 144| 1.50k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.50k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.50k] | | ------------------ | | 145| 1.50k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.50k| } ------------------ 1462| 1.50k| _yr_atoms_xor(*atoms, modifier.xor_min, modifier.xor_max, &xor_atoms), 1463| 1.50k| { // Cleanup 1464| 1.50k| yr_atoms_list_destroy(*atoms); 1465| 1.50k| yr_atoms_list_destroy(xor_atoms); 1466| 1.50k| *atoms = NULL; 1467| 1.50k| }); 1468| | 1469| 1.50k| yr_atoms_list_destroy(*atoms); 1470| 1.50k| *atoms = xor_atoms; 1471| 1.50k| } 1472| | 1473| | // Recheck the atom quality, in case we have just generated some poor atoms. 1474| | // https://github.com/VirusTotal/yara/issues/1172 1475| 231k| for (item = *atoms; item != NULL; item = item->next) ------------------ | Branch (1475:23): [True: 218k, False: 13.5k] ------------------ 1476| 218k| { 1477| 218k| quality = config->get_atom_quality(config, &item->atom); 1478| 218k| if (quality < *min_atom_quality) ------------------ | Branch (1478:9): [True: 1.35k, False: 216k] ------------------ 1479| 1.35k| *min_atom_quality = quality; 1480| 218k| } 1481| | 1482| 13.5k| return ERROR_SUCCESS; ------------------ | | 40| 13.5k|#define ERROR_SUCCESS 0 ------------------ 1483| 13.5k|} atoms.c:_yr_atoms_tree_node_create: 339| 239k|{ 340| 239k| YR_ATOM_TREE_NODE* new_node = (YR_ATOM_TREE_NODE*) yr_malloc( 341| 239k| sizeof(YR_ATOM_TREE_NODE)); 342| | 343| 239k| if (new_node != NULL) ------------------ | Branch (343:7): [True: 239k, False: 0] ------------------ 344| 239k| { 345| 239k| new_node->type = type; 346| 239k| new_node->atom.length = 0; 347| 239k| new_node->next_sibling = NULL; 348| 239k| new_node->children_head = NULL; 349| 239k| new_node->children_tail = NULL; 350| 239k| } 351| | 352| 239k| return new_node; 353| 239k|} atoms.c:_yr_atoms_tree_destroy: 401| 8.78k|{ 402| 8.78k| _yr_atoms_tree_node_destroy(atom_tree->root_node); 403| 8.78k| yr_free(atom_tree); 404| 8.78k|} atoms.c:_yr_atoms_tree_node_destroy: 359| 239k|{ 360| 239k| YR_ATOM_TREE_NODE* child; 361| 239k| YR_ATOM_TREE_NODE* next_child; 362| | 363| 239k| if (node == NULL) ------------------ | Branch (363:7): [True: 0, False: 239k] ------------------ 364| 0| return; 365| | 366| 239k| if (node->type == ATOM_TREE_OR || node->type == ATOM_TREE_AND) ------------------ | | 38| 479k|#define ATOM_TREE_OR 3 ------------------ if (node->type == ATOM_TREE_OR || node->type == ATOM_TREE_AND) ------------------ | | 37| 209k|#define ATOM_TREE_AND 2 ------------------ | Branch (366:7): [True: 29.6k, False: 209k] | Branch (366:37): [True: 10.4k, False: 199k] ------------------ 367| 40.1k| { 368| 40.1k| child = node->children_head; 369| | 370| 270k| while (child != NULL) ------------------ | Branch (370:12): [True: 230k, False: 40.1k] ------------------ 371| 230k| { 372| 230k| next_child = child->next_sibling; 373| 230k| _yr_atoms_tree_node_destroy(child); 374| 230k| child = next_child; 375| 230k| } 376| 40.1k| } 377| | 378| 239k| yr_free(node); 379| 239k|} atoms.c:_yr_atoms_extract_from_re: 878| 8.78k|{ 879| 8.78k| YR_STACK* stack; 880| 8.78k| RE_NODE* re_node; 881| | 882| 8.78k| YR_ATOM atom = {0}; 883| 8.78k| YR_ATOM best_atom = {0}; 884| | 885| 8.78k| struct STACK_ITEM si; 886| | 887| 8.78k| int i, shift; 888| 8.78k| int quality; 889| 8.78k| int best_quality = -1; 890| 8.78k| int n = 0; 891| | 892| 8.78k| YR_ATOM_TREE_NODE* and_node; 893| 8.78k| YR_ATOM_TREE_NODE* left_node; 894| 8.78k| YR_ATOM_TREE_NODE* right_node; 895| | 896| | // The RE_NODEs most recently visited that can conform an atom (ie: 897| | // RE_NODE_LITERAL, RE_NODE_MASKED_LITERAL and RE_NODE_ANY). The number of 898| | // items in this array is n. 899| 8.78k| RE_NODE* recent_re_nodes[YR_MAX_ATOM_LENGTH]; 900| | 901| | // The RE_NODEs corresponding to the best atom found so far for the current 902| | // appending node. 903| 8.78k| RE_NODE* best_atom_re_nodes[YR_MAX_ATOM_LENGTH]; 904| | 905| | // This holds the ATOM_TREE_OR node where leaves (ATOM_TREE_LEAF) are 906| | // currently being appended. 907| 8.78k| YR_ATOM_TREE_NODE* current_appending_node = NULL; 908| | 909| | // This holds the ATOM_TREE_LEAF node whose atom is currently being updated. 910| 8.78k| YR_ATOM_TREE_NODE* leaf = NULL; 911| | 912| 8.78k| FAIL_ON_ERROR(yr_stack_create(1024, sizeof(si), &stack)); ------------------ | | 134| 8.78k| { \ | | 135| 8.78k| int __error = (x); \ | | 136| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 8.78k] | | ------------------ | | 137| 8.78k| return __error; \ | | 138| 8.78k| } ------------------ 913| | 914| | // This first item pushed in the stack is the last one to be poped out, the 915| | // sole purpose of this item is forcing that any pending leaf is appended to 916| | // appending_node during the last iteration of the loop. 917| 8.78k| si.re_node = NULL; 918| 8.78k| si.new_appending_node = appending_node; 919| | 920| 8.78k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 8.78k| { \ | | 143| 8.78k| int __error = (x); \ | | 144| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 8.78k] | | ------------------ | | 145| 8.78k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 8.78k| } ------------------ 921| 8.78k| yr_stack_push(stack, (void*) &si), yr_stack_destroy(stack)); 922| | 923| | // Start processing the root node. 924| 8.78k| si.re_node = re_ast->root_node; 925| | 926| | // Leaf nodes are initially appended to the node passed in the appending_node, 927| | // argument which is the root ATOM_TREE_OR node that is empty at this point. 928| 8.78k| si.new_appending_node = appending_node; 929| | 930| 8.78k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 8.78k| { \ | | 143| 8.78k| int __error = (x); \ | | 144| 8.78k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 8.78k] | | ------------------ | | 145| 8.78k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 8.78k| } ------------------ 931| 8.78k| yr_stack_push(stack, (void*) &si), yr_stack_destroy(stack)); 932| | 933| 8.11M| while (yr_stack_pop(stack, (void*) &si)) ------------------ | Branch (933:10): [True: 8.10M, False: 8.78k] ------------------ 934| 8.10M| { 935| | // Change the appending node if the item poped from the stack says so. 936| 8.10M| if (si.new_appending_node != NULL) ------------------ | Branch (936:9): [True: 498k, False: 7.60M] ------------------ 937| 498k| { 938| | // Before changing the appending node let's append any pending leaf to 939| | // the current appending node. 940| 498k| if (n > 0) ------------------ | Branch (940:11): [True: 199k, False: 299k] ------------------ 941| 199k| { 942| 199k| make_atom_from_re_nodes(atom, n, recent_re_nodes); ------------------ | | 858| 199k| { \ | | 859| 199k| atom.length = nodes_length; \ | | 860| 789k| for (i = 0; i < atom.length; i++) \ | | ------------------ | | | Branch (860:17): [True: 590k, False: 199k] | | ------------------ | | 861| 590k| { \ | | 862| 590k| atom.bytes[i] = (uint8_t) (recent_re_nodes)[i]->value; \ | | 863| 590k| atom.mask[i] = (uint8_t) (recent_re_nodes)[i]->mask; \ | | 864| 590k| } \ | | 865| 199k| } ------------------ 943| 199k| shift = _yr_atoms_trim(&atom); 944| 199k| quality = config->get_atom_quality(config, &atom); 945| | 946| 199k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 152| 199k| { \ | | 153| 199k| if ((x) == NULL) \ | | ------------------ | | | Branch (153:9): [True: 0, False: 199k] | | ------------------ | | 154| 199k| { \ | | 155| 0| cleanup; \ | | 156| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 157| 0| } \ | | 158| 199k| } ------------------ 947| 199k| leaf = _yr_atoms_tree_node_create(ATOM_TREE_LEAF), 948| 199k| yr_stack_destroy(stack)); 949| | 950| 199k| if (quality > best_quality) ------------------ | Branch (950:13): [True: 93.3k, False: 106k] ------------------ 951| 93.3k| { 952| 93.3k| memcpy(&leaf->atom, &atom, sizeof(atom)); 953| 93.3k| memcpy( 954| 93.3k| &leaf->re_nodes, 955| 93.3k| &recent_re_nodes[shift], 956| 93.3k| sizeof(recent_re_nodes) - shift * sizeof(recent_re_nodes[0])); 957| 93.3k| } 958| 106k| else 959| 106k| { 960| 106k| memcpy(&leaf->atom, &best_atom, sizeof(best_atom)); 961| 106k| memcpy( 962| 106k| &leaf->re_nodes, &best_atom_re_nodes, sizeof(best_atom_re_nodes)); 963| 106k| } 964| | 965| 199k| _yr_atoms_tree_node_append(current_appending_node, leaf); 966| 199k| n = 0; 967| 199k| } 968| | 969| 498k| current_appending_node = si.new_appending_node; 970| 498k| best_quality = -1; 971| 498k| } 972| | 973| 8.10M| if (si.re_node != NULL) ------------------ | Branch (973:9): [True: 7.63M, False: 469k] ------------------ 974| 7.63M| { 975| 7.63M| switch (si.re_node->type) 976| 7.63M| { 977| 6.81M| case RE_NODE_LITERAL: ------------------ | | 41| 6.81M|#define RE_NODE_LITERAL 1 ------------------ | Branch (977:7): [True: 6.81M, False: 818k] ------------------ 978| 6.82M| case RE_NODE_MASKED_LITERAL: ------------------ | | 42| 6.82M|#define RE_NODE_MASKED_LITERAL 2 ------------------ | Branch (978:7): [True: 2.44k, False: 7.63M] ------------------ 979| 6.92M| case RE_NODE_ANY: ------------------ | | 43| 6.92M|#define RE_NODE_ANY 3 ------------------ | Branch (979:7): [True: 105k, False: 7.53M] ------------------ 980| | 981| 6.92M| if (n < YR_MAX_ATOM_LENGTH) ------------------ | | 67| 6.92M|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (981:13): [True: 590k, False: 6.33M] ------------------ 982| 590k| { 983| 590k| recent_re_nodes[n] = si.re_node; 984| 590k| best_atom_re_nodes[n] = si.re_node; 985| 590k| best_atom.bytes[n] = (uint8_t) si.re_node->value; 986| 590k| best_atom.mask[n] = (uint8_t) si.re_node->mask; 987| 590k| best_atom.length = ++n; 988| 590k| } 989| 6.33M| else if (best_quality < YR_MAX_ATOM_QUALITY) ------------------ | | 71| 6.33M|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (989:18): [True: 4.88M, False: 1.44M] ------------------ 990| 4.88M| { 991| 4.88M| make_atom_from_re_nodes(atom, n, recent_re_nodes); ------------------ | | 858| 4.88M| { \ | | 859| 4.88M| atom.length = nodes_length; \ | | 860| 24.4M| for (i = 0; i < atom.length; i++) \ | | ------------------ | | | Branch (860:17): [True: 19.5M, False: 4.88M] | | ------------------ | | 861| 19.5M| { \ | | 862| 19.5M| atom.bytes[i] = (uint8_t) (recent_re_nodes)[i]->value; \ | | 863| 19.5M| atom.mask[i] = (uint8_t) (recent_re_nodes)[i]->mask; \ | | 864| 19.5M| } \ | | 865| 4.88M| } ------------------ 992| 4.88M| shift = _yr_atoms_trim(&atom); 993| 4.88M| quality = config->get_atom_quality(config, &atom); 994| | 995| 4.88M| if (quality > best_quality) ------------------ | Branch (995:15): [True: 384k, False: 4.50M] ------------------ 996| 384k| { 997| 1.91M| for (i = 0; i < atom.length; i++) ------------------ | Branch (997:25): [True: 1.53M, False: 384k] ------------------ 998| 1.53M| { 999| 1.53M| best_atom.bytes[i] = atom.bytes[i]; 1000| 1.53M| best_atom.mask[i] = atom.mask[i]; 1001| 1.53M| best_atom_re_nodes[i] = recent_re_nodes[i + shift]; 1002| 1.53M| } 1003| | 1004| 384k| best_atom.length = atom.length; 1005| 384k| best_quality = quality; 1006| 384k| } 1007| | 1008| 19.5M| for (i = 1; i < YR_MAX_ATOM_LENGTH; i++) ------------------ | | 67| 19.5M|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (1008:23): [True: 14.6M, False: 4.88M] ------------------ 1009| 14.6M| recent_re_nodes[i - 1] = recent_re_nodes[i]; 1010| | 1011| 4.88M| recent_re_nodes[YR_MAX_ATOM_LENGTH - 1] = si.re_node; ------------------ | | 67| 4.88M|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1012| 4.88M| } 1013| | 1014| 6.92M| break; 1015| | 1016| 249k| case RE_NODE_CONCAT: ------------------ | | 44| 249k|#define RE_NODE_CONCAT 4 ------------------ | Branch (1016:7): [True: 249k, False: 7.38M] ------------------ 1017| | 1018| 249k| re_node = si.re_node->children_tail; 1019| | 1020| | // Push children right to left, they are poped left to right. 1021| 7.67M| while (re_node != NULL) ------------------ | Branch (1021:16): [True: 7.42M, False: 249k] ------------------ 1022| 7.42M| { 1023| 7.42M| si.new_appending_node = NULL; 1024| 7.42M| si.re_node = re_node; 1025| | 1026| 7.42M| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 7.42M| { \ | | 143| 7.42M| int __error = (x); \ | | 144| 7.42M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.42M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 7.42M] | | ------------------ | | 145| 7.42M| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 7.42M| } ------------------ 1027| 7.42M| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1028| | 1029| 7.42M| re_node = re_node->prev_sibling; 1030| 7.42M| } 1031| | 1032| 249k| break; 1033| | 1034| 249k| case RE_NODE_ALT: ------------------ | | 45| 10.4k|#define RE_NODE_ALT 5 ------------------ | Branch (1034:7): [True: 10.4k, False: 7.62M] ------------------ 1035| | 1036| | // Create ATOM_TREE_AND node with two ATOM_TREE_OR children nodes. 1037| 10.4k| and_node = _yr_atoms_tree_node_create(ATOM_TREE_AND); ------------------ | | 37| 10.4k|#define ATOM_TREE_AND 2 ------------------ 1038| 10.4k| left_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 10.4k|#define ATOM_TREE_OR 3 ------------------ 1039| 10.4k| right_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 10.4k|#define ATOM_TREE_OR 3 ------------------ 1040| | 1041| 10.4k| if (and_node == NULL || left_node == NULL || right_node == NULL) ------------------ | Branch (1041:13): [True: 0, False: 10.4k] | Branch (1041:33): [True: 0, False: 10.4k] | Branch (1041:54): [True: 0, False: 10.4k] ------------------ 1042| 0| { 1043| 0| _yr_atoms_tree_node_destroy(and_node); 1044| 0| _yr_atoms_tree_node_destroy(left_node); 1045| 0| _yr_atoms_tree_node_destroy(right_node); 1046| | 1047| 0| yr_stack_destroy(stack); 1048| | 1049| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1050| 0| } 1051| | 1052| 10.4k| and_node->children_head = left_node; 1053| 10.4k| and_node->children_tail = right_node; 1054| 10.4k| left_node->next_sibling = right_node; 1055| | 1056| | // Add the ATOM_TREE_AND as children of the current node. 1057| 10.4k| _yr_atoms_tree_node_append(current_appending_node, and_node); 1058| | 1059| 10.4k| re_node = si.re_node; 1060| | 1061| 10.4k| si.new_appending_node = current_appending_node; 1062| 10.4k| si.re_node = NULL; 1063| | 1064| 10.4k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 10.4k| { \ | | 143| 10.4k| int __error = (x); \ | | 144| 10.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 10.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 10.4k] | | ------------------ | | 145| 10.4k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 10.4k| } ------------------ 1065| 10.4k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1066| | 1067| | // RE_NODE_ALT nodes has only two children, so children_head is the 1068| | // left one, and children_tail is right one. 1069| 10.4k| si.new_appending_node = right_node; 1070| 10.4k| si.re_node = re_node->children_tail; 1071| | 1072| 10.4k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 10.4k| { \ | | 143| 10.4k| int __error = (x); \ | | 144| 10.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 10.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 10.4k] | | ------------------ | | 145| 10.4k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 10.4k| } ------------------ 1073| 10.4k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1074| | 1075| 10.4k| si.new_appending_node = left_node; 1076| 10.4k| si.re_node = re_node->children_head; 1077| | 1078| 10.4k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 10.4k| { \ | | 143| 10.4k| int __error = (x); \ | | 144| 10.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 10.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 10.4k] | | ------------------ | | 145| 10.4k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 10.4k| } ------------------ 1079| 10.4k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1080| | 1081| 10.4k| break; 1082| | 1083| 798| case RE_NODE_PLUS: ------------------ | | 48| 798|#define RE_NODE_PLUS 8 ------------------ | Branch (1083:7): [True: 798, False: 7.63M] ------------------ 1084| | 1085| 798| re_node = si.re_node; 1086| | 1087| 798| si.new_appending_node = current_appending_node; 1088| 798| si.re_node = NULL; 1089| | 1090| 798| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 798| { \ | | 143| 798| int __error = (x); \ | | 144| 798| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 798|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 798] | | ------------------ | | 145| 798| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 798| } ------------------ 1091| 798| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1092| | 1093| 798| si.new_appending_node = NULL; 1094| | // RE_NODE_PLUS nodes has a single child, which is children_head. 1095| 798| si.re_node = re_node->children_head; 1096| | 1097| 798| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 798| { \ | | 143| 798| int __error = (x); \ | | 144| 798| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 798|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 798] | | ------------------ | | 145| 798| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 798| } ------------------ 1098| 798| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1099| | 1100| 798| break; 1101| | 1102| 61.1k| case RE_NODE_RANGE: ------------------ | | 46| 61.1k|#define RE_NODE_RANGE 6 ------------------ | Branch (1102:7): [True: 61.1k, False: 7.57M] ------------------ 1103| | 1104| 61.1k| re_node = si.re_node; 1105| | 1106| 61.1k| si.new_appending_node = current_appending_node; 1107| 61.1k| si.re_node = NULL; 1108| | 1109| 61.1k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 61.1k| { \ | | 143| 61.1k| int __error = (x); \ | | 144| 61.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 61.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 61.1k] | | ------------------ | | 145| 61.1k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 61.1k| } ------------------ 1110| 61.1k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1111| | 1112| 61.1k| si.new_appending_node = NULL; 1113| | 1114| | // RE_NODE_RANGE nodes has a single child, which is children_head. 1115| 61.1k| si.re_node = re_node->children_head; 1116| | 1117| | // In a regexp like /a{10,20}/ the optimal atom is 'aaaa' (assuming 1118| | // that YR_MAX_ATOM_LENGTH = 4) because the 'a' character must appear 1119| | // at least 10 times in the matching string. Each call in the loop 1120| | // will append one 'a' to the atom, so YR_MAX_ATOM_LENGTH iterations 1121| | // are enough. 1122| | 1123| 247k| for (i = 0; i < yr_min(re_node->start, YR_MAX_ATOM_LENGTH); i++) ------------------ | | 107| 247k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 225k, False: 22.5k] | | ------------------ ------------------ | Branch (1123:21): [True: 186k, False: 61.1k] ------------------ 1124| 186k| { 1125| 186k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 186k| { \ | | 143| 186k| int __error = (x); \ | | 144| 186k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 186k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 186k] | | ------------------ | | 145| 186k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 186k| } ------------------ 1126| 186k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1127| 186k| } 1128| | 1129| 61.1k| break; 1130| | 1131| 61.1k| case RE_NODE_RANGE_ANY: ------------------ | | 61| 3.57k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (1131:7): [True: 3.57k, False: 7.63M] ------------------ 1132| 4.01k| case RE_NODE_STAR: ------------------ | | 47| 4.01k|#define RE_NODE_STAR 7 ------------------ | Branch (1132:7): [True: 435, False: 7.63M] ------------------ 1133| 5.15k| case RE_NODE_CLASS: ------------------ | | 49| 5.15k|#define RE_NODE_CLASS 9 ------------------ | Branch (1133:7): [True: 1.14k, False: 7.63M] ------------------ 1134| 5.29k| case RE_NODE_WORD_CHAR: ------------------ | | 50| 5.29k|#define RE_NODE_WORD_CHAR 10 ------------------ | Branch (1134:7): [True: 133, False: 7.63M] ------------------ 1135| 5.49k| case RE_NODE_NON_WORD_CHAR: ------------------ | | 51| 5.49k|#define RE_NODE_NON_WORD_CHAR 11 ------------------ | Branch (1135:7): [True: 203, False: 7.63M] ------------------ 1136| 5.49k| case RE_NODE_SPACE: ------------------ | | 52| 5.49k|#define RE_NODE_SPACE 12 ------------------ | Branch (1136:7): [True: 0, False: 7.63M] ------------------ 1137| 5.63k| case RE_NODE_NON_SPACE: ------------------ | | 53| 5.63k|#define RE_NODE_NON_SPACE 13 ------------------ | Branch (1137:7): [True: 135, False: 7.63M] ------------------ 1138| 5.77k| case RE_NODE_DIGIT: ------------------ | | 54| 5.77k|#define RE_NODE_DIGIT 14 ------------------ | Branch (1138:7): [True: 146, False: 7.63M] ------------------ 1139| 5.78k| case RE_NODE_NON_DIGIT: ------------------ | | 55| 5.78k|#define RE_NODE_NON_DIGIT 15 ------------------ | Branch (1139:7): [True: 9, False: 7.63M] ------------------ 1140| 6.11k| case RE_NODE_EMPTY: ------------------ | | 56| 6.11k|#define RE_NODE_EMPTY 16 ------------------ | Branch (1140:7): [True: 330, False: 7.63M] ------------------ 1141| 349k| case RE_NODE_ANCHOR_START: ------------------ | | 57| 349k|#define RE_NODE_ANCHOR_START 17 ------------------ | Branch (1141:7): [True: 342k, False: 7.29M] ------------------ 1142| 387k| case RE_NODE_ANCHOR_END: ------------------ | | 58| 387k|#define RE_NODE_ANCHOR_END 18 ------------------ | Branch (1142:7): [True: 37.9k, False: 7.59M] ------------------ 1143| 387k| case RE_NODE_WORD_BOUNDARY: ------------------ | | 59| 387k|#define RE_NODE_WORD_BOUNDARY 19 ------------------ | Branch (1143:7): [True: 134, False: 7.63M] ------------------ 1144| 387k| case RE_NODE_NON_WORD_BOUNDARY: ------------------ | | 60| 387k|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ | Branch (1144:7): [True: 131, False: 7.63M] ------------------ 1145| 387k| case RE_NODE_NOT_LITERAL: ------------------ | | 62| 387k|#define RE_NODE_NOT_LITERAL 22 ------------------ | Branch (1145:7): [True: 282, False: 7.63M] ------------------ 1146| 388k| case RE_NODE_MASKED_NOT_LITERAL: ------------------ | | 63| 388k|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ | Branch (1146:7): [True: 505, False: 7.63M] ------------------ 1147| | 1148| 388k| si.new_appending_node = current_appending_node; 1149| 388k| si.re_node = NULL; 1150| | 1151| 388k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 388k| { \ | | 143| 388k| int __error = (x); \ | | 144| 388k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 388k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 388k] | | ------------------ | | 145| 388k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 388k| } ------------------ 1152| 388k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1153| | 1154| 388k| break; 1155| | 1156| 0| default: ------------------ | Branch (1156:7): [True: 0, False: 7.63M] ------------------ 1157| 0| assert(false); 1158| 7.63M| } 1159| 7.63M| } 1160| 8.10M| } 1161| | 1162| 8.78k| yr_stack_destroy(stack); 1163| | 1164| 8.78k| return ERROR_SUCCESS; ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ 1165| 8.78k|} atoms.c:_yr_atoms_tree_node_append: 387| 209k|{ 388| 209k| if (dest->children_head == NULL) ------------------ | Branch (388:7): [True: 26.9k, False: 183k] ------------------ 389| 26.9k| dest->children_head = node; 390| | 391| 209k| if (dest->children_tail != NULL) ------------------ | Branch (391:7): [True: 183k, False: 26.9k] ------------------ 392| 183k| dest->children_tail->next_sibling = node; 393| | 394| 209k| dest->children_tail = node; 395| 209k|} atoms.c:_yr_atoms_choose: 522| 62.7k|{ 523| 62.7k| YR_ATOM_TREE_NODE* child; 524| 62.7k| YR_ATOM_LIST_ITEM* item; 525| 62.7k| YR_ATOM_LIST_ITEM* tail; 526| | 527| 62.7k| int shift, quality; 528| | 529| 62.7k| int max_quality = YR_MIN_ATOM_QUALITY; ------------------ | | 75| 62.7k|#define YR_MIN_ATOM_QUALITY 0 ------------------ 530| 62.7k| int min_quality = YR_MAX_ATOM_QUALITY; ------------------ | | 71| 62.7k|#define YR_MAX_ATOM_QUALITY 255 ------------------ 531| | 532| 62.7k| *chosen_atoms = NULL; 533| 62.7k| *atoms_quality = YR_MIN_ATOM_QUALITY; ------------------ | | 75| 62.7k|#define YR_MIN_ATOM_QUALITY 0 ------------------ 534| | 535| 62.7k| switch (node->type) ------------------ | Branch (535:11): [True: 0, False: 62.7k] ------------------ 536| 62.7k| { 537| 23.0k| case ATOM_TREE_LEAF: ------------------ | | 36| 23.0k|#define ATOM_TREE_LEAF 1 ------------------ | Branch (537:3): [True: 23.0k, False: 39.6k] ------------------ 538| | 539| 23.0k| item = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 540| | 541| 23.0k| if (item == NULL) ------------------ | Branch (541:9): [True: 0, False: 23.0k] ------------------ 542| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 543| | 544| 23.0k| memcpy(&item->atom, &node->atom, sizeof(YR_ATOM)); 545| | 546| 23.0k| shift = _yr_atoms_trim(&item->atom); 547| | 548| 23.0k| if (item->atom.length > 0) ------------------ | Branch (548:9): [True: 20.6k, False: 2.39k] ------------------ 549| 20.6k| { 550| 20.6k| item->forward_code_ref = node->re_nodes[shift]->forward_code_ref; 551| 20.6k| item->backward_code_ref = node->re_nodes[shift]->backward_code_ref; 552| 20.6k| item->backtrack = 0; 553| 20.6k| item->next = NULL; 554| | 555| 20.6k| *chosen_atoms = item; 556| 20.6k| *atoms_quality = config->get_atom_quality(config, &item->atom); 557| 20.6k| } 558| 2.39k| else 559| 2.39k| { 560| 2.39k| yr_free(item); 561| 2.39k| } 562| | 563| 23.0k| break; 564| | 565| 29.3k| case ATOM_TREE_OR: ------------------ | | 38| 29.3k|#define ATOM_TREE_OR 3 ------------------ | Branch (565:3): [True: 29.3k, False: 33.3k] ------------------ 566| | 567| | // The choosen nodes are those coming from the highest quality child. 568| | 569| 29.3k| child = node->children_head; 570| | 571| 61.8k| while (child != NULL) ------------------ | Branch (571:12): [True: 33.3k, False: 28.5k] ------------------ 572| 33.3k| { 573| 33.3k| FAIL_ON_ERROR(_yr_atoms_choose(config, child, &item, &quality)); ------------------ | | 134| 33.3k| { \ | | 135| 33.3k| int __error = (x); \ | | 136| 33.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 33.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 33.3k] | | ------------------ | | 137| 33.3k| return __error; \ | | 138| 33.3k| } ------------------ 574| | 575| 33.3k| if (quality > max_quality) ------------------ | Branch (575:11): [True: 25.6k, False: 7.67k] ------------------ 576| 25.6k| { 577| 25.6k| max_quality = quality; 578| 25.6k| yr_atoms_list_destroy(*chosen_atoms); 579| 25.6k| *chosen_atoms = item; 580| 25.6k| } 581| 7.67k| else 582| 7.67k| { 583| 7.67k| yr_atoms_list_destroy(item); 584| 7.67k| } 585| | 586| 33.3k| if (max_quality == YR_MAX_ATOM_QUALITY) ------------------ | | 71| 33.3k|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (586:11): [True: 863, False: 32.4k] ------------------ 587| 863| break; 588| | 589| 32.4k| child = child->next_sibling; 590| 32.4k| } 591| | 592| 29.3k| *atoms_quality = max_quality; 593| 29.3k| break; 594| | 595| 10.3k| case ATOM_TREE_AND: ------------------ | | 37| 10.3k|#define ATOM_TREE_AND 2 ------------------ | Branch (595:3): [True: 10.3k, False: 52.4k] ------------------ 596| | 597| | // The choosen nodes are the concatenation of the the nodes choosen from 598| | // all the children. 599| | 600| 10.3k| child = node->children_head; 601| | 602| 30.9k| while (child != NULL) ------------------ | Branch (602:12): [True: 20.6k, False: 10.3k] ------------------ 603| 20.6k| { 604| 20.6k| FAIL_ON_ERROR(_yr_atoms_choose(config, child, &item, &quality)); ------------------ | | 134| 20.6k| { \ | | 135| 20.6k| int __error = (x); \ | | 136| 20.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 20.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 20.6k] | | ------------------ | | 137| 20.6k| return __error; \ | | 138| 20.6k| } ------------------ 605| | 606| 20.6k| if (quality < min_quality) ------------------ | Branch (606:11): [True: 11.0k, False: 9.59k] ------------------ 607| 11.0k| min_quality = quality; 608| | 609| 20.6k| if (item != NULL) ------------------ | Branch (609:11): [True: 19.8k, False: 725] ------------------ 610| 19.8k| { 611| 19.8k| tail = item; 612| 133k| while (tail->next != NULL) tail = tail->next; ------------------ | Branch (612:16): [True: 113k, False: 19.8k] ------------------ 613| | 614| 19.8k| tail->next = *chosen_atoms; 615| 19.8k| *chosen_atoms = item; 616| 19.8k| } 617| | 618| 20.6k| child = child->next_sibling; 619| 20.6k| } 620| | 621| 10.3k| *atoms_quality = min_quality; 622| 10.3k| break; 623| 62.7k| } 624| | 625| 62.7k| return ERROR_SUCCESS; ------------------ | | 40| 62.7k|#define ERROR_SUCCESS 0 ------------------ 626| 62.7k|} atoms.c:_yr_atoms_expand_wildcards: 1197| 8.78k|{ 1198| 8.78k| int i; 1199| | 1200| 8.78k| YR_ATOM_LIST_ITEM* atom = atoms; 1201| 8.78k| YR_ATOM_LIST_ITEM* new_atom; 1202| 8.78k| YR_ATOM_LIST_ITEM* prev_atom; 1203| 8.78k| YR_ATOM_LIST_ITEM* next_atom; 1204| | 1205| 718k| while (atom != NULL) ------------------ | Branch (1205:10): [True: 710k, False: 8.78k] ------------------ 1206| 710k| { 1207| 710k| bool expanded = false; 1208| | 1209| 3.44M| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (1209:17): [True: 2.73M, False: 710k] ------------------ 1210| 2.73M| { 1211| 2.73M| uint16_t a, s, e, incr = 1; 1212| | 1213| 2.73M| switch (atom->atom.mask[i]) 1214| 2.73M| { 1215| 2.27k| case 0x00: ------------------ | Branch (1215:7): [True: 2.27k, False: 2.73M] ------------------ 1216| 2.27k| expanded = true; 1217| 2.27k| s = 0x00; 1218| 2.27k| e = 0xFF; 1219| 2.27k| break; 1220| | 1221| 755| case 0x0F: ------------------ | Branch (1221:7): [True: 755, False: 2.73M] ------------------ 1222| 755| expanded = true; 1223| 755| s = atom->atom.bytes[i]; 1224| 755| e = atom->atom.bytes[i] | 0xF0; 1225| 755| incr = 0x10; 1226| 755| break; 1227| | 1228| 6.34k| case 0xF0: ------------------ | Branch (1228:7): [True: 6.34k, False: 2.72M] ------------------ 1229| 6.34k| expanded = true; 1230| 6.34k| s = atom->atom.bytes[i]; 1231| 6.34k| e = atom->atom.bytes[i] | 0x0F; 1232| 6.34k| break; 1233| | 1234| 2.72M| default: ------------------ | Branch (1234:7): [True: 2.72M, False: 9.37k] ------------------ 1235| 2.72M| s = 0; 1236| 2.72M| e = 0; 1237| 2.73M| } 1238| | 1239| 2.73M| if (s != e) ------------------ | Branch (1239:11): [True: 9.37k, False: 2.72M] ------------------ 1240| 9.37k| { 1241| 9.37k| atom->atom.bytes[i] = (uint8_t) s; 1242| 9.37k| atom->atom.mask[i] = 0xFF; 1243| 9.37k| } 1244| | 1245| 2.73M| prev_atom = atom; 1246| 2.73M| next_atom = atom->next; 1247| | 1248| 3.42M| for (a = s + incr; a <= e; a += incr) ------------------ | Branch (1248:26): [True: 686k, False: 2.73M] ------------------ 1249| 686k| { 1250| 686k| new_atom = _yr_atoms_clone_list_item(atom); 1251| | 1252| 686k| if (new_atom == NULL) ------------------ | Branch (1252:13): [True: 0, False: 686k] ------------------ 1253| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1254| | 1255| 686k| new_atom->atom.bytes[i] = (uint8_t) a; 1256| 686k| new_atom->atom.mask[i] = 0xFF; 1257| 686k| new_atom->next = next_atom; 1258| 686k| prev_atom->next = new_atom; 1259| 686k| prev_atom = new_atom; 1260| 686k| } 1261| 2.73M| } 1262| | 1263| 710k| if (!expanded) ------------------ | Branch (1263:9): [True: 701k, False: 8.97k] ------------------ 1264| 701k| atom = atom->next; 1265| 710k| } 1266| | 1267| 8.78k| return ERROR_SUCCESS; ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ 1268| 8.78k|} atoms.c:_yr_atoms_clone_list_item: 1171| 686k|{ 1172| 686k| YR_ATOM_LIST_ITEM* clone = (YR_ATOM_LIST_ITEM*) yr_malloc( 1173| 686k| sizeof(YR_ATOM_LIST_ITEM)); 1174| | 1175| 686k| if (clone == NULL) ------------------ | Branch (1175:7): [True: 0, False: 686k] ------------------ 1176| 0| return NULL; 1177| | 1178| 686k| memcpy(clone, item, sizeof(YR_ATOM_LIST_ITEM)); 1179| | 1180| 686k| return clone; 1181| 686k|} atoms.c:_yr_atoms_wide: 807| 2.91k|{ 808| 2.91k| YR_ATOM_LIST_ITEM* atom; 809| 2.91k| YR_ATOM_LIST_ITEM* new_atom; 810| | 811| 2.91k| int i; 812| | 813| 2.91k| *wide_atoms = NULL; 814| 2.91k| atom = atoms; 815| | 816| 12.0k| while (atom != NULL) ------------------ | Branch (816:10): [True: 9.16k, False: 2.91k] ------------------ 817| 9.16k| { 818| 9.16k| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 819| | 820| 9.16k| if (new_atom == NULL) ------------------ | Branch (820:9): [True: 0, False: 9.16k] ------------------ 821| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 822| | 823| 45.8k| for (i = 0; i < YR_MAX_ATOM_LENGTH; i++) ------------------ | | 67| 45.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (823:17): [True: 36.6k, False: 9.16k] ------------------ 824| 36.6k| { 825| 36.6k| new_atom->atom.bytes[i] = 0; 826| 36.6k| new_atom->atom.mask[i] = 0xFF; 827| 36.6k| } 828| | 829| 26.4k| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (829:17): [True: 24.9k, False: 1.53k] ------------------ 830| 24.9k| { 831| 24.9k| if (i * 2 < YR_MAX_ATOM_LENGTH) ------------------ | | 67| 24.9k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (831:11): [True: 17.2k, False: 7.62k] ------------------ 832| 17.2k| new_atom->atom.bytes[i * 2] = atom->atom.bytes[i]; 833| 7.62k| else 834| 7.62k| break; 835| 24.9k| } 836| | 837| 9.16k| new_atom->atom.length = yr_min(atom->atom.length * 2, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 9.16k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 1.03k, False: 8.12k] | | ------------------ ------------------ 838| 9.16k| new_atom->forward_code_ref = atom->forward_code_ref; 839| 9.16k| new_atom->backward_code_ref = atom->backward_code_ref; 840| 9.16k| new_atom->backtrack = atom->backtrack * 2; 841| 9.16k| new_atom->next = *wide_atoms; 842| | 843| 9.16k| *wide_atoms = new_atom; 844| | 845| 9.16k| atom = atom->next; 846| 9.16k| } 847| | 848| 2.91k| return ERROR_SUCCESS; ------------------ | | 40| 2.91k|#define ERROR_SUCCESS 0 ------------------ 849| 2.91k|} atoms.c:_yr_atoms_list_concat: 428| 6.18k|{ 429| 6.18k| YR_ATOM_LIST_ITEM* item; 430| | 431| 6.18k| if (list1 == NULL) ------------------ | Branch (431:7): [True: 1.21k, False: 4.97k] ------------------ 432| 1.21k| return list2; 433| | 434| 4.97k| item = list1; 435| | 436| 491k| while (item->next != NULL) ------------------ | Branch (436:10): [True: 486k, False: 4.97k] ------------------ 437| 486k| { 438| 486k| item = item->next; 439| 486k| } 440| | 441| 4.97k| item->next = list2; 442| 4.97k| return list1; 443| 6.18k|} atoms.c:_yr_atoms_case_insensitive: 700| 4.91k|{ 701| 4.91k| YR_ATOM_LIST_ITEM* atom; 702| 4.91k| YR_ATOM_LIST_ITEM* new_atom; 703| | 704| 4.91k| uint8_t buffer[CASE_COMBINATIONS_BUFFER_SIZE]; 705| 4.91k| uint8_t atom_length; 706| 4.91k| uint8_t* atoms_cursor; 707| | 708| 4.91k| int i; 709| | 710| 4.91k| *case_insensitive_atoms = NULL; 711| 4.91k| atom = atoms; 712| | 713| 490k| while (atom != NULL) ------------------ | Branch (713:10): [True: 485k, False: 4.91k] ------------------ 714| 485k| { 715| 485k| _yr_atoms_case_combinations(atom->atom.bytes, atom->atom.length, 0, buffer); 716| | 717| 485k| atoms_cursor = buffer; 718| 485k| atom_length = *atoms_cursor; 719| 485k| atoms_cursor++; 720| | 721| 4.39M| while (atom_length != 0) ------------------ | Branch (721:12): [True: 3.90M, False: 485k] ------------------ 722| 3.90M| { 723| 3.90M| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 724| | 725| 3.90M| if (new_atom == NULL) ------------------ | Branch (725:11): [True: 0, False: 3.90M] ------------------ 726| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 727| | 728| 19.4M| for (i = 0; i < atom_length; i++) ------------------ | Branch (728:19): [True: 15.5M, False: 3.90M] ------------------ 729| 15.5M| { 730| 15.5M| new_atom->atom.bytes[i] = atoms_cursor[i]; 731| 15.5M| new_atom->atom.mask[i] = 0xFF; 732| 15.5M| } 733| | 734| 3.90M| new_atom->atom.length = atom_length; 735| 3.90M| new_atom->forward_code_ref = atom->forward_code_ref; 736| 3.90M| new_atom->backward_code_ref = atom->backward_code_ref; 737| 3.90M| new_atom->backtrack = atom->backtrack; 738| 3.90M| new_atom->next = *case_insensitive_atoms; 739| | 740| 3.90M| *case_insensitive_atoms = new_atom; 741| | 742| 3.90M| atoms_cursor += atom_length; 743| 3.90M| atom_length = *atoms_cursor; 744| 3.90M| atoms_cursor++; 745| 3.90M| } 746| | 747| 485k| atom = atom->next; 748| 485k| } 749| | 750| 4.91k| return ERROR_SUCCESS; ------------------ | | 40| 4.91k|#define ERROR_SUCCESS 0 ------------------ 751| 4.91k|} atoms.c:_yr_atoms_case_combinations: 645| 4.89M|{ 646| 4.89M| uint8_t c; 647| 4.89M| uint8_t* new_atom; 648| | 649| 4.89M| if (atom_offset + 1 < atom_length) ------------------ | Branch (649:7): [True: 2.65M, False: 2.23M] ------------------ 650| 2.65M| output_buffer = _yr_atoms_case_combinations( 651| 2.65M| atom, atom_length, atom_offset + 1, output_buffer); 652| | 653| 4.89M| c = atom[atom_offset]; 654| | 655| 4.89M| if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) ------------------ | Branch (655:8): [True: 4.35M, False: 542k] | Branch (655:20): [True: 3.75M, False: 601k] | Branch (655:34): [True: 786k, False: 357k] | Branch (655:46): [True: 154k, False: 632k] ------------------ 656| 3.90M| { 657| | // Write atom length. 658| 3.90M| *output_buffer = atom_length; 659| 3.90M| output_buffer++; 660| | 661| 3.90M| memcpy(output_buffer, atom, atom_length); 662| | 663| 3.90M| new_atom = output_buffer; 664| 3.90M| output_buffer += atom_length; 665| | 666| | // Swap character case. 667| 3.90M| if (c >= 'a' && c <= 'z') ------------------ | Branch (667:9): [True: 3.75M, False: 154k] | Branch (667:21): [True: 3.75M, False: 0] ------------------ 668| 3.75M| new_atom[atom_offset] -= 32; 669| 154k| else 670| 154k| new_atom[atom_offset] += 32; 671| | 672| 3.90M| if (atom_offset + 1 < atom_length) ------------------ | Branch (672:9): [True: 1.75M, False: 2.15M] ------------------ 673| 1.75M| output_buffer = _yr_atoms_case_combinations( 674| 1.75M| new_atom, atom_length, atom_offset + 1, output_buffer); 675| 3.90M| } 676| | 677| 4.89M| if (atom_offset == 0) ------------------ | Branch (677:7): [True: 485k, False: 4.40M] ------------------ 678| 485k| *output_buffer = 0; 679| | 680| 4.89M| return output_buffer; 681| 4.89M|} atoms.c:_yr_atoms_xor: 762| 1.50k|{ 763| 1.50k| YR_ATOM_LIST_ITEM* atom; 764| 1.50k| YR_ATOM_LIST_ITEM* new_atom; 765| | 766| 1.50k| int i, j; 767| 1.50k| *xor_atoms = NULL; 768| 1.50k| atom = atoms; 769| | 770| 3.37k| while (atom != NULL) ------------------ | Branch (770:10): [True: 1.87k, False: 1.50k] ------------------ 771| 1.87k| { 772| 200k| for (j = min; j <= max; j++) ------------------ | Branch (772:19): [True: 198k, False: 1.87k] ------------------ 773| 198k| { 774| 198k| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 775| | 776| 198k| if (new_atom == NULL) ------------------ | Branch (776:11): [True: 0, False: 198k] ------------------ 777| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 778| | 779| 779k| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (779:19): [True: 580k, False: 198k] ------------------ 780| 580k| { 781| 580k| new_atom->atom.bytes[i] = atom->atom.bytes[i] ^ j; 782| 580k| new_atom->atom.mask[i] = 0xFF; 783| 580k| } 784| | 785| 198k| new_atom->atom.length = yr_min(atom->atom.length, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 198k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 103k, False: 95.8k] | | ------------------ ------------------ 786| 198k| new_atom->forward_code_ref = atom->forward_code_ref; 787| 198k| new_atom->backward_code_ref = atom->backward_code_ref; 788| 198k| new_atom->backtrack = atom->backtrack; 789| 198k| new_atom->next = *xor_atoms; 790| | 791| 198k| *xor_atoms = new_atom; 792| 198k| } 793| | 794| 1.87k| atom = atom->next; 795| 1.87k| } 796| 1.50k| return ERROR_SUCCESS; ------------------ | | 40| 1.50k|#define ERROR_SUCCESS 0 ------------------ 797| 1.50k|} _yr_base64_create_regexp: 306| 1.95k|{ 307| 1.95k| BASE64_NODE* p = head; 308| 1.95k| char* re_str; 309| 1.95k| char* s; 310| 1.95k| uint32_t length = 0; 311| | 312| | // The number of nodes in the list, used to know how many '|'. 313| 1.95k| uint32_t c = 0; 314| | 315| 8.79k| while (p != NULL) ------------------ | Branch (315:10): [True: 6.84k, False: 1.95k] ------------------ 316| 6.84k| { 317| 6.84k| length += (p->str->length + p->escaped); 318| 6.84k| c++; 319| 6.84k| p = p->next; 320| 6.84k| } 321| | 322| 1.95k| if (c == 0) ------------------ | Branch (322:7): [True: 0, False: 1.95k] ------------------ 323| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 324| | 325| | // Make sure to include '(' and ')'. 326| | // The number of '|' is number of nodes - 1. 327| 1.95k| re_str = (char*) yr_malloc(length + 2 + (c - 1) + 1); 328| 1.95k| if (re_str == NULL) ------------------ | Branch (328:7): [True: 0, False: 1.95k] ------------------ 329| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 330| | 331| 1.95k| s = re_str; 332| 1.95k| p = head; 333| 1.95k| *s++ = '('; 334| 8.79k| while (p != NULL) ------------------ | Branch (334:10): [True: 6.84k, False: 1.95k] ------------------ 335| 6.84k| { 336| 2.32M| for (uint32_t i = 0; i < p->str->length; i++) ------------------ | Branch (336:26): [True: 2.31M, False: 6.84k] ------------------ 337| 2.31M| { 338| 2.31M| if (IS_METACHAR(p->str->c_string[i])) ------------------ | | 174| 2.31M| (x == '\\' || x == '^' || x == '$' || x == '|' || x == '(' || x == ')' || \ | | ------------------ | | | Branch (174:4): [True: 302, False: 2.31M] | | | Branch (174:17): [True: 3.30k, False: 2.31M] | | | Branch (174:29): [True: 1.69k, False: 2.31M] | | | Branch (174:41): [True: 0, False: 2.31M] | | | Branch (174:53): [True: 410, False: 2.31M] | | | Branch (174:65): [True: 3, False: 2.31M] | | ------------------ | | 175| 2.31M| x == '[' || x == ']' || x == '*' || x == '?' || x == '{' || x == ',' || \ | | ------------------ | | | Branch (175:4): [True: 155, False: 2.31M] | | | Branch (175:16): [True: 1.10k, False: 2.31M] | | | Branch (175:28): [True: 113, False: 2.31M] | | | Branch (175:40): [True: 1.52k, False: 2.30M] | | | Branch (175:52): [True: 491, False: 2.30M] | | | Branch (175:64): [True: 608, False: 2.30M] | | ------------------ | | 176| 2.31M| x == '.' || x == '+' || x == '}') | | ------------------ | | | Branch (176:4): [True: 5.92k, False: 2.30M] | | | Branch (176:16): [True: 8.80k, False: 2.29M] | | | Branch (176:28): [True: 1.68k, False: 2.29M] | | ------------------ ------------------ 339| 26.1k| *s++ = '\\'; 340| | 341| 2.31M| if (p->str->c_string[i] == '\x00') ------------------ | Branch (341:11): [True: 1.00M, False: 1.30M] ------------------ 342| 1.00M| { 343| 1.00M| *s++ = '\\'; 344| 1.00M| *s++ = 'x'; 345| 1.00M| *s++ = '0'; 346| 1.00M| *s++ = '0'; 347| 1.00M| } 348| 1.30M| else 349| 1.30M| *s++ = p->str->c_string[i]; 350| 2.31M| } 351| | 352| 6.84k| if (p->next != NULL) ------------------ | Branch (352:9): [True: 4.88k, False: 1.95k] ------------------ 353| 4.88k| *s++ = '|'; 354| | 355| 6.84k| p = p->next; 356| 6.84k| } 357| 1.95k| *s++ = ')'; 358| 1.95k| *s = '\x00'; 359| | 360| | // Useful for debugging as long as the string has no NULL bytes in it. ;) 361| | // printf("%s\n", re_str); 362| | 363| 1.95k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.95k| { \ | | 143| 1.95k| int __error = (x); \ | | 144| 1.95k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.95k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.95k] | | ------------------ | | 145| 1.95k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.95k| } ------------------ 364| 1.95k| yr_re_parse(re_str, re_ast, re_error, RE_PARSER_FLAG_NONE), yr_free(re_str)); 365| | 366| 1.95k| yr_free(re_str); 367| | 368| 1.95k| return ERROR_SUCCESS; ------------------ | | 40| 1.95k|#define ERROR_SUCCESS 0 ------------------ 369| 1.95k|} yr_base64_ast_from_string: 388| 1.95k|{ 389| 1.95k| BASE64_NODE* head = NULL; 390| 1.95k| BASE64_NODE* tail = NULL; 391| 1.95k| SIZED_STRING* wide_str; 392| | 393| 1.95k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 1.95k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (393:7): [True: 402, False: 1.55k] ------------------ 394| 402| { 395| 402| wide_str = ss_convert_to_wide(in_str); 396| | 397| 402| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 402|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (397:9): [True: 78, False: 324] ------------------ 398| 78| { 399| 78| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 78| { \ | | 143| 78| int __error = (x); \ | | 144| 78| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 78|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 78] | | ------------------ | | 145| 78| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 78| } ------------------ 400| 78| _yr_base64_create_nodes(wide_str, modifier.alphabet, 0, &head, &tail), 401| 78| { // Cleanup 402| 78| strcpy(error->message, "Failure encoding base64 wide string"); 403| 78| yr_free(wide_str); 404| 78| _yr_base64_destroy_nodes(head); 405| 78| }); 406| 78| } 407| | 408| 402| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 402|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (408:9): [True: 324, False: 78] ------------------ 409| 324| { 410| 324| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 324| { \ | | 143| 324| int __error = (x); \ | | 144| 324| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 324|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 324] | | ------------------ | | 145| 324| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 324| } ------------------ 411| 324| _yr_base64_create_nodes(wide_str, modifier.alphabet, 1, &head, &tail), 412| 324| { // Cleanup 413| 324| strcpy(error->message, "Failure encoding base64wide wide string"); 414| 324| yr_free(wide_str); 415| 324| _yr_base64_destroy_nodes(head); 416| 324| }); 417| 324| } 418| | 419| 402| yr_free(wide_str); 420| 402| } 421| | 422| 1.95k| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 1.95k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (422:7): [True: 109, False: 1.84k] ------------------ 423| 109| { 424| 109| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 109|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (424:9): [True: 49, False: 60] ------------------ 425| 49| { 426| 49| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 49| { \ | | 143| 49| int __error = (x); \ | | 144| 49| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 49|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 49] | | ------------------ | | 145| 49| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 49| } ------------------ 427| 49| _yr_base64_create_nodes(in_str, modifier.alphabet, 0, &head, &tail), 428| 49| { // Cleanup 429| 49| strcpy(error->message, "Failure encoding base64 ascii string"); 430| 49| _yr_base64_destroy_nodes(head); 431| 49| }); 432| 49| } 433| | 434| 109| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 109|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (434:9): [True: 60, False: 49] ------------------ 435| 60| { 436| 60| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 60| { \ | | 143| 60| int __error = (x); \ | | 144| 60| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 60|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 60] | | ------------------ | | 145| 60| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 60| } ------------------ 437| 60| _yr_base64_create_nodes(in_str, modifier.alphabet, 1, &head, &tail), 438| 60| { // Cleanup 439| 60| strcpy(error->message, "Failure encoding base64wide ascii string"); 440| 60| _yr_base64_destroy_nodes(head); 441| 60| }); 442| 60| } 443| 109| } 444| | 445| 1.95k| if (!(modifier.flags & STRING_FLAGS_WIDE) && ------------------ | | 70| 1.95k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (445:7): [True: 1.55k, False: 402] ------------------ 446| 1.95k| !(modifier.flags & STRING_FLAGS_ASCII)) ------------------ | | 69| 1.55k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (446:7): [True: 1.44k, False: 109] ------------------ 447| 1.44k| { 448| 1.44k| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 1.44k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (448:9): [True: 1.13k, False: 315] ------------------ 449| 1.13k| { 450| 1.13k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.13k| { \ | | 143| 1.13k| int __error = (x); \ | | 144| 1.13k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.13k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.13k] | | ------------------ | | 145| 1.13k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.13k| } ------------------ 451| 1.13k| _yr_base64_create_nodes(in_str, modifier.alphabet, 0, &head, &tail), 452| 1.13k| { // Cleanup 453| 1.13k| strcpy(error->message, "Failure encoding base64 string"); 454| 1.13k| _yr_base64_destroy_nodes(head); 455| 1.13k| }); 456| 1.13k| } 457| | 458| 1.44k| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 1.44k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (458:9): [True: 1.17k, False: 273] ------------------ 459| 1.17k| { 460| 1.17k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.17k| { \ | | 143| 1.17k| int __error = (x); \ | | 144| 1.17k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.17k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.17k] | | ------------------ | | 145| 1.17k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.17k| } ------------------ 461| 1.17k| _yr_base64_create_nodes(in_str, modifier.alphabet, 1, &head, &tail), 462| 1.17k| { // Cleanup 463| 1.17k| strcpy(error->message, "Failure encoding base64wide string"); 464| 1.17k| _yr_base64_destroy_nodes(head); 465| 1.17k| }); 466| 1.17k| } 467| 1.44k| } 468| | 469| | // Useful for printing the contents of the nodes, to make sure they were 470| | // encoded and stripped properly. 471| | //_yr_base64_print_nodes(head); 472| | 473| | // Create the final regex string to be parsed from all the nodes. 474| | // Error message is filled in by the caller in case of failure. 475| 1.95k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.95k| { \ | | 143| 1.95k| int __error = (x); \ | | 144| 1.95k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.95k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.95k] | | ------------------ | | 145| 1.95k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.95k| } ------------------ 476| 1.95k| _yr_base64_create_regexp(head, re_ast, error), 477| 1.95k| _yr_base64_destroy_nodes(head)); 478| | 479| 1.95k| _yr_base64_destroy_nodes(head); 480| | 481| 1.95k| return ERROR_SUCCESS; ------------------ | | 40| 1.95k|#define ERROR_SUCCESS 0 ------------------ 482| 1.95k|} base64.c:_yr_base64_create_nodes: 207| 2.81k|{ 208| 2.81k| SIZED_STRING* encoded_str; 209| 2.81k| SIZED_STRING* final_str; 210| 2.81k| BASE64_NODE* node; 211| | 212| 2.81k| int pad; 213| | 214| 11.2k| for (int i = 0; i <= 2; i++) ------------------ | Branch (214:19): [True: 8.44k, False: 2.81k] ------------------ 215| 8.44k| { 216| 8.44k| if (i == 1 && str->length == 1) ------------------ | Branch (216:9): [True: 2.81k, False: 5.63k] | Branch (216:19): [True: 1.60k, False: 1.21k] ------------------ 217| 1.60k| continue; 218| | 219| 6.84k| node = (BASE64_NODE*) yr_malloc(sizeof(BASE64_NODE)); 220| 6.84k| if (node == NULL) ------------------ | Branch (220:9): [True: 0, False: 6.84k] ------------------ 221| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 222| | 223| 6.84k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 152| 6.84k| { \ | | 153| 6.84k| if ((x) == NULL) \ | | ------------------ | | | Branch (153:9): [True: 0, False: 6.84k] | | ------------------ | | 154| 6.84k| { \ | | 155| 0| cleanup; \ | | 156| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 157| 0| } \ | | 158| 6.84k| } ------------------ 224| 6.84k| encoded_str = _yr_modified_base64_encode(str, alphabet, i, &pad), 225| 6.84k| yr_free(node)); 226| | 227| | // Now take the encoded string and strip the bytes which are affected by 228| | // the leading and trailing bytes of the plaintext. 229| 6.84k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 152| 6.84k| { \ | | 153| 6.84k| if ((x) == NULL) \ | | ------------------ | | | Branch (153:9): [True: 0, False: 6.84k] | | ------------------ | | 154| 6.84k| { \ | | 155| 0| cleanup; \ | | 156| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 157| 0| } \ | | 158| 6.84k| } ------------------ 230| 6.84k| final_str = _yr_base64_get_base64_substring(encoded_str, wide, i, pad), 231| 6.84k| { 232| 6.84k| yr_free(encoded_str); 233| 6.84k| yr_free(node); 234| 6.84k| }); 235| | 236| 6.84k| yr_free(encoded_str); 237| | 238| 6.84k| node->str = final_str; 239| 6.84k| node->escaped = _yr_base64_count_escaped(node->str); 240| 6.84k| node->next = NULL; 241| | 242| 6.84k| if (*head == NULL) ------------------ | Branch (242:9): [True: 1.95k, False: 4.88k] ------------------ 243| 1.95k| *head = node; 244| | 245| 6.84k| if (*tail == NULL) ------------------ | Branch (245:9): [True: 1.95k, False: 4.88k] ------------------ 246| 1.95k| { 247| 1.95k| *tail = node; 248| 1.95k| } 249| 4.88k| else 250| 4.88k| { 251| 4.88k| (*tail)->next = node; 252| 4.88k| *tail = node; 253| 4.88k| } 254| 6.84k| } 255| | 256| 2.81k| return ERROR_SUCCESS; ------------------ | | 40| 2.81k|#define ERROR_SUCCESS 0 ------------------ 257| 2.81k|} base64.c:_yr_modified_base64_encode: 52| 6.84k|{ 53| 6.84k| uint8_t* src = (uint8_t*) in->c_string; 54| 6.84k| size_t len = in->length; 55| 6.84k| SIZED_STRING* out; 56| 6.84k| uint8_t* p; 57| 6.84k| uint8_t* end; 58| 6.84k| char* alphabet_str = alphabet->c_string; 59| 6.84k| uint8_t* tmp; 60| 6.84k| int j; 61| | 62| 6.84k| *pad = ((i + len) % 3) ? 3 - ((i + len) % 3) : 0; ------------------ | Branch (62:10): [True: 4.02k, False: 2.81k] ------------------ 63| | 64| | // Add "i" for the number of prepended bytes. 65| 6.84k| out = (SIZED_STRING*) yr_malloc( 66| 6.84k| sizeof(SIZED_STRING) + i + ((len * 4 + 3) / 3) + *pad); 67| | 68| 6.84k| if (out == NULL) ------------------ | Branch (68:7): [True: 0, False: 6.84k] ------------------ 69| 0| return NULL; 70| | 71| 6.84k| tmp = (uint8_t*) yr_malloc(sizeof(uint8_t) * (len + i)); 72| 6.84k| if (tmp == NULL) ------------------ | Branch (72:7): [True: 0, False: 6.84k] ------------------ 73| 0| { 74| 0| yr_free(out); 75| 0| return NULL; 76| 0| } 77| | 78| | // Prepend appropriate number of bytes and copy remaining input bytes into 79| | // temporary buffer. 80| 13.6k| for (j = 0; j < i; j++) tmp[j] = 'A'; ------------------ | Branch (80:15): [True: 6.84k, False: 6.84k] ------------------ 81| | 82| 6.84k| memcpy(tmp + j, src, len); 83| 6.84k| src = tmp; 84| | 85| 6.84k| p = (uint8_t*) out->c_string; 86| 6.84k| end = src + len + j; 87| | 88| 335k| while (end - src >= 3) ------------------ | Branch (88:10): [True: 328k, False: 6.84k] ------------------ 89| 328k| { 90| 328k| *p++ = alphabet_str[src[0] >> 2]; 91| 328k| *p++ = alphabet_str[((src[0] & 0x03) << 4 | src[1] >> 4)]; 92| 328k| *p++ = alphabet_str[((src[1] & 0x0f) << 2 | (src[2] >> 6))]; 93| 328k| *p++ = alphabet_str[src[2] & 0x3f]; 94| 328k| src += 3; 95| 328k| } 96| | 97| | // Handle remaining bytes and padding. 98| 6.84k| if (end - src) ------------------ | Branch (98:7): [True: 4.02k, False: 2.81k] ------------------ 99| 4.02k| { 100| 4.02k| *p++ = alphabet_str[src[0] >> 2]; 101| 4.02k| if (end - src == 1) ------------------ | Branch (101:9): [True: 2.81k, False: 1.21k] ------------------ 102| 2.81k| { 103| 2.81k| *p++ = alphabet_str[(src[0] & 0x03) << 4]; 104| 2.81k| *p++ = '='; 105| 2.81k| } 106| 1.21k| else 107| 1.21k| { 108| 1.21k| *p++ = alphabet_str[((src[0] & 0x03) << 4 | src[1] >> 4)]; 109| 1.21k| *p++ = alphabet_str[(src[1] & 0x0f) << 2]; 110| 1.21k| } 111| 4.02k| *p++ = '='; 112| 4.02k| } 113| | 114| 6.84k| yr_free(tmp); 115| 6.84k| out->length = (uint32_t)(p - (uint8_t*) out->c_string); 116| | 117| 6.84k| return out; 118| 6.84k|} base64.c:_yr_base64_get_base64_substring: 134| 6.84k|{ 135| 6.84k| SIZED_STRING* new_str; 136| 6.84k| SIZED_STRING* final_str; 137| 6.84k| char* start; 138| 6.84k| uint32_t length; 139| 6.84k| int trailing; 140| 6.84k| int leading; 141| | 142| 6.84k| trailing = pad ? pad + 1 : 0; ------------------ | Branch (142:14): [True: 4.02k, False: 2.81k] ------------------ 143| 6.84k| leading = i ? i + 1 : 0; ------------------ | Branch (143:13): [True: 4.02k, False: 2.81k] ------------------ 144| | 145| 6.84k| length = encoded_str->length - (leading + trailing); 146| | 147| 6.84k| new_str = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 148| | 149| 6.84k| if (new_str == NULL) ------------------ | Branch (149:7): [True: 0, False: 6.84k] ------------------ 150| 0| return NULL; 151| | 152| 6.84k| start = encoded_str->c_string + leading; 153| | 154| 6.84k| memcpy(new_str->c_string, start, length); 155| | 156| 6.84k| new_str->length = length; 157| 6.84k| new_str->c_string[length] = '\0'; 158| | 159| 6.84k| if (wide) ------------------ | Branch (159:7): [True: 3.86k, False: 2.97k] ------------------ 160| 3.86k| { 161| 3.86k| final_str = ss_convert_to_wide(new_str); 162| 3.86k| yr_free(new_str); 163| 3.86k| } 164| 2.97k| else 165| 2.97k| { 166| 2.97k| final_str = new_str; 167| 2.97k| } 168| | 169| 6.84k| return final_str; 170| 6.84k|} base64.c:_yr_base64_count_escaped: 183| 6.84k|{ 184| 6.84k| int c = 0; 185| | 186| 2.32M| for (uint32_t i = 0; i < str->length; i++) ------------------ | Branch (186:24): [True: 2.31M, False: 6.84k] ------------------ 187| 2.31M| { 188| | // We must be careful to escape null bytes because they break the RE lexer. 189| 2.31M| if (IS_METACHAR(str->c_string[i])) ------------------ | | 174| 2.31M| (x == '\\' || x == '^' || x == '$' || x == '|' || x == '(' || x == ')' || \ | | ------------------ | | | Branch (174:4): [True: 302, False: 2.31M] | | | Branch (174:17): [True: 3.30k, False: 2.31M] | | | Branch (174:29): [True: 1.69k, False: 2.31M] | | | Branch (174:41): [True: 0, False: 2.31M] | | | Branch (174:53): [True: 410, False: 2.31M] | | | Branch (174:65): [True: 3, False: 2.31M] | | ------------------ | | 175| 2.31M| x == '[' || x == ']' || x == '*' || x == '?' || x == '{' || x == ',' || \ | | ------------------ | | | Branch (175:4): [True: 155, False: 2.31M] | | | Branch (175:16): [True: 1.10k, False: 2.31M] | | | Branch (175:28): [True: 113, False: 2.31M] | | | Branch (175:40): [True: 1.52k, False: 2.30M] | | | Branch (175:52): [True: 491, False: 2.30M] | | | Branch (175:64): [True: 608, False: 2.30M] | | ------------------ | | 176| 2.31M| x == '.' || x == '+' || x == '}') | | ------------------ | | | Branch (176:4): [True: 5.92k, False: 2.30M] | | | Branch (176:16): [True: 8.80k, False: 2.29M] | | | Branch (176:28): [True: 1.68k, False: 2.29M] | | ------------------ ------------------ 190| 26.1k| c++; 191| 2.29M| else if (str->c_string[i] == '\x00') ------------------ | Branch (191:14): [True: 1.00M, False: 1.28M] ------------------ 192| 1.00M| c += 4; 193| 2.31M| } 194| | 195| 6.84k| return c; 196| 6.84k|} base64.c:_yr_base64_destroy_nodes: 285| 1.95k|{ 286| 1.95k| BASE64_NODE* p = head; 287| 1.95k| BASE64_NODE* next; 288| | 289| 8.79k| while (p != NULL) ------------------ | Branch (289:10): [True: 6.84k, False: 1.95k] ------------------ 290| 6.84k| { 291| 6.84k| yr_free(p->str); 292| 6.84k| next = p->next; 293| 6.84k| yr_free(p); 294| 6.84k| p = next; 295| 6.84k| } 296| 1.95k|} yr_bitmask_find_non_colliding_offset: 64| 252k|{ 65| 252k| uint32_t i, j, k; 66| | 67| | // Ensure that the first bit of bitmask B is set, as this function does some 68| | // optimizations that rely on that. 69| 252k| assert(yr_bitmask_is_set(b, 0)); 70| | 71| | // Skip all slots that are filled with 1s. It's safe to do that because the 72| | // first bit of B is 1, so we won't be able to accommodate B at any offset 73| | // within such slots. 74| 252k| for (i = *off_a / YR_BITMASK_SLOT_BITS; ------------------ | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 75| 72.3M| i <= len_a / YR_BITMASK_SLOT_BITS && a[i] == -1L; ------------------ | | 56| 144M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (75:8): [True: 72.3M, False: 0] | Branch (75:45): [True: 72.0M, False: 252k] ------------------ 76| 72.0M| i++) 77| 72.0M| ; 78| | 79| 252k| *off_a = i; 80| | 81| 13.1M| for (; i <= len_a / YR_BITMASK_SLOT_BITS; i++) ------------------ | | 56| 13.1M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (81:10): [True: 13.1M, False: 0] ------------------ 82| 13.1M| { 83| | // The slot is filled with 1s, we can safely skip it. 84| 13.1M| if (a[i] == -1L) ------------------ | Branch (84:9): [True: 3.85M, False: 9.32M] ------------------ 85| 3.85M| continue; 86| | 87| 597M| for (j = 0; j <= yr_min(len_a, YR_BITMASK_SLOT_BITS - 1); j++) ------------------ | | 107| 597M|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 0, False: 597M] | | ------------------ ------------------ | Branch (87:17): [True: 588M, False: 9.07M] ------------------ 88| 588M| { 89| 588M| bool found = true; 90| | 91| 734M| for (k = 0; k <= len_b / YR_BITMASK_SLOT_BITS; k++) ------------------ | | 56| 734M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (91:19): [True: 734M, False: 252k] ------------------ 92| 734M| { 93| 734M| YR_BITMASK m = b[k] << j; ------------------ | | 54| 734M|#define YR_BITMASK unsigned long ------------------ 94| | 95| 734M| if (j > 0 && k > 0) ------------------ | Branch (95:13): [True: 722M, False: 11.1M] | Branch (95:22): [True: 143M, False: 579M] ------------------ 96| 143M| m |= b[k - 1] >> (YR_BITMASK_SLOT_BITS - j); ------------------ | | 56| 143M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 97| | 98| 734M| if ((i + k <= len_a / YR_BITMASK_SLOT_BITS) && (m & a[i + k]) != 0) ------------------ | | 56| 734M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (98:13): [True: 734M, False: 651] | Branch (98:56): [True: 588M, False: 145M] ------------------ 99| 588M| { 100| 588M| found = false; 101| 588M| break; 102| 588M| } 103| 734M| } 104| | 105| 588M| if (found) ------------------ | Branch (105:11): [True: 252k, False: 588M] ------------------ 106| 252k| return i * YR_BITMASK_SLOT_BITS + j; ------------------ | | 56| 252k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 107| 588M| } 108| 9.32M| } 109| | 110| 0| return len_a; 111| 252k|} _yr_compiler_default_include_callback: 69| 1.88k|{ 70| 1.88k|#ifndef _MSC_VER 71| 1.88k| struct stat stbuf; 72| 1.88k|#endif 73| | 74| 1.88k| char* file_buffer; 75| | 76| |#ifdef _MSC_VER 77| | long file_size; 78| |#else 79| 1.88k| off_t file_size; 80| 1.88k|#endif 81| | 82| 1.88k| int fd = -1; 83| | 84| |#if defined(_MSC_VER) 85| | _sopen_s(&fd, include_name, _O_RDONLY | _O_BINARY, _SH_DENYWR, _S_IREAD); 86| |#elif defined(_WIN32) || defined(__CYGWIN__) 87| | fd = open(include_name, O_RDONLY | O_BINARY); 88| |#else 89| 1.88k| fd = open(include_name, O_RDONLY); 90| 1.88k|#endif 91| | 92| 1.88k| if (fd == -1) ------------------ | Branch (92:7): [True: 1.72k, False: 160] ------------------ 93| 1.72k| return NULL; 94| | 95| |#ifdef _MSC_VER 96| | file_size = _filelength(fd); 97| | if (file_size == -1) 98| | { 99| | _close(fd); 100| | return NULL; 101| | } 102| |#else 103| 160| if ((fstat(fd, &stbuf) != 0) || (!S_ISREG(stbuf.st_mode))) ------------------ | Branch (103:7): [True: 0, False: 160] | Branch (103:35): [True: 160, False: 0] ------------------ 104| 160| { 105| 160| close(fd); 106| 160| return NULL; 107| 160| } 108| 0| file_size = stbuf.st_size; 109| 0|#endif 110| | 111| 0| file_buffer = (char*) yr_malloc((size_t) file_size + 1); 112| | 113| 0| if (file_buffer == NULL) ------------------ | Branch (113:7): [True: 0, False: 0] ------------------ 114| 0| { 115| |#ifdef _MSC_VER 116| | _close(fd); 117| |#else 118| 0| close(fd); 119| 0|#endif 120| | 121| 0| return NULL; 122| 0| } 123| | 124| 0| if (file_size != read(fd, file_buffer, (size_t) file_size)) ------------------ | Branch (124:7): [True: 0, False: 0] ------------------ 125| 0| { 126| 0| yr_free(file_buffer); 127| | 128| |#ifdef _MSC_VER 129| | _close(fd); 130| |#else 131| 0| close(fd); 132| 0|#endif 133| | 134| 0| return NULL; 135| 0| } 136| 0| else 137| 0| { 138| 0| file_buffer[file_size] = '\0'; 139| 0| } 140| | 141| |#ifdef _MSC_VER 142| | _close(fd); 143| |#else 144| 0| close(fd); 145| 0|#endif 146| | 147| 0| return file_buffer; 148| 0|} _yr_compiler_get_rule_by_idx: 160| 54.9k|{ 161| 54.9k| return (YR_RULE*) yr_arena_get_ptr( 162| 54.9k| compiler->arena, YR_RULES_TABLE, rule_idx * sizeof(YR_RULE)); ------------------ | | 58| 54.9k|#define YR_RULES_TABLE 1 ------------------ 163| 54.9k|} _yr_compiler_store_data: 177| 55.2k|{ 178| | // Check if the data is already in YR_SZ_POOL by using a hash table. 179| 55.2k| uint32_t offset = yr_hash_table_lookup_uint32_raw_key( 180| 55.2k| compiler->sz_table, data, data_length, NULL); 181| | 182| 55.2k| if (offset == UINT32_MAX) ------------------ | Branch (182:7): [True: 16.3k, False: 38.9k] ------------------ 183| 16.3k| { 184| | // The data was not previously written to YR_SZ_POOL, write it and store 185| | // the reference's offset in the hash table. Storing the buffer number 186| | // is not necessary, it's always YR_SZ_POOL. 187| 16.3k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 16.3k| { \ | | 135| 16.3k| int __error = (x); \ | | 136| 16.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 16.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 16.3k] | | ------------------ | | 137| 16.3k| return __error; \ | | 138| 16.3k| } ------------------ 188| 16.3k| compiler->arena, YR_SZ_POOL, data, data_length, ref)); 189| | 190| 16.3k| FAIL_ON_ERROR(yr_hash_table_add_uint32_raw_key( ------------------ | | 134| 16.3k| { \ | | 135| 16.3k| int __error = (x); \ | | 136| 16.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 16.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 16.3k] | | ------------------ | | 137| 16.3k| return __error; \ | | 138| 16.3k| } ------------------ 191| 16.3k| compiler->sz_table, data, data_length, NULL, ref->offset)); 192| 16.3k| } 193| 38.9k| else 194| 38.9k| { 195| 38.9k| ref->buffer_id = YR_SZ_POOL; ------------------ | | 62| 38.9k|#define YR_SZ_POOL 5 ------------------ 196| 38.9k| ref->offset = offset; 197| 38.9k| } 198| | 199| 55.2k| return ERROR_SUCCESS; ------------------ | | 40| 55.2k|#define ERROR_SUCCESS 0 ------------------ 200| 55.2k|} _yr_compiler_store_string: 209| 36.8k|{ 210| 36.8k| return _yr_compiler_store_data( 211| 36.8k| compiler, 212| 36.8k| (void*) string, 213| 36.8k| strlen(string) + 1, // include the null terminator 214| 36.8k| ref); 215| 36.8k|} yr_compiler_create: 218| 1.72k|{ 219| 1.72k| int result; 220| 1.72k| YR_COMPILER* new_compiler; 221| | 222| 1.72k| new_compiler = (YR_COMPILER*) yr_calloc(1, sizeof(YR_COMPILER)); 223| | 224| 1.72k| if (new_compiler == NULL) ------------------ | Branch (224:7): [True: 0, False: 1.72k] ------------------ 225| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 226| | 227| 1.72k| new_compiler->current_rule_idx = UINT32_MAX; 228| 1.72k| new_compiler->next_rule_idx = 0; 229| 1.72k| new_compiler->current_string_idx = 0; 230| 1.72k| new_compiler->current_namespace_idx = 0; 231| 1.72k| new_compiler->current_meta_idx = 0; 232| 1.72k| new_compiler->num_namespaces = 0; 233| 1.72k| new_compiler->errors = 0; 234| 1.72k| new_compiler->callback = NULL; 235| 1.72k| new_compiler->rules = NULL; 236| 1.72k| new_compiler->include_callback = _yr_compiler_default_include_callback; 237| 1.72k| new_compiler->incl_clbk_user_data = NULL; 238| 1.72k| new_compiler->include_free = _yr_compiler_default_include_free; 239| 1.72k| new_compiler->re_ast_callback = NULL; 240| 1.72k| new_compiler->re_ast_clbk_user_data = NULL; 241| 1.72k| new_compiler->last_error = ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 242| 1.72k| new_compiler->last_error_line = 0; 243| 1.72k| new_compiler->strict_escape = false; 244| 1.72k| new_compiler->current_line = 0; 245| 1.72k| new_compiler->file_name_stack_ptr = 0; 246| 1.72k| new_compiler->fixup_stack_head = NULL; 247| 1.72k| new_compiler->loop_index = -1; 248| 1.72k| new_compiler->loop_for_of_var_index = -1; 249| | 250| 1.72k| new_compiler->atoms_config.get_atom_quality = yr_atoms_heuristic_quality; 251| 1.72k| new_compiler->atoms_config.quality_warning_threshold = 252| 1.72k| YR_ATOM_QUALITY_WARNING_THRESHOLD; ------------------ | | 84| 1.72k| YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 71| 1.72k|#define YR_MAX_ATOM_QUALITY 255 | | ------------------ | | YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 67| 1.72k|#define YR_MAX_ATOM_LENGTH 4 | | ------------------ ------------------ 253| | 254| 1.72k| result = yr_hash_table_create(5000, &new_compiler->rules_table); 255| | 256| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (256:7): [True: 1.72k, False: 0] ------------------ 257| 1.72k| result = yr_hash_table_create(1000, &new_compiler->objects_table); 258| | 259| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (259:7): [True: 1.72k, False: 0] ------------------ 260| 1.72k| result = yr_hash_table_create(10000, &new_compiler->strings_table); 261| | 262| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (262:7): [True: 1.72k, False: 0] ------------------ 263| 1.72k| result = yr_hash_table_create( 264| 1.72k| 1000, &new_compiler->wildcard_identifiers_table); 265| | 266| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (266:7): [True: 1.72k, False: 0] ------------------ 267| 1.72k| result = yr_hash_table_create(10000, &new_compiler->sz_table); 268| | 269| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (269:7): [True: 1.72k, False: 0] ------------------ 270| 1.72k| result = yr_arena_create(YR_NUM_SECTIONS, 1048576, &new_compiler->arena); ------------------ | | 72| 1.72k|#define YR_NUM_SECTIONS 12 ------------------ 271| | 272| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (272:7): [True: 1.72k, False: 0] ------------------ 273| 1.72k| result = yr_ac_automaton_create( 274| 1.72k| new_compiler->arena, &new_compiler->automaton); 275| | 276| 1.72k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (276:7): [True: 1.72k, False: 0] ------------------ 277| 1.72k| { 278| 1.72k| *compiler = new_compiler; 279| 1.72k| } 280| 0| else // if error, do cleanup 281| 0| { 282| 0| yr_compiler_destroy(new_compiler); 283| 0| } 284| | 285| 1.72k| return result; 286| 1.72k|} yr_compiler_destroy: 289| 1.72k|{ 290| 1.72k| if (compiler->arena != NULL) ------------------ | Branch (290:7): [True: 1.72k, False: 0] ------------------ 291| 1.72k| yr_arena_release(compiler->arena); 292| | 293| 1.72k| if (compiler->automaton != NULL) ------------------ | Branch (293:7): [True: 1.72k, False: 0] ------------------ 294| 1.72k| yr_ac_automaton_destroy(compiler->automaton); 295| | 296| 1.72k| if (compiler->rules_table != NULL) ------------------ | Branch (296:7): [True: 1.72k, False: 0] ------------------ 297| 1.72k| yr_hash_table_destroy(compiler->rules_table, NULL); 298| | 299| 1.72k| if (compiler->strings_table != NULL) ------------------ | Branch (299:7): [True: 1.72k, False: 0] ------------------ 300| 1.72k| yr_hash_table_destroy(compiler->strings_table, NULL); 301| | 302| 1.72k| if (compiler->wildcard_identifiers_table != NULL) ------------------ | Branch (302:7): [True: 1.72k, False: 0] ------------------ 303| 1.72k| yr_hash_table_destroy(compiler->wildcard_identifiers_table, NULL); 304| | 305| 1.72k| if (compiler->sz_table != NULL) ------------------ | Branch (305:7): [True: 1.72k, False: 0] ------------------ 306| 1.72k| yr_hash_table_destroy(compiler->sz_table, NULL); 307| | 308| 1.72k| if (compiler->objects_table != NULL) ------------------ | Branch (308:7): [True: 1.72k, False: 0] ------------------ 309| 1.72k| yr_hash_table_destroy( 310| 1.72k| compiler->objects_table, 311| 1.72k| (YR_HASH_TABLE_FREE_VALUE_FUNC) yr_object_destroy); 312| | 313| 1.72k| if (compiler->atoms_config.free_quality_table) ------------------ | Branch (313:7): [True: 0, False: 1.72k] ------------------ 314| 0| yr_free(compiler->atoms_config.quality_table); 315| | 316| 1.72k| for (int i = 0; i < compiler->file_name_stack_ptr; i++) ------------------ | Branch (316:19): [True: 0, False: 1.72k] ------------------ 317| 0| yr_free(compiler->file_name_stack[i]); 318| | 319| 1.72k| YR_FIXUP* fixup = compiler->fixup_stack_head; 320| | 321| 14.1k| while (fixup != NULL) ------------------ | Branch (321:10): [True: 12.4k, False: 1.72k] ------------------ 322| 12.4k| { 323| 12.4k| YR_FIXUP* next_fixup = fixup->next; 324| 12.4k| yr_free(fixup); 325| 12.4k| fixup = next_fixup; 326| 12.4k| } 327| | 328| 1.72k| yr_free(compiler); 329| 1.72k|} _yr_compiler_get_var_frame: 492| 3.05k|{ 493| 3.05k| int i, result = 0; 494| | 495| 4.11k| for (i = 0; i < compiler->loop_index; i++) ------------------ | Branch (495:15): [True: 1.05k, False: 3.05k] ------------------ 496| 1.05k| { 497| 1.05k| result += compiler->loop[i].vars_count + 498| 1.05k| compiler->loop[i].vars_internal_count; 499| 1.05k| } 500| | 501| 3.05k| return result; 502| 3.05k|} yr_compiler_get_current_file_name: 505| 1.88k|{ 506| 1.88k| if (compiler->file_name_stack_ptr > 0) ------------------ | Branch (506:7): [True: 0, False: 1.88k] ------------------ 507| 0| { 508| 0| return compiler->file_name_stack[compiler->file_name_stack_ptr - 1]; 509| 0| } 510| 1.88k| else 511| 1.88k| { 512| 1.88k| return NULL; 513| 1.88k| } 514| 1.88k|} yr_compiler_add_string: 662| 1.72k|{ 663| | // Don't allow calls to yr_compiler_add_string() after 664| | // yr_compiler_get_rules() has been called. 665| 1.72k| assert(compiler->rules == NULL); 666| | 667| | // Don't allow calls to yr_compiler_add_string() if a previous call to 668| | // yr_compiler_add_XXXX failed. 669| 1.72k| assert(compiler->errors == 0); 670| | 671| 1.72k| if (namespace_ != NULL) ------------------ | Branch (671:7): [True: 0, False: 1.72k] ------------------ 672| 0| compiler->last_error = _yr_compiler_set_namespace(compiler, namespace_); 673| 1.72k| else 674| 1.72k| compiler->last_error = _yr_compiler_set_namespace(compiler, "default"); 675| | 676| 1.72k| if (compiler->last_error != ERROR_SUCCESS) ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ | Branch (676:7): [True: 0, False: 1.72k] ------------------ 677| 0| return ++compiler->errors; 678| | 679| 1.72k| return yr_lex_parse_rules_string(rules_string, compiler); 680| 1.72k|} yr_compiler_get_rules: 730| 112|{ 731| | // Don't allow calls to yr_compiler_get_rules() if a previous call to 732| | // yr_compiler_add_XXXX failed. 733| 112| assert(compiler->errors == 0); 734| | 735| 112| *rules = NULL; 736| | 737| 112| if (compiler->rules == NULL) ------------------ | Branch (737:7): [True: 112, False: 0] ------------------ 738| 112| FAIL_ON_ERROR(_yr_compiler_compile_rules(compiler)); ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 739| | 740| 112| *rules = compiler->rules; 741| | 742| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 743| 112|} compiler.c:_yr_compiler_set_namespace: 519| 1.72k|{ 520| 1.72k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 521| 1.72k| compiler->arena, YR_NAMESPACES_TABLE, 0); ------------------ | | 57| 1.72k|#define YR_NAMESPACES_TABLE 0 ------------------ 522| | 523| 1.72k| bool found = false; 524| | 525| 1.72k| for (int i = 0; i < compiler->num_namespaces; i++, ns++) ------------------ | Branch (525:19): [True: 0, False: 1.72k] ------------------ 526| 0| { 527| 0| if (strcmp(ns->name, namespace_) == 0) ------------------ | Branch (527:9): [True: 0, False: 0] ------------------ 528| 0| { 529| 0| found = true; 530| 0| compiler->current_namespace_idx = i; 531| 0| break; 532| 0| } 533| 0| } 534| | 535| 1.72k| if (!found) ------------------ | Branch (535:7): [True: 1.72k, False: 0] ------------------ 536| 1.72k| { 537| 1.72k| YR_ARENA_REF ref; 538| | 539| 1.72k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 1.72k| { \ | | 135| 1.72k| int __error = (x); \ | | 136| 1.72k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.72k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.72k] | | ------------------ | | 137| 1.72k| return __error; \ | | 138| 1.72k| } ------------------ 540| 1.72k| compiler->arena, 541| 1.72k| YR_NAMESPACES_TABLE, 542| 1.72k| sizeof(YR_NAMESPACE), 543| 1.72k| &ref, 544| 1.72k| offsetof(YR_NAMESPACE, name), 545| 1.72k| EOL)); 546| | 547| 1.72k| ns = (YR_NAMESPACE*) yr_arena_ref_to_ptr(compiler->arena, &ref); 548| | 549| 1.72k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, namespace_, &ref)); ------------------ | | 134| 1.72k| { \ | | 135| 1.72k| int __error = (x); \ | | 136| 1.72k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.72k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.72k] | | ------------------ | | 137| 1.72k| return __error; \ | | 138| 1.72k| } ------------------ 550| | 551| 1.72k| ns->name = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 552| 1.72k| ns->idx = compiler->num_namespaces; 553| | 554| 1.72k| compiler->current_namespace_idx = compiler->num_namespaces; 555| 1.72k| compiler->num_namespaces++; 556| 1.72k| } 557| | 558| 1.72k| return ERROR_SUCCESS; ------------------ | | 40| 1.72k|#define ERROR_SUCCESS 0 ------------------ 559| 1.72k|} compiler.c:_yr_compiler_compile_rules: 683| 112|{ 684| 112| YR_RULE null_rule; 685| 112| YR_EXTERNAL_VARIABLE null_external; 686| | 687| 112| uint8_t halt = OP_HALT; ------------------ | | 46| 112|#define OP_HALT 255 ------------------ 688| | 689| | // Write halt instruction at the end of code. 690| 112| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 691| 112| compiler->arena, YR_CODE_SECTION, &halt, sizeof(uint8_t), NULL)); 692| | 693| | // Write a null rule indicating the end. 694| 112| memset(&null_rule, 0xFA, sizeof(YR_RULE)); 695| 112| null_rule.flags = RULE_FLAGS_NULL; ------------------ | | 54| 112|#define RULE_FLAGS_NULL 0x04 ------------------ 696| | 697| 112| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 698| 112| compiler->arena, YR_RULES_TABLE, &null_rule, sizeof(YR_RULE), NULL)); 699| | 700| | // Write a null external indicating the end. 701| 112| memset(&null_external, 0xFA, sizeof(YR_EXTERNAL_VARIABLE)); 702| 112| null_external.type = EXTERNAL_VARIABLE_TYPE_NULL; ------------------ | | 144| 112|#define EXTERNAL_VARIABLE_TYPE_NULL 0 ------------------ 703| | 704| 112| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 705| 112| compiler->arena, 706| 112| YR_EXTERNAL_VARIABLES_TABLE, 707| 112| &null_external, 708| 112| sizeof(YR_EXTERNAL_VARIABLE), 709| 112| NULL)); 710| | 711| | // Write Aho-Corasick automaton to arena. 712| 112| FAIL_ON_ERROR(yr_ac_compile(compiler->automaton, compiler->arena)); ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 713| | 714| 112| YR_ARENA_REF ref; 715| | 716| 112| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 112| { \ | | 135| 112| int __error = (x); \ | | 136| 112| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 112|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 112] | | ------------------ | | 137| 112| return __error; \ | | 138| 112| } ------------------ 717| 112| compiler->arena, YR_SUMMARY_SECTION, sizeof(YR_SUMMARY), &ref, EOL)); 718| | 719| 112| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_ref_to_ptr( 720| 112| compiler->arena, &ref); 721| | 722| 112| summary->num_namespaces = compiler->num_namespaces; 723| 112| summary->num_rules = compiler->next_rule_idx; 724| 112| summary->num_strings = compiler->current_string_idx; 725| | 726| 112| return yr_rules_from_arena(compiler->arena, &compiler->rules); 727| 112|} yara_yyparse: 1883| 1.72k|{ 1884| |/* Lookahead token kind. */ 1885| 1.72k|int yychar; 1886| | 1887| | 1888| |/* The semantic value of the lookahead symbol. */ 1889| |/* Default value used for initialization, for pacifying older GCCs 1890| | or non-GCC compilers. */ 1891| 1.72k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 726| 1.72k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1892| 1.72k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 726| 1.72k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1893| | 1894| | /* Number of syntax errors so far. */ 1895| 1.72k| int yynerrs = 0; 1896| | 1897| 1.72k| yy_state_fast_t yystate = 0; 1898| | /* Number of tokens to shift before error messages enabled. */ 1899| 1.72k| int yyerrstatus = 0; 1900| | 1901| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1902| | to reallocate them elsewhere. */ 1903| | 1904| | /* Their size. */ 1905| 1.72k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 633| 1.72k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1472| 1.72k|# define YYINITDEPTH 200 ------------------ 1906| | 1907| | /* The state stack: array, bottom, top. */ 1908| 1.72k| yy_state_t yyssa[YYINITDEPTH]; 1909| 1.72k| yy_state_t *yyss = yyssa; 1910| 1.72k| yy_state_t *yyssp = yyss; 1911| | 1912| | /* The semantic value stack: array, bottom, top. */ 1913| 1.72k| YYSTYPE yyvsa[YYINITDEPTH]; 1914| 1.72k| YYSTYPE *yyvs = yyvsa; 1915| 1.72k| YYSTYPE *yyvsp = yyvs; 1916| | 1917| 1.72k| int yyn; 1918| | /* The return value of yyparse. */ 1919| 1.72k| int yyresult; 1920| | /* Lookahead symbol kind. */ 1921| 1.72k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1922| | /* The variables used to return semantic value and location from the 1923| | action routines. */ 1924| 1.72k| YYSTYPE yyval; 1925| | 1926| | /* Buffer for error messages, and its allocated size. */ 1927| 1.72k| char yymsgbuf[128]; 1928| 1.72k| char *yymsg = yymsgbuf; 1929| 1.72k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 633| 1.72k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1930| | 1931| 1.72k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1932| | 1933| | /* The number of symbols on the RHS of the reduced rule. 1934| | Keep to zero when no symbol should be popped. */ 1935| 1.72k| int yylen = 0; 1936| | 1937| 1.72k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1463| 1.72k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1938| | 1939| 1.72k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 51| 1.72k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 312| 1.72k|#define YYEMPTY -2 ------------------ 1940| | 1941| 1.72k| goto yysetstate; 1942| | 1943| | 1944| |/*------------------------------------------------------------. 1945| || yynewstate -- push a new state, which is found in yystate. | 1946| |`------------------------------------------------------------*/ 1947| 1.21M|yynewstate: 1948| | /* In all cases, when you get here, the value and location stacks 1949| | have just been pushed. So pushing a state here evens the stacks. */ 1950| 1.21M| yyssp++; 1951| | 1952| | 1953| |/*--------------------------------------------------------------------. 1954| || yysetstate -- set current state (the top of the stack) to yystate. | 1955| |`--------------------------------------------------------------------*/ 1956| 1.21M|yysetstate: 1957| 1.21M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1463| 1.21M|# define YYDPRINTF(Args) ((void) 0) ------------------ 1958| 1.21M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 749| 1.21M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (749:31): [Folded - Ignored] | | | Branch (749:37): [True: 0, False: 0] | | | Branch (749:37): [True: 0, False: 0] | | ------------------ ------------------ 1959| 1.21M| YY_IGNORE_USELESS_CAST_BEGIN 1960| 1.21M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 210| 1.21M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1961| 1.21M| YY_IGNORE_USELESS_CAST_END 1962| 1.21M| YY_STACK_PRINT (yyss, yyssp); 1963| | 1964| 1.21M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1964:7): [True: 97, False: 1.21M] ------------------ 1965| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1966| | YYNOMEM; 1967| |#else 1968| 97| { 1969| | /* Get the current used size of the three stacks, in elements. */ 1970| 97| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 633| 97|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1971| | 1972| |# if defined yyoverflow 1973| | { 1974| | /* Give user a chance to reallocate the stack. Use copies of 1975| | these so that the &'s don't force the real ones into 1976| | memory. */ 1977| | yy_state_t *yyss1 = yyss; 1978| | YYSTYPE *yyvs1 = yyvs; 1979| | 1980| | /* Each stack pointer address is followed by the size of the 1981| | data in use in that stack, in bytes. This used to be a 1982| | conditional around just the two extra args, but that might 1983| | be undefined if yyoverflow is a macro. */ 1984| | yyoverflow (YY_("memory exhausted"), 1985| | &yyss1, yysize * YYSIZEOF (*yyssp), 1986| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1987| | &yystacksize); 1988| | yyss = yyss1; 1989| | yyvs = yyvs1; 1990| | } 1991| |# else /* defined YYSTACK_RELOCATE */ 1992| | /* Extend the stack our own way. */ 1993| 97| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1483| 97|# define YYMAXDEPTH 10000 ------------------ | Branch (1993:11): [True: 1, False: 96] ------------------ 1994| 1| YYNOMEM; ------------------ | | 1314| 1|#define YYNOMEM goto yyexhaustedlab ------------------ 1995| 96| yystacksize *= 2; 1996| 96| if (YYMAXDEPTH < yystacksize) ------------------ | | 1483| 96|# define YYMAXDEPTH 10000 ------------------ | Branch (1996:11): [True: 3, False: 93] ------------------ 1997| 3| yystacksize = YYMAXDEPTH; ------------------ | | 1483| 3|# define YYMAXDEPTH 10000 ------------------ 1998| | 1999| 96| { 2000| 96| yy_state_t *yyss1 = yyss; 2001| 96| union yyalloc *yyptr = 2002| 96| YY_CAST (union yyalloc *, ------------------ | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2003| 96| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2004| 96| if (! yyptr) ------------------ | Branch (2004:13): [True: 0, False: 96] ------------------ 2005| 0| YYNOMEM; ------------------ | | 1314| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2006| 96| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 846| 96| do \ | | 847| 96| { \ | | 848| 96| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 633| 96|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 849| 96| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 864| 96| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 850| 96| Stack = &yyptr->Stack_alloc; \ | | 851| 96| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 830| 96|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 852| 96| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 853| 96| } \ | | 854| 96| while (0) | | ------------------ | | | Branch (854:12): [Folded - Ignored] | | ------------------ ------------------ 2007| 96| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 846| 96| do \ | | 847| 96| { \ | | 848| 96| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 633| 96|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 849| 96| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 864| 96| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 850| 96| Stack = &yyptr->Stack_alloc; \ | | 851| 96| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 830| 96|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 852| 96| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 666| 96|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 96|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 853| 96| } \ | | 854| 96| while (0) | | ------------------ | | | Branch (854:12): [Folded - Ignored] | | ------------------ ------------------ 2008| 96|# undef YYSTACK_RELOCATE 2009| 96| if (yyss1 != yyssa) ------------------ | Branch (2009:13): [True: 51, False: 45] ------------------ 2010| 51| YYSTACK_FREE (yyss1); ------------------ | | 791| 51|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 51|#define YYFREE yr_free | | ------------------ ------------------ 2011| 96| } 2012| 0|# endif 2013| | 2014| 0| yyssp = yyss + yysize - 1; 2015| 96| yyvsp = yyvs + yysize - 1; 2016| | 2017| 96| YY_IGNORE_USELESS_CAST_BEGIN 2018| 96| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1463| 96|# define YYDPRINTF(Args) ((void) 0) ------------------ 2019| 96| YY_CAST (long, yystacksize))); 2020| 96| YY_IGNORE_USELESS_CAST_END 2021| | 2022| 96| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2022:11): [True: 0, False: 96] ------------------ 2023| 0| YYABORT; ------------------ | | 1312| 0|#define YYABORT goto yyabortlab ------------------ 2024| 96| } 2025| 1.21M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2026| | 2027| | 2028| 1.21M| if (yystate == YYFINAL) ------------------ | | 879| 1.21M|#define YYFINAL 2 ------------------ | Branch (2028:7): [True: 133, False: 1.21M] ------------------ 2029| 133| YYACCEPT; ------------------ | | 1311| 133|#define YYACCEPT goto yyacceptlab ------------------ 2030| | 2031| 1.21M| goto yybackup; 2032| | 2033| | 2034| |/*-----------. 2035| || yybackup. | 2036| |`-----------*/ 2037| 1.21M|yybackup: 2038| | /* Do appropriate processing given the current state. Read a 2039| | lookahead token if we need one and don't already have one. */ 2040| | 2041| | /* First try to decide what to do without reference to lookahead token. */ 2042| 1.21M| yyn = yypact[yystate]; 2043| 1.21M| if (yypact_value_is_default (yyn)) ------------------ | | 1020| 1.21M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 1.21M|#define YYPACT_NINF (-170) | | ------------------ | | | Branch (1020:3): [True: 251k, False: 963k] | | ------------------ ------------------ 2044| 251k| goto yydefault; 2045| | 2046| | /* Not known => get a lookahead token if don't already have one. */ 2047| | 2048| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2049| 963k| if (yychar == YYEMPTY) ------------------ | | 51| 963k|#define yychar yara_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 312| 963k|#define YYEMPTY -2 ------------------ | Branch (2049:7): [True: 571k, False: 391k] ------------------ 2050| 571k| { 2051| 571k| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1463| 571k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2052| 571k| yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 51| 571k|#define yychar yara_yychar ------------------ yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 47| 571k|#define yylex yara_yylex ------------------ 2053| 571k| } 2054| | 2055| 963k| if (yychar <= _END_OF_FILE_) ------------------ | | 51| 963k|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 963k|#define _END_OF_FILE_ 0 ------------------ | Branch (2055:7): [True: 4.54k, False: 959k] ------------------ 2056| 4.54k| { 2057| 4.54k| yychar = _END_OF_FILE_; ------------------ | | 51| 4.54k|#define yychar yara_yychar ------------------ yychar = _END_OF_FILE_; ------------------ | | 313| 4.54k|#define _END_OF_FILE_ 0 ------------------ 2058| 4.54k| yytoken = YYSYMBOL_YYEOF; 2059| 4.54k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1463| 4.54k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2060| 4.54k| } 2061| 959k| else if (yychar == YYerror) ------------------ | | 51| 959k|#define yychar yara_yychar ------------------ else if (yychar == YYerror) ------------------ | | 314| 959k|#define YYerror 256 ------------------ | Branch (2061:12): [True: 0, False: 959k] ------------------ 2062| 0| { 2063| | /* The scanner already issued an error message, process directly 2064| | to error recovery. But do not keep the error token as 2065| | lookahead, it is too special and may lead us to an endless 2066| | loop in error recovery. */ 2067| 0| yychar = YYUNDEF; ------------------ | | 51| 0|#define yychar yara_yychar ------------------ yychar = YYUNDEF; ------------------ | | 315| 0|#define YYUNDEF 257 ------------------ 2068| 0| yytoken = YYSYMBOL_YYerror; 2069| 0| goto yyerrlab1; 2070| 0| } 2071| 959k| else 2072| 959k| { 2073| 959k| yytoken = YYTRANSLATE (yychar); ------------------ | | 899| 959k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 959k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 959k, False: 0] | | | Branch (899:18): [True: 959k, False: 0] | | ------------------ | | 900| 959k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 959k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 959k| : YYSYMBOL_YYUNDEF) ------------------ 2074| 959k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2075| 959k| } 2076| | 2077| | /* If the proper action on seeing token YYTOKEN is to reduce or to 2078| | detect an error, take that action. */ 2079| 963k| yyn += yytoken; 2080| 963k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 881| 962k|#define YYLAST 480 ------------------ | Branch (2080:7): [True: 1.18k, False: 962k] | Branch (2080:18): [True: 429, False: 961k] | Branch (2080:34): [True: 523k, False: 437k] ------------------ 2081| 525k| goto yydefault; 2082| 437k| yyn = yytable[yyn]; 2083| 437k| if (yyn <= 0) ------------------ | Branch (2083:7): [True: 23.7k, False: 414k] ------------------ 2084| 23.7k| { 2085| 23.7k| if (yytable_value_is_error (yyn)) ------------------ | | 1025| 23.7k| 0 | | ------------------ | | | Branch (1025:3): [Folded - Ignored] | | ------------------ ------------------ 2086| 0| goto yyerrlab; 2087| 23.7k| yyn = -yyn; 2088| 23.7k| goto yyreduce; 2089| 23.7k| } 2090| | 2091| | /* Count tokens shifted since error; after three, turn off error 2092| | status. */ 2093| 414k| if (yyerrstatus) ------------------ | Branch (2093:7): [True: 36.2k, False: 377k] ------------------ 2094| 36.2k| yyerrstatus--; 2095| | 2096| | /* Shift the lookahead token. */ 2097| 414k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2098| 414k| yystate = yyn; 2099| 414k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2100| 414k| *++yyvsp = yylval; 2101| 414k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2102| | 2103| | /* Discard the shifted token. */ 2104| 414k| yychar = YYEMPTY; ------------------ | | 51| 414k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 414k|#define YYEMPTY -2 ------------------ 2105| 414k| goto yynewstate; 2106| | 2107| | 2108| |/*-----------------------------------------------------------. 2109| || yydefault -- do the default action for the current state. | 2110| |`-----------------------------------------------------------*/ 2111| 777k|yydefault: 2112| 777k| yyn = yydefact[yystate]; 2113| 777k| if (yyn == 0) ------------------ | Branch (2113:7): [True: 166k, False: 610k] ------------------ 2114| 166k| goto yyerrlab; 2115| 610k| goto yyreduce; 2116| | 2117| | 2118| |/*-----------------------------. 2119| || yyreduce -- do a reduction. | 2120| |`-----------------------------*/ 2121| 634k|yyreduce: 2122| | /* yyn is the number of a rule to reduce with. */ 2123| 634k| yylen = yyr2[yyn]; 2124| | 2125| | /* If YYLEN is nonzero, implement the default value of the action: 2126| | '$$ = $1'. 2127| | 2128| | Otherwise, the following line sets YYVAL to garbage. 2129| | This behavior is undocumented and Bison 2130| | users should not rely upon it. Assigning to YYVAL 2131| | unconditionally makes the parser a bit smaller, and it avoids a 2132| | GCC warning that YYVAL may be used uninitialized. */ 2133| 634k| yyval = yyvsp[1-yylen]; 2134| | 2135| | 2136| 634k| YY_REDUCE_PRINT (yyn); 2137| 634k| switch (yyn) 2138| 634k| { 2139| 0| case 8: /* rules: rules "end of included file" */ ------------------ | Branch (2139:3): [True: 0, False: 634k] ------------------ 2140| 0|#line 369 "libyara/grammar.y" 2141| 0| { 2142| 0| _yr_compiler_pop_file_name(compiler); 2143| 0| } 2144| 0|#line 2145 "libyara/grammar.c" 2145| 0| break; 2146| | 2147| 0| case 9: /* rules: rules error "end of included file" */ ------------------ | Branch (2147:3): [True: 0, False: 634k] ------------------ 2148| 0|#line 373 "libyara/grammar.y" 2149| 0| { 2150| 0| _yr_compiler_pop_file_name(compiler); 2151| 0| } 2152| 0|#line 2153 "libyara/grammar.c" 2153| 0| break; 2154| | 2155| 1.91k| case 10: /* import: "" "text string" */ ------------------ | Branch (2155:3): [True: 1.91k, False: 632k] ------------------ 2156| 1.91k|#line 381 "libyara/grammar.y" 2157| 1.91k| { 2158| 1.91k| int result = yr_parser_reduce_import(yyscanner, (yyvsp[0].sized_string)); 2159| | 2160| 1.91k| yr_free((yyvsp[0].sized_string)); 2161| | 2162| 1.91k| fail_if_error(result); ------------------ | | 135| 1.91k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.83k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.54k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 630, False: 1.28k] | | | Branch (135:31): [True: 630, False: 0] | | ------------------ | | 136| 1.91k| { \ | | 137| 630| fail_with_error(e); \ | | ------------------ | | | | 120| 630| { \ | | | | 121| 630| compiler->last_error = e; \ | | | | 122| 630| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 630|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 630| switch (e) \ | | | | 124| 630| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 630] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 630| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 630, False: 0] | | | | ------------------ | | | | 128| 630| YYERROR; \ | | | | ------------------ | | | | | | 1313| 630|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 630| } \ | | | | 130| 630| } | | ------------------ | | 138| 0| } ------------------ 2163| 1.28k| } 2164| 0|#line 2165 "libyara/grammar.c" 2165| 0| break; 2166| | 2167| 13.8k| case 11: /* @1: %empty */ ------------------ | Branch (2167:3): [True: 13.8k, False: 620k] ------------------ 2168| 13.8k|#line 393 "libyara/grammar.y" 2169| 13.8k| { 2170| 13.8k| fail_if_error(yr_parser_reduce_rule_declaration_phase_1( ------------------ | | 135| 13.8k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 27.6k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 17.7k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 3.93k, False: 9.88k] | | | Branch (135:31): [True: 3.93k, False: 0] | | ------------------ | | 136| 13.8k| { \ | | 137| 3.93k| fail_with_error(e); \ | | ------------------ | | | | 120| 3.93k| { \ | | | | 121| 3.93k| compiler->last_error = e; \ | | | | 122| 3.93k| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 3.93k|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 3.93k| switch (e) \ | | | | 124| 3.93k| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 3.93k] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 3.93k| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 3.93k, False: 0] | | | | ------------------ | | | | 128| 3.93k| YYERROR; \ | | | | ------------------ | | | | | | 1313| 3.93k|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 3.93k| } \ | | | | 130| 3.93k| } | | ------------------ | | 138| 0| } ------------------ 2171| 13.8k| yyscanner, (int32_t) (yyvsp[-2].integer), (yyvsp[0].c_string), &(yyval.rule))); 2172| 9.88k| } 2173| 0|#line 2174 "libyara/grammar.c" 2174| 0| break; 2175| | 2176| 6.24k| case 12: /* $@2: %empty */ ------------------ | Branch (2176:3): [True: 6.24k, False: 627k] ------------------ 2177| 6.24k|#line 398 "libyara/grammar.y" 2178| 6.24k| { 2179| 6.24k| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr( 2180| 6.24k| compiler->arena, &(yyvsp[-4].rule)); 2181| | 2182| 6.24k| rule->tags = (char*) yr_arena_ref_to_ptr( 2183| 6.24k| compiler->arena, &(yyvsp[-3].tag)); 2184| | 2185| 6.24k| rule->metas = (YR_META*) yr_arena_ref_to_ptr( 2186| 6.24k| compiler->arena, &(yyvsp[-1].meta)); 2187| | 2188| 6.24k| rule->strings = (YR_STRING*) yr_arena_ref_to_ptr( 2189| 6.24k| compiler->arena, &(yyvsp[0].string)); 2190| 6.24k| } 2191| 6.24k|#line 2192 "libyara/grammar.c" 2192| 6.24k| break; 2193| | 2194| 388| case 13: /* rule: rule_modifiers "" "identifier" @1 tags '{' meta strings $@2 condition '}' */ ------------------ | Branch (2194:3): [True: 388, False: 633k] ------------------ 2195| 388|#line 412 "libyara/grammar.y" 2196| 388| { 2197| 388| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr( 2198| 388| compiler->arena, &(yyvsp[-7].rule)); 2199| 388| rule->required_strings = (yyvsp[-1].expression).required_strings.count; 2200| | 2201| 388| int result = yr_parser_reduce_rule_declaration_phase_2( 2202| 388| yyscanner, &(yyvsp[-7].rule)); // rule created in phase 1 2203| | 2204| 388| yr_free((yyvsp[-8].c_string)); 2205| | 2206| 388| fail_if_error(result); ------------------ | | 135| 388| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 776|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 408|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 20, False: 368] | | | Branch (135:31): [True: 20, False: 0] | | ------------------ | | 136| 388| { \ | | 137| 20| fail_with_error(e); \ | | ------------------ | | | | 120| 20| { \ | | | | 121| 20| compiler->last_error = e; \ | | | | 122| 20| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 20|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 20| switch (e) \ | | | | 124| 20| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 20] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 20| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 20, False: 0] | | | | ------------------ | | | | 128| 20| YYERROR; \ | | | | ------------------ | | | | | | 1313| 20|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 20| } \ | | | | 130| 20| } | | ------------------ | | 138| 0| } ------------------ 2207| 368| } 2208| 0|#line 2209 "libyara/grammar.c" 2209| 0| break; 2210| | 2211| 7.43k| case 14: /* meta: %empty */ ------------------ | Branch (2211:3): [True: 7.43k, False: 626k] ------------------ 2212| 7.43k|#line 429 "libyara/grammar.y" 2213| 7.43k| { 2214| 7.43k| (yyval.meta) = YR_ARENA_NULL_REF; ------------------ | | 43| 7.43k| (YR_ARENA_REF) \ | | 44| 7.43k| { \ | | 45| 7.43k| UINT32_MAX, UINT32_MAX \ | | 46| 7.43k| } ------------------ 2215| 7.43k| } 2216| 7.43k|#line 2217 "libyara/grammar.c" 2217| 7.43k| break; 2218| | 2219| 18| case 15: /* meta: "" ':' meta_declarations */ ------------------ | Branch (2219:3): [True: 18, False: 634k] ------------------ 2220| 18|#line 433 "libyara/grammar.y" 2221| 18| { 2222| 18| YR_META* meta = yr_arena_get_ptr( 2223| 18| compiler->arena, 2224| 18| YR_METAS_TABLE, ------------------ | | 59| 18|#define YR_METAS_TABLE 2 ------------------ 2225| 18| (compiler->current_meta_idx - 1) * sizeof(YR_META)); 2226| | 2227| 18| meta->flags |= META_FLAGS_LAST_IN_RULE; ------------------ | | 140| 18|#define META_FLAGS_LAST_IN_RULE 1 ------------------ 2228| | 2229| 18| (yyval.meta) = (yyvsp[0].meta); 2230| 18| } 2231| 18|#line 2232 "libyara/grammar.c" 2232| 18| break; 2233| | 2234| 5.25k| case 16: /* strings: %empty */ ------------------ | Branch (2234:3): [True: 5.25k, False: 628k] ------------------ 2235| 5.25k|#line 448 "libyara/grammar.y" 2236| 5.25k| { 2237| 5.25k| (yyval.string) = YR_ARENA_NULL_REF; ------------------ | | 43| 5.25k| (YR_ARENA_REF) \ | | 44| 5.25k| { \ | | 45| 5.25k| UINT32_MAX, UINT32_MAX \ | | 46| 5.25k| } ------------------ 2238| 5.25k| } 2239| 5.25k|#line 2240 "libyara/grammar.c" 2240| 5.25k| break; 2241| | 2242| 999| case 17: /* strings: "" ':' string_declarations */ ------------------ | Branch (2242:3): [True: 999, False: 633k] ------------------ 2243| 999|#line 452 "libyara/grammar.y" 2244| 999| { 2245| 999| YR_STRING* string = (YR_STRING*) yr_arena_get_ptr( 2246| 999| compiler->arena, 2247| 999| YR_STRINGS_TABLE, ------------------ | | 60| 999|#define YR_STRINGS_TABLE 3 ------------------ 2248| 999| (compiler->current_string_idx - 1) * sizeof(YR_STRING)); 2249| | 2250| 999| string->flags |= STRING_FLAGS_LAST_IN_RULE; ------------------ | | 78| 999|#define STRING_FLAGS_LAST_IN_RULE 0x1000 ------------------ 2251| | 2252| 999| (yyval.string) = (yyvsp[0].string); 2253| 999| } 2254| 999|#line 2255 "libyara/grammar.c" 2255| 999| break; 2256| | 2257| 748| case 18: /* condition: "" ':' boolean_expression */ ------------------ | Branch (2257:3): [True: 748, False: 633k] ------------------ 2258| 748|#line 467 "libyara/grammar.y" 2259| 748| { 2260| 748| (yyval.expression) = (yyvsp[0].expression); 2261| 748| } 2262| 748|#line 2263 "libyara/grammar.c" 2263| 748| break; 2264| | 2265| 172k| case 19: /* rule_modifiers: %empty */ ------------------ | Branch (2265:3): [True: 172k, False: 461k] ------------------ 2266| 172k|#line 474 "libyara/grammar.y" 2267| 172k| { (yyval.integer) = 0; } 2268| 172k|#line 2269 "libyara/grammar.c" 2269| 172k| break; 2270| | 2271| 604| case 20: /* rule_modifiers: rule_modifiers rule_modifier */ ------------------ | Branch (2271:3): [True: 604, False: 633k] ------------------ 2272| 604|#line 475 "libyara/grammar.y" 2273| 604| { (yyval.integer) = (yyvsp[-1].integer) | (yyvsp[0].integer); } 2274| 604|#line 2275 "libyara/grammar.c" 2275| 604| break; 2276| | 2277| 169| case 21: /* rule_modifier: "" */ ------------------ | Branch (2277:3): [True: 169, False: 634k] ------------------ 2278| 169|#line 480 "libyara/grammar.y" 2279| 169| { (yyval.integer) = RULE_FLAGS_PRIVATE; } ------------------ | | 52| 169|#define RULE_FLAGS_PRIVATE 0x01 ------------------ 2280| 169|#line 2281 "libyara/grammar.c" 2281| 169| break; 2282| | 2283| 435| case 22: /* rule_modifier: "" */ ------------------ | Branch (2283:3): [True: 435, False: 633k] ------------------ 2284| 435|#line 481 "libyara/grammar.y" 2285| 435| { (yyval.integer) = RULE_FLAGS_GLOBAL; } ------------------ | | 53| 435|#define RULE_FLAGS_GLOBAL 0x02 ------------------ 2286| 435|#line 2287 "libyara/grammar.c" 2287| 435| break; 2288| | 2289| 9.34k| case 23: /* tags: %empty */ ------------------ | Branch (2289:3): [True: 9.34k, False: 624k] ------------------ 2290| 9.34k|#line 487 "libyara/grammar.y" 2291| 9.34k| { 2292| 9.34k| (yyval.tag) = YR_ARENA_NULL_REF; ------------------ | | 43| 9.34k| (YR_ARENA_REF) \ | | 44| 9.34k| { \ | | 45| 9.34k| UINT32_MAX, UINT32_MAX \ | | 46| 9.34k| } ------------------ 2293| 9.34k| } 2294| 9.34k|#line 2295 "libyara/grammar.c" 2295| 9.34k| break; 2296| | 2297| 223| case 24: /* tags: ':' tag_list */ ------------------ | Branch (2297:3): [True: 223, False: 633k] ------------------ 2298| 223|#line 491 "libyara/grammar.y" 2299| 223| { 2300| | // Tags list is represented in the arena as a sequence 2301| | // of null-terminated strings, the sequence ends with an 2302| | // additional null character. Here we write the ending null 2303| | //character. Example: tag1\0tag2\0tag3\0\0 2304| | 2305| 223| fail_if_error(yr_arena_write_string( ------------------ | | 135| 223| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 446|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 223|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 223] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 223| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2306| 223| yyget_extra(yyscanner)->arena, YR_SZ_POOL, "", NULL)); 2307| | 2308| 223| (yyval.tag) = (yyvsp[0].tag); 2309| 223| } 2310| 0|#line 2311 "libyara/grammar.c" 2311| 0| break; 2312| | 2313| 235| case 25: /* tag_list: "identifier" */ ------------------ | Branch (2313:3): [True: 235, False: 633k] ------------------ 2314| 235|#line 507 "libyara/grammar.y" 2315| 235| { 2316| 235| int result = yr_arena_write_string( 2317| 235| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 54| 235|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 62| 235|#define YR_SZ_POOL 5 ------------------ 2318| | 2319| 235| yr_free((yyvsp[0].c_string)); 2320| | 2321| 235| fail_if_error(result); ------------------ | | 135| 235| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 470|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 235|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 235] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 235| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2322| 235| } 2323| 0|#line 2324 "libyara/grammar.c" 2324| 0| break; 2325| | 2326| 175| case 26: /* tag_list: tag_list "identifier" */ ------------------ | Branch (2326:3): [True: 175, False: 634k] ------------------ 2327| 175|#line 516 "libyara/grammar.y" 2328| 175| { 2329| 175| YR_ARENA_REF ref; 2330| | 2331| | // Write the new tag identifier. 2332| 175| int result = yr_arena_write_string( 2333| 175| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 54| 175|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 62| 175|#define YR_SZ_POOL 5 ------------------ 2334| | 2335| 175| yr_free((yyvsp[0].c_string)); 2336| | 2337| 175| fail_if_error(result); ------------------ | | 135| 175| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 350|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 175|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 175] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 175| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2338| | 2339| | // Get the address for the tag identifier just written. 2340| 175| char* new_tag = (char*) yr_arena_ref_to_ptr( 2341| 175| compiler->arena, &ref); 2342| | 2343| | // Take the address of first tag's identifier in the list. 2344| 175| char* tag = (char*) yr_arena_ref_to_ptr( 2345| 175| compiler->arena, &(yyval.tag)); 2346| | 2347| | // Search for duplicated tags. Tags are written one after 2348| | // the other, with zeroes in between (i.e: tag1/0tag2/0tag3) 2349| | // that's why can use tag < new_tag as the condition for the 2350| | // loop. 2351| 392| while (tag < new_tag) ------------------ | Branch (2351:16): [True: 229, False: 163] ------------------ 2352| 229| { 2353| 229| if (strcmp(tag, new_tag) == 0) ------------------ | Branch (2353:15): [True: 12, False: 217] ------------------ 2354| 12| { 2355| 12| yr_compiler_set_error_extra_info(compiler, tag); ------------------ | | 306| 12| strlcpy( \ | | 307| 12| compiler->last_error_extra_info, \ | | 308| 12| info, \ | | 309| 12| sizeof(compiler->last_error_extra_info)); ------------------ 2356| 12| fail_with_error(ERROR_DUPLICATED_TAG_IDENTIFIER); ------------------ | | 120| 12| { \ | | 121| 12| compiler->last_error = e; \ | | 122| 12| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 12|#define yyerror yara_yyerror | | ------------------ | | 123| 12| switch (e) \ | | 124| 12| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 12] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 12| default: \ | | ------------------ | | | Branch (127:7): [True: 12, False: 0] | | ------------------ | | 128| 12| YYERROR; \ | | ------------------ | | | | 1313| 12|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 12| } \ | | 130| 12| } ------------------ 2357| 0| } 2358| | 2359| 217| tag += strlen(tag) + 1; 2360| 217| } 2361| | 2362| 163| (yyval.tag) = (yyvsp[-1].tag); 2363| 163| } 2364| 0|#line 2365 "libyara/grammar.c" 2365| 0| break; 2366| | 2367| 33| case 27: /* meta_declarations: meta_declaration */ ------------------ | Branch (2367:3): [True: 33, False: 634k] ------------------ 2368| 33|#line 557 "libyara/grammar.y" 2369| 33| { (yyval.meta) = (yyvsp[0].meta); } 2370| 33|#line 2371 "libyara/grammar.c" 2371| 33| break; 2372| | 2373| 1.03k| case 28: /* meta_declarations: meta_declarations meta_declaration */ ------------------ | Branch (2373:3): [True: 1.03k, False: 633k] ------------------ 2374| 1.03k|#line 558 "libyara/grammar.y" 2375| 1.03k| { (yyval.meta) = (yyvsp[-1].meta); } 2376| 1.03k|#line 2377 "libyara/grammar.c" 2377| 1.03k| break; 2378| | 2379| 326| case 29: /* meta_declaration: "identifier" '=' "text string" */ ------------------ | Branch (2379:3): [True: 326, False: 633k] ------------------ 2380| 326|#line 564 "libyara/grammar.y" 2381| 326| { 2382| 326| SIZED_STRING* sized_string = (yyvsp[0].sized_string); 2383| | 2384| 326| int result = yr_parser_reduce_meta_declaration( 2385| 326| yyscanner, 2386| 326| META_TYPE_STRING, ------------------ | | 137| 326|#define META_TYPE_STRING 2 ------------------ 2387| 326| (yyvsp[-2].c_string), 2388| 326| sized_string->c_string, 2389| 326| 0, 2390| 326| &(yyval.meta)); 2391| | 2392| 326| yr_free((yyvsp[-2].c_string)); 2393| 326| yr_free((yyvsp[0].sized_string)); 2394| | 2395| 326| fail_if_error(result); ------------------ | | 135| 326| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 652|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 326|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 326] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 326| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2396| 326| } 2397| 0|#line 2398 "libyara/grammar.c" 2398| 0| break; 2399| | 2400| 257| case 30: /* meta_declaration: "identifier" '=' "integer number" */ ------------------ | Branch (2400:3): [True: 257, False: 633k] ------------------ 2401| 257|#line 581 "libyara/grammar.y" 2402| 257| { 2403| 257| int result = yr_parser_reduce_meta_declaration( 2404| 257| yyscanner, 2405| 257| META_TYPE_INTEGER, ------------------ | | 136| 257|#define META_TYPE_INTEGER 1 ------------------ 2406| 257| (yyvsp[-2].c_string), 2407| 257| NULL, 2408| 257| (yyvsp[0].integer), 2409| 257| &(yyval.meta)); 2410| | 2411| 257| yr_free((yyvsp[-2].c_string)); 2412| | 2413| 257| fail_if_error(result); ------------------ | | 135| 257| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 514|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 257|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 257] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 257| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2414| 257| } 2415| 0|#line 2416 "libyara/grammar.c" 2416| 0| break; 2417| | 2418| 191| case 31: /* meta_declaration: "identifier" '=' '-' "integer number" */ ------------------ | Branch (2418:3): [True: 191, False: 634k] ------------------ 2419| 191|#line 595 "libyara/grammar.y" 2420| 191| { 2421| 191| int result = yr_parser_reduce_meta_declaration( 2422| 191| yyscanner, 2423| 191| META_TYPE_INTEGER, ------------------ | | 136| 191|#define META_TYPE_INTEGER 1 ------------------ 2424| 191| (yyvsp[-3].c_string), 2425| 191| NULL, 2426| 191| -(yyvsp[0].integer), 2427| 191| &(yyval.meta)); 2428| | 2429| 191| yr_free((yyvsp[-3].c_string)); 2430| | 2431| 191| fail_if_error(result); ------------------ | | 135| 191| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 382|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 191|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 191] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 191| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2432| 191| } 2433| 0|#line 2434 "libyara/grammar.c" 2434| 0| break; 2435| | 2436| 128| case 32: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2436:3): [True: 128, False: 634k] ------------------ 2437| 128|#line 609 "libyara/grammar.y" 2438| 128| { 2439| 128| int result = yr_parser_reduce_meta_declaration( 2440| 128| yyscanner, 2441| 128| META_TYPE_BOOLEAN, ------------------ | | 138| 128|#define META_TYPE_BOOLEAN 3 ------------------ 2442| 128| (yyvsp[-2].c_string), 2443| 128| NULL, 2444| 128| true, 2445| 128| &(yyval.meta)); 2446| | 2447| 128| yr_free((yyvsp[-2].c_string)); 2448| | 2449| 128| fail_if_error(result); ------------------ | | 135| 128| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 256|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 128|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 128] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 128| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2450| 128| } 2451| 0|#line 2452 "libyara/grammar.c" 2452| 0| break; 2453| | 2454| 162| case 33: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2454:3): [True: 162, False: 634k] ------------------ 2455| 162|#line 623 "libyara/grammar.y" 2456| 162| { 2457| 162| int result = yr_parser_reduce_meta_declaration( 2458| 162| yyscanner, 2459| 162| META_TYPE_BOOLEAN, ------------------ | | 138| 162|#define META_TYPE_BOOLEAN 3 ------------------ 2460| 162| (yyvsp[-2].c_string), 2461| 162| NULL, 2462| 162| false, 2463| 162| &(yyval.meta)); 2464| | 2465| 162| yr_free((yyvsp[-2].c_string)); 2466| | 2467| 162| fail_if_error(result); ------------------ | | 135| 162| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 324|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 162|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 162] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 162| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2468| 162| } 2469| 0|#line 2470 "libyara/grammar.c" 2470| 0| break; 2471| | 2472| 1.10k| case 34: /* string_declarations: string_declaration */ ------------------ | Branch (2472:3): [True: 1.10k, False: 633k] ------------------ 2473| 1.10k|#line 640 "libyara/grammar.y" 2474| 1.10k| { (yyval.string) = (yyvsp[0].string); } 2475| 1.10k|#line 2476 "libyara/grammar.c" 2476| 1.10k| break; 2477| | 2478| 16.1k| case 35: /* string_declarations: string_declarations string_declaration */ ------------------ | Branch (2478:3): [True: 16.1k, False: 618k] ------------------ 2479| 16.1k|#line 641 "libyara/grammar.y" 2480| 16.1k| { (yyval.string) = (yyvsp[-1].string); } 2481| 16.1k|#line 2482 "libyara/grammar.c" 2482| 16.1k| break; 2483| | 2484| 4.81k| case 36: /* $@3: %empty */ ------------------ | Branch (2484:3): [True: 4.81k, False: 629k] ------------------ 2485| 4.81k|#line 647 "libyara/grammar.y" 2486| 4.81k| { 2487| 4.81k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 4.81k|#define yyget_lineno yara_yyget_lineno ------------------ 2488| 4.81k| } 2489| 4.81k|#line 2490 "libyara/grammar.c" 2490| 4.81k| break; 2491| | 2492| 4.63k| case 37: /* string_declaration: "string identifier" '=' $@3 "text string" string_modifiers */ ------------------ | Branch (2492:3): [True: 4.63k, False: 629k] ------------------ 2493| 4.63k|#line 651 "libyara/grammar.y" 2494| 4.63k| { 2495| 4.63k| int result = yr_parser_reduce_string_declaration( 2496| 4.63k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2497| | 2498| 4.63k| yr_free((yyvsp[-4].c_string)); 2499| 4.63k| yr_free((yyvsp[-1].sized_string)); 2500| 4.63k| yr_free((yyvsp[0].modifier).alphabet); 2501| | 2502| 4.63k| fail_if_error(result); ------------------ | | 135| 4.63k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 9.27k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 4.65k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 17, False: 4.62k] | | | Branch (135:31): [True: 17, False: 0] | | ------------------ | | 136| 4.63k| { \ | | 137| 17| fail_with_error(e); \ | | ------------------ | | | | 120| 17| { \ | | | | 121| 17| compiler->last_error = e; \ | | | | 122| 17| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 17|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 17| switch (e) \ | | | | 124| 17| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 17] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 17| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 17, False: 0] | | | | ------------------ | | | | 128| 17| YYERROR; \ | | | | ------------------ | | | | | | 1313| 17|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 17| } \ | | | | 130| 17| } | | ------------------ | | 138| 0| } ------------------ 2503| 4.62k| compiler->current_line = 0; 2504| 4.62k| } 2505| 0|#line 2506 "libyara/grammar.c" 2506| 0| break; 2507| | 2508| 12.2k| case 38: /* $@4: %empty */ ------------------ | Branch (2508:3): [True: 12.2k, False: 621k] ------------------ 2509| 12.2k|#line 663 "libyara/grammar.y" 2510| 12.2k| { 2511| 12.2k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 12.2k|#define yyget_lineno yara_yyget_lineno ------------------ 2512| 12.2k| } 2513| 12.2k|#line 2514 "libyara/grammar.c" 2514| 12.2k| break; 2515| | 2516| 12.2k| case 39: /* string_declaration: "string identifier" '=' $@4 "regular expression" regexp_modifiers */ ------------------ | Branch (2516:3): [True: 12.2k, False: 621k] ------------------ 2517| 12.2k|#line 667 "libyara/grammar.y" 2518| 12.2k| { 2519| 12.2k| int result; 2520| | 2521| 12.2k| (yyvsp[0].modifier).flags |= STRING_FLAGS_REGEXP; ------------------ | | 71| 12.2k|#define STRING_FLAGS_REGEXP 0x20 ------------------ 2522| | 2523| 12.2k| result = yr_parser_reduce_string_declaration( 2524| 12.2k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2525| | 2526| 12.2k| yr_free((yyvsp[-4].c_string)); 2527| 12.2k| yr_free((yyvsp[-1].sized_string)); 2528| | 2529| 12.2k| fail_if_error(result); ------------------ | | 135| 12.2k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 24.5k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 12.9k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 640, False: 11.6k] | | | Branch (135:31): [True: 640, False: 0] | | ------------------ | | 136| 12.2k| { \ | | 137| 640| fail_with_error(e); \ | | ------------------ | | | | 120| 640| { \ | | | | 121| 640| compiler->last_error = e; \ | | | | 122| 640| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 640|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 640| switch (e) \ | | | | 124| 640| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 640] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 640| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 640, False: 0] | | | | ------------------ | | | | 128| 640| YYERROR; \ | | | | ------------------ | | | | | | 1313| 640|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 640| } \ | | | | 130| 640| } | | ------------------ | | 138| 0| } ------------------ 2530| | 2531| 11.6k| compiler->current_line = 0; 2532| 11.6k| } 2533| 0|#line 2534 "libyara/grammar.c" 2534| 0| break; 2535| | 2536| 1.27k| case 40: /* $@5: %empty */ ------------------ | Branch (2536:3): [True: 1.27k, False: 632k] ------------------ 2537| 1.27k|#line 683 "libyara/grammar.y" 2538| 1.27k| { 2539| 1.27k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 1.27k|#define yyget_lineno yara_yyget_lineno ------------------ 2540| 1.27k| } 2541| 1.27k|#line 2542 "libyara/grammar.c" 2542| 1.27k| break; 2543| | 2544| 1.27k| case 41: /* string_declaration: "string identifier" '=' $@5 "hex string" hex_modifiers */ ------------------ | Branch (2544:3): [True: 1.27k, False: 632k] ------------------ 2545| 1.27k|#line 687 "libyara/grammar.y" 2546| 1.27k| { 2547| 1.27k| int result; 2548| | 2549| 1.27k| (yyvsp[0].modifier).flags |= STRING_FLAGS_HEXADECIMAL; ------------------ | | 67| 1.27k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ 2550| | 2551| 1.27k| result = yr_parser_reduce_string_declaration( 2552| 1.27k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2553| | 2554| 1.27k| yr_free((yyvsp[-4].c_string)); 2555| 1.27k| yr_free((yyvsp[-1].sized_string)); 2556| | 2557| 1.27k| fail_if_error(result); ------------------ | | 135| 1.27k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 2.54k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.51k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 249, False: 1.02k] | | | Branch (135:31): [True: 249, False: 0] | | ------------------ | | 136| 1.27k| { \ | | 137| 249| fail_with_error(e); \ | | ------------------ | | | | 120| 249| { \ | | | | 121| 249| compiler->last_error = e; \ | | | | 122| 249| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 249|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 249| switch (e) \ | | | | 124| 249| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 249] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 249| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 249, False: 0] | | | | ------------------ | | | | 128| 249| YYERROR; \ | | | | ------------------ | | | | | | 1313| 249|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 249| } \ | | | | 130| 249| } | | ------------------ | | 138| 0| } ------------------ 2558| | 2559| 1.02k| compiler->current_line = 0; 2560| 1.02k| } 2561| 0|#line 2562 "libyara/grammar.c" 2562| 0| break; 2563| | 2564| 4.69k| case 42: /* string_modifiers: %empty */ ------------------ | Branch (2564:3): [True: 4.69k, False: 629k] ------------------ 2565| 4.69k|#line 707 "libyara/grammar.y" 2566| 4.69k| { 2567| 4.69k| (yyval.modifier).flags = 0; 2568| 4.69k| (yyval.modifier).xor_min = 0; 2569| 4.69k| (yyval.modifier).xor_max = 0; 2570| 4.69k| (yyval.modifier).alphabet = NULL; 2571| 4.69k| } 2572| 4.69k|#line 2573 "libyara/grammar.c" 2573| 4.69k| break; 2574| | 2575| 6.29k| case 43: /* string_modifiers: string_modifiers string_modifier */ ------------------ | Branch (2575:3): [True: 6.29k, False: 627k] ------------------ 2576| 6.29k|#line 714 "libyara/grammar.y" 2577| 6.29k| { 2578| 6.29k| (yyval.modifier) = (yyvsp[-1].modifier); 2579| | 2580| | // Only set the xor minimum and maximum if we are dealing with the 2581| | // xor modifier. If we don't check for this then we can end up with 2582| | // "xor wide" resulting in whatever is on the stack for "wide" 2583| | // overwriting the values for xor. 2584| 6.29k| if ((yyvsp[0].modifier).flags & STRING_FLAGS_XOR) ------------------ | | 85| 6.29k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (2584:13): [True: 1.51k, False: 4.77k] ------------------ 2585| 1.51k| { 2586| 1.51k| (yyval.modifier).xor_min = (yyvsp[0].modifier).xor_min; 2587| 1.51k| (yyval.modifier).xor_max = (yyvsp[0].modifier).xor_max; 2588| 1.51k| } 2589| | 2590| | // Only set the base64 alphabet if we are dealing with the base64 2591| | // modifier. If we don't check for this then we can end up with 2592| | // "base64 ascii" resulting in whatever is on the stack for "ascii" 2593| | // overwriting the values for base64. 2594| 6.29k| if (((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64) || ------------------ | | 87| 6.29k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (2594:13): [True: 1.26k, False: 5.02k] ------------------ 2595| 6.29k| ((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 5.02k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (2595:13): [True: 1.58k, False: 3.44k] ------------------ 2596| 2.85k| { 2597| 2.85k| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2597:15): [True: 868, False: 1.98k] ------------------ 2598| 868| { 2599| 868| if (ss_compare((yyval.modifier).alphabet, (yyvsp[0].modifier).alphabet) != 0) ------------------ | Branch (2599:17): [True: 6, False: 862] ------------------ 2600| 6| { 2601| 6| yr_compiler_set_error_extra_info( ------------------ | | 306| 6| strlcpy( \ | | 307| 6| compiler->last_error_extra_info, \ | | 308| 6| info, \ | | 309| 6| sizeof(compiler->last_error_extra_info)); ------------------ 2602| 6| compiler, "can not specify multiple alphabets"); 2603| | 2604| 6| yr_free((yyvsp[0].modifier).alphabet); 2605| 6| yr_free((yyval.modifier).alphabet); 2606| | 2607| 6| fail_with_error(ERROR_INVALID_MODIFIER); ------------------ | | 120| 6| { \ | | 121| 6| compiler->last_error = e; \ | | 122| 6| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 6|#define yyerror yara_yyerror | | ------------------ | | 123| 6| switch (e) \ | | 124| 6| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 6] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 6| default: \ | | ------------------ | | | Branch (127:7): [True: 6, False: 0] | | ------------------ | | 128| 6| YYERROR; \ | | ------------------ | | | | 1313| 6|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 6| } \ | | 130| 6| } ------------------ 2608| 0| } 2609| 862| else 2610| 862| { 2611| 862| yr_free((yyvsp[0].modifier).alphabet); 2612| 862| } 2613| 868| } 2614| 1.98k| else 2615| 1.98k| { 2616| 1.98k| (yyval.modifier).alphabet = (yyvsp[0].modifier).alphabet; 2617| 1.98k| } 2618| 2.85k| } 2619| | 2620| 6.29k| if ((yyval.modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2620:13): [True: 8, False: 6.28k] ------------------ 2621| 8| { 2622| 8| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2622:15): [True: 4, False: 4] ------------------ 2623| 4| yr_free((yyval.modifier).alphabet); 2624| | 2625| 8| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 8| { \ | | 121| 8| compiler->last_error = e; \ | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 8|#define yyerror yara_yyerror | | ------------------ | | 123| 8| switch (e) \ | | 124| 8| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 8] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 8| default: \ | | ------------------ | | | Branch (127:7): [True: 8, False: 0] | | ------------------ | | 128| 8| YYERROR; \ | | ------------------ | | | | 1313| 8|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 8| } \ | | 130| 8| } ------------------ 2626| 0| } 2627| 6.28k| else 2628| 6.28k| { 2629| 6.28k| (yyval.modifier).flags = (yyval.modifier).flags | (yyvsp[0].modifier).flags; 2630| 6.28k| } 2631| 6.29k| } 2632| 6.28k|#line 2633 "libyara/grammar.c" 2633| 6.28k| break; 2634| | 2635| 6.28k| case 44: /* string_modifier: "" */ ------------------ | Branch (2635:3): [True: 962, False: 633k] ------------------ 2636| 962|#line 773 "libyara/grammar.y" 2637| 962| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 962|#define STRING_FLAGS_WIDE 0x10 ------------------ 2638| 962|#line 2639 "libyara/grammar.c" 2639| 962| break; 2640| | 2641| 491| case 45: /* string_modifier: "" */ ------------------ | Branch (2641:3): [True: 491, False: 633k] ------------------ 2642| 491|#line 774 "libyara/grammar.y" 2643| 491| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 491|#define STRING_FLAGS_ASCII 0x08 ------------------ 2644| 491|#line 2645 "libyara/grammar.c" 2645| 491| break; 2646| | 2647| 208| case 46: /* string_modifier: "" */ ------------------ | Branch (2647:3): [True: 208, False: 633k] ------------------ 2648| 208|#line 775 "libyara/grammar.y" 2649| 208| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 208|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2650| 208|#line 2651 "libyara/grammar.c" 2651| 208| break; 2652| | 2653| 217| case 47: /* string_modifier: "" */ ------------------ | Branch (2653:3): [True: 217, False: 633k] ------------------ 2654| 217|#line 776 "libyara/grammar.y" 2655| 217| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 217|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2656| 217|#line 2657 "libyara/grammar.c" 2657| 217| break; 2658| | 2659| 48| case 48: /* string_modifier: "" */ ------------------ | Branch (2659:3): [True: 48, False: 634k] ------------------ 2660| 48|#line 777 "libyara/grammar.y" 2661| 48| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 48|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2662| 48|#line 2663 "libyara/grammar.c" 2663| 48| break; 2664| | 2665| 394| case 49: /* string_modifier: "" */ ------------------ | Branch (2665:3): [True: 394, False: 633k] ------------------ 2666| 394|#line 779 "libyara/grammar.y" 2667| 394| { 2668| 394| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 394|#define STRING_FLAGS_XOR 0x80000 ------------------ 2669| 394| (yyval.modifier).xor_min = 0; 2670| 394| (yyval.modifier).xor_max = 255; 2671| 394| } 2672| 394|#line 2673 "libyara/grammar.c" 2673| 394| break; 2674| | 2675| 313| case 50: /* string_modifier: "" '(' "integer number" ')' */ ------------------ | Branch (2675:3): [True: 313, False: 633k] ------------------ 2676| 313|#line 785 "libyara/grammar.y" 2677| 313| { 2678| 313| int result = ERROR_SUCCESS; ------------------ | | 40| 313|#define ERROR_SUCCESS 0 ------------------ 2679| | 2680| 313| if ((yyvsp[-1].integer) < 0 || (yyvsp[-1].integer) > 255) ------------------ | Branch (2680:13): [True: 0, False: 313] | Branch (2680:40): [True: 7, False: 306] ------------------ 2681| 7| { 2682| 7| yr_compiler_set_error_extra_info(compiler, "invalid xor range"); ------------------ | | 306| 7| strlcpy( \ | | 307| 7| compiler->last_error_extra_info, \ | | 308| 7| info, \ | | 309| 7| sizeof(compiler->last_error_extra_info)); ------------------ 2683| 7| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 7|#define ERROR_INVALID_MODIFIER 59 ------------------ 2684| 7| } 2685| | 2686| 313| fail_if_error(result); ------------------ | | 135| 313| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 626|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 320|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 7, False: 306] | | | Branch (135:31): [True: 7, False: 0] | | ------------------ | | 136| 313| { \ | | 137| 7| fail_with_error(e); \ | | ------------------ | | | | 120| 7| { \ | | | | 121| 7| compiler->last_error = e; \ | | | | 122| 7| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 7|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 7| switch (e) \ | | | | 124| 7| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 7] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 7| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 7, False: 0] | | | | ------------------ | | | | 128| 7| YYERROR; \ | | | | ------------------ | | | | | | 1313| 7|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 7| } \ | | | | 130| 7| } | | ------------------ | | 138| 0| } ------------------ 2687| | 2688| 306| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 306|#define STRING_FLAGS_XOR 0x80000 ------------------ 2689| 306| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-1].integer); 2690| 306| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2691| 306| } 2692| 0|#line 2693 "libyara/grammar.c" 2693| 0| break; 2694| | 2695| 818| case 51: /* string_modifier: "" '(' "integer number" '-' "integer number" ')' */ ------------------ | Branch (2695:3): [True: 818, False: 633k] ------------------ 2696| 818|#line 806 "libyara/grammar.y" 2697| 818| { 2698| 818| int result = ERROR_SUCCESS; ------------------ | | 40| 818|#define ERROR_SUCCESS 0 ------------------ 2699| | 2700| 818| if ((yyvsp[-3].integer) < 0) ------------------ | Branch (2700:13): [True: 0, False: 818] ------------------ 2701| 0| { 2702| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2703| 0| compiler, "lower bound for xor range exceeded (min: 0)"); 2704| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2705| 0| } 2706| | 2707| 818| if ((yyvsp[-1].integer) > 255) ------------------ | Branch (2707:13): [True: 0, False: 818] ------------------ 2708| 0| { 2709| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2710| 0| compiler, "upper bound for xor range exceeded (max: 255)"); 2711| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2712| 0| } 2713| | 2714| 818| if ((yyvsp[-3].integer) > (yyvsp[-1].integer)) ------------------ | Branch (2714:13): [True: 0, False: 818] ------------------ 2715| 0| { 2716| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2717| 0| compiler, "xor lower bound exceeds upper bound"); 2718| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2719| 0| } 2720| | 2721| 818| fail_if_error(result); ------------------ | | 135| 818| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.63k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 818|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 818] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 818| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2722| | 2723| 818| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 818|#define STRING_FLAGS_XOR 0x80000 ------------------ 2724| 818| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-3].integer); 2725| 818| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2726| 818| } 2727| 0|#line 2728 "libyara/grammar.c" 2728| 0| break; 2729| | 2730| 1.20k| case 52: /* string_modifier: "" */ ------------------ | Branch (2730:3): [True: 1.20k, False: 633k] ------------------ 2731| 1.20k|#line 837 "libyara/grammar.y" 2732| 1.20k| { 2733| 1.20k| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 1.20k|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2734| 1.20k| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 1.20k| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2735| 1.20k| } 2736| 1.20k|#line 2737 "libyara/grammar.c" 2737| 1.20k| break; 2738| | 2739| 69| case 53: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2739:3): [True: 69, False: 634k] ------------------ 2740| 69|#line 842 "libyara/grammar.y" 2741| 69| { 2742| 69| int result = ERROR_SUCCESS; ------------------ | | 40| 69|#define ERROR_SUCCESS 0 ------------------ 2743| | 2744| 69| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2744:13): [True: 5, False: 64] ------------------ 2745| 5| { 2746| 5| yr_free((yyvsp[-1].sized_string)); 2747| 5| yr_compiler_set_error_extra_info( ------------------ | | 306| 5| strlcpy( \ | | 307| 5| compiler->last_error_extra_info, \ | | 308| 5| info, \ | | 309| 5| sizeof(compiler->last_error_extra_info)); ------------------ 2748| 5| compiler, "length of base64 alphabet must be 64"); 2749| 5| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 5|#define ERROR_INVALID_MODIFIER 59 ------------------ 2750| 5| } 2751| | 2752| 69| fail_if_error(result); ------------------ | | 135| 69| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 138|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 74|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 5, False: 64] | | | Branch (135:31): [True: 5, False: 0] | | ------------------ | | 136| 69| { \ | | 137| 5| fail_with_error(e); \ | | ------------------ | | | | 120| 5| { \ | | | | 121| 5| compiler->last_error = e; \ | | | | 122| 5| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 5|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 5| switch (e) \ | | | | 124| 5| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 5] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 5| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 5, False: 0] | | | | ------------------ | | | | 128| 5| YYERROR; \ | | | | ------------------ | | | | | | 1313| 5|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 5| } \ | | | | 130| 5| } | | ------------------ | | 138| 0| } ------------------ 2753| | 2754| 64| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 64|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2755| 64| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2756| 64| } 2757| 0|#line 2758 "libyara/grammar.c" 2758| 0| break; 2759| | 2760| 1.46k| case 54: /* string_modifier: "" */ ------------------ | Branch (2760:3): [True: 1.46k, False: 632k] ------------------ 2761| 1.46k|#line 859 "libyara/grammar.y" 2762| 1.46k| { 2763| 1.46k| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 1.46k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2764| 1.46k| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 1.46k| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2765| 1.46k| } 2766| 1.46k|#line 2767 "libyara/grammar.c" 2767| 1.46k| break; 2768| | 2769| 134| case 55: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2769:3): [True: 134, False: 634k] ------------------ 2770| 134|#line 864 "libyara/grammar.y" 2771| 134| { 2772| 134| int result = ERROR_SUCCESS; ------------------ | | 40| 134|#define ERROR_SUCCESS 0 ------------------ 2773| | 2774| 134| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2774:13): [True: 13, False: 121] ------------------ 2775| 13| { 2776| 13| yr_free((yyvsp[-1].sized_string)); 2777| 13| yr_compiler_set_error_extra_info( ------------------ | | 306| 13| strlcpy( \ | | 307| 13| compiler->last_error_extra_info, \ | | 308| 13| info, \ | | 309| 13| sizeof(compiler->last_error_extra_info)); ------------------ 2778| 13| compiler, "length of base64 alphabet must be 64"); 2779| 13| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 13|#define ERROR_INVALID_MODIFIER 59 ------------------ 2780| 13| } 2781| | 2782| 134| fail_if_error(result); ------------------ | | 135| 134| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 268|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 147|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 13, False: 121] | | | Branch (135:31): [True: 13, False: 0] | | ------------------ | | 136| 134| { \ | | 137| 13| fail_with_error(e); \ | | ------------------ | | | | 120| 13| { \ | | | | 121| 13| compiler->last_error = e; \ | | | | 122| 13| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 13|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 13| switch (e) \ | | | | 124| 13| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 13] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 13| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 13, False: 0] | | | | ------------------ | | | | 128| 13| YYERROR; \ | | | | ------------------ | | | | | | 1313| 13|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 13| } \ | | | | 130| 13| } | | ------------------ | | 138| 0| } ------------------ 2783| | 2784| 121| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 121|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2785| 121| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2786| 121| } 2787| 0|#line 2788 "libyara/grammar.c" 2788| 0| break; 2789| | 2790| 12.2k| case 56: /* regexp_modifiers: %empty */ ------------------ | Branch (2790:3): [True: 12.2k, False: 621k] ------------------ 2791| 12.2k|#line 883 "libyara/grammar.y" 2792| 12.2k| { (yyval.modifier).flags = 0; } 2793| 12.2k|#line 2794 "libyara/grammar.c" 2794| 12.2k| break; 2795| | 2796| 1.29k| case 57: /* regexp_modifiers: regexp_modifiers regexp_modifier */ ------------------ | Branch (2796:3): [True: 1.29k, False: 632k] ------------------ 2797| 1.29k|#line 885 "libyara/grammar.y" 2798| 1.29k| { 2799| 1.29k| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2799:13): [True: 0, False: 1.29k] ------------------ 2800| 0| { 2801| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2802| 0| } 2803| 1.29k| else 2804| 1.29k| { 2805| 1.29k| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2806| 1.29k| } 2807| 1.29k| } 2808| 1.29k|#line 2809 "libyara/grammar.c" 2809| 1.29k| break; 2810| | 2811| 1.29k| case 58: /* regexp_modifier: "" */ ------------------ | Branch (2811:3): [True: 432, False: 633k] ------------------ 2812| 432|#line 898 "libyara/grammar.y" 2813| 432| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 432|#define STRING_FLAGS_WIDE 0x10 ------------------ 2814| 432|#line 2815 "libyara/grammar.c" 2815| 432| break; 2816| | 2817| 456| case 59: /* regexp_modifier: "" */ ------------------ | Branch (2817:3): [True: 456, False: 633k] ------------------ 2818| 456|#line 899 "libyara/grammar.y" 2819| 456| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 456|#define STRING_FLAGS_ASCII 0x08 ------------------ 2820| 456|#line 2821 "libyara/grammar.c" 2821| 456| break; 2822| | 2823| 184| case 60: /* regexp_modifier: "" */ ------------------ | Branch (2823:3): [True: 184, False: 634k] ------------------ 2824| 184|#line 900 "libyara/grammar.y" 2825| 184| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 184|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2826| 184|#line 2827 "libyara/grammar.c" 2827| 184| break; 2828| | 2829| 53| case 61: /* regexp_modifier: "" */ ------------------ | Branch (2829:3): [True: 53, False: 634k] ------------------ 2830| 53|#line 901 "libyara/grammar.y" 2831| 53| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 53|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2832| 53|#line 2833 "libyara/grammar.c" 2833| 53| break; 2834| | 2835| 167| case 62: /* regexp_modifier: "" */ ------------------ | Branch (2835:3): [True: 167, False: 634k] ------------------ 2836| 167|#line 902 "libyara/grammar.y" 2837| 167| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 167|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2838| 167|#line 2839 "libyara/grammar.c" 2839| 167| break; 2840| | 2841| 1.27k| case 63: /* hex_modifiers: %empty */ ------------------ | Branch (2841:3): [True: 1.27k, False: 632k] ------------------ 2842| 1.27k|#line 906 "libyara/grammar.y" 2843| 1.27k| { (yyval.modifier).flags = 0; } 2844| 1.27k|#line 2845 "libyara/grammar.c" 2845| 1.27k| break; 2846| | 2847| 184| case 64: /* hex_modifiers: hex_modifiers hex_modifier */ ------------------ | Branch (2847:3): [True: 184, False: 634k] ------------------ 2848| 184|#line 908 "libyara/grammar.y" 2849| 184| { 2850| 184| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2850:13): [True: 0, False: 184] ------------------ 2851| 0| { 2852| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2853| 0| } 2854| 184| else 2855| 184| { 2856| 184| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2857| 184| } 2858| 184| } 2859| 184|#line 2860 "libyara/grammar.c" 2860| 184| break; 2861| | 2862| 184| case 65: /* hex_modifier: "" */ ------------------ | Branch (2862:3): [True: 184, False: 634k] ------------------ 2863| 184|#line 921 "libyara/grammar.y" 2864| 184| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 184|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2865| 184|#line 2866 "libyara/grammar.c" 2866| 184| break; 2867| | 2868| 15.6k| case 66: /* identifier: "identifier" */ ------------------ | Branch (2868:3): [True: 15.6k, False: 618k] ------------------ 2869| 15.6k|#line 926 "libyara/grammar.y" 2870| 15.6k| { 2871| 15.6k| YR_EXPRESSION expr; 2872| | 2873| 15.6k| int result = ERROR_SUCCESS; ------------------ | | 40| 15.6k|#define ERROR_SUCCESS 0 ------------------ 2874| 15.6k| int var_index = yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), &expr); 2875| | 2876| 15.6k| if (var_index >= 0) ------------------ | Branch (2876:13): [True: 8.00k, False: 7.66k] ------------------ 2877| 8.00k| { 2878| | // The identifier corresponds to a loop variable. 2879| 8.00k| result = yr_parser_emit_with_arg( 2880| 8.00k| yyscanner, 2881| 8.00k| OP_PUSH_M, ------------------ | | 82| 8.00k|#define OP_PUSH_M 34 ------------------ 2882| 8.00k| var_index, 2883| 8.00k| NULL, 2884| 8.00k| NULL); 2885| | 2886| | // The expression associated to this identifier is the same one 2887| | // associated to the loop variable. 2888| 8.00k| (yyval.expression) = expr; 2889| 8.00k| } 2890| 7.66k| else 2891| 7.66k| { 2892| | // Search for identifier within the global namespace, where the 2893| | // externals variables reside. 2894| | 2895| 7.66k| YR_OBJECT* object = (YR_OBJECT*) yr_hash_table_lookup( 2896| 7.66k| compiler->objects_table, (yyvsp[0].c_string), NULL); 2897| | 2898| 7.66k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 2899| 7.66k| compiler->arena, 2900| 7.66k| YR_NAMESPACES_TABLE, ------------------ | | 57| 7.66k|#define YR_NAMESPACES_TABLE 0 ------------------ 2901| 7.66k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 2902| | 2903| 7.66k| if (object == NULL) ------------------ | Branch (2903:15): [True: 7.66k, False: 0] ------------------ 2904| 7.66k| { 2905| | // If not found, search within the current namespace. 2906| 7.66k| object = (YR_OBJECT*) yr_hash_table_lookup( 2907| 7.66k| compiler->objects_table, (yyvsp[0].c_string), ns->name); 2908| 7.66k| } 2909| | 2910| 7.66k| if (object != NULL) ------------------ | Branch (2910:15): [True: 727, False: 6.93k] ------------------ 2911| 727| { 2912| 727| YR_ARENA_REF ref; 2913| | 2914| 727| result = _yr_compiler_store_string( 2915| 727| compiler, (yyvsp[0].c_string), &ref); 2916| | 2917| 727| if (result == ERROR_SUCCESS) ------------------ | | 40| 727|#define ERROR_SUCCESS 0 ------------------ | Branch (2917:17): [True: 727, False: 0] ------------------ 2918| 727| result = yr_parser_emit_with_arg_reloc( 2919| 727| yyscanner, 2920| 727| OP_OBJ_LOAD, ------------------ | | 64| 727|#define OP_OBJ_LOAD 16 ------------------ 2921| 727| yr_arena_ref_to_ptr(compiler->arena, &ref), 2922| 727| NULL, 2923| 727| NULL); 2924| | 2925| 727| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 727|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 2926| 727| (yyval.expression).value.object = object; 2927| 727| (yyval.expression).identifier.ptr = NULL; 2928| 727| (yyval.expression).identifier.ref = ref; 2929| 727| } 2930| 6.93k| else 2931| 6.93k| { 2932| 6.93k| uint32_t rule_idx = yr_hash_table_lookup_uint32( 2933| 6.93k| compiler->rules_table, (yyvsp[0].c_string), ns->name); 2934| | 2935| 6.93k| if (rule_idx != UINT32_MAX) ------------------ | Branch (2935:17): [True: 6.64k, False: 290] ------------------ 2936| 6.64k| { 2937| 6.64k| result = yr_parser_emit_with_arg( 2938| 6.64k| yyscanner, 2939| 6.64k| OP_PUSH_RULE, ------------------ | | 75| 6.64k|#define OP_PUSH_RULE 27 ------------------ 2940| 6.64k| rule_idx, 2941| 6.64k| NULL, 2942| 6.64k| NULL); 2943| | 2944| 6.64k| YR_RULE* rule = _yr_compiler_get_rule_by_idx(compiler, rule_idx); 2945| | 2946| 6.64k| yr_arena_ptr_to_ref(compiler->arena, rule->identifier, &(yyval.expression).identifier.ref); 2947| | 2948| 6.64k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 6.64k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 2949| 6.64k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 6.64k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 2950| 6.64k| (yyval.expression).identifier.ptr = NULL; 2951| 6.64k| (yyval.expression).required_strings.count = 0; 2952| 6.64k| } 2953| 290| else 2954| 290| { 2955| 290| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 306| 290| strlcpy( \ | | 307| 290| compiler->last_error_extra_info, \ | | 308| 290| info, \ | | 309| 290| sizeof(compiler->last_error_extra_info)); ------------------ 2956| 290| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 290|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 2957| 290| } 2958| 6.93k| } 2959| 7.66k| } 2960| | 2961| 15.6k| yr_free((yyvsp[0].c_string)); 2962| | 2963| 15.6k| fail_if_error(result); ------------------ | | 135| 15.6k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 31.3k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 15.9k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 290, False: 15.3k] | | | Branch (135:31): [True: 290, False: 0] | | ------------------ | | 136| 15.6k| { \ | | 137| 290| fail_with_error(e); \ | | ------------------ | | | | 120| 290| { \ | | | | 121| 290| compiler->last_error = e; \ | | | | 122| 290| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 290|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 290| switch (e) \ | | | | 124| 290| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 290] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 290| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 290, False: 0] | | | | ------------------ | | | | 128| 290| YYERROR; \ | | | | ------------------ | | | | | | 1313| 290|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 290| } \ | | | | 130| 290| } | | ------------------ | | 138| 0| } ------------------ 2964| 15.3k| } 2965| 0|#line 2966 "libyara/grammar.c" 2966| 0| break; 2967| | 2968| 541| case 67: /* identifier: identifier '.' "identifier" */ ------------------ | Branch (2968:3): [True: 541, False: 633k] ------------------ 2969| 541|#line 1022 "libyara/grammar.y" 2970| 541| { 2971| 541| int result = ERROR_SUCCESS; ------------------ | | 40| 541|#define ERROR_SUCCESS 0 ------------------ 2972| 541| YR_OBJECT* field = NULL; 2973| | 2974| 541| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 1.08k|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (2974:13): [True: 514, False: 27] ------------------ 2975| 541| (yyvsp[-2].expression).value.object->type == OBJECT_TYPE_STRUCTURE) ------------------ | | 60| 514|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (2975:13): [True: 510, False: 4] ------------------ 2976| 510| { 2977| 510| field = yr_object_lookup_field((yyvsp[-2].expression).value.object, (yyvsp[0].c_string)); 2978| | 2979| 510| if (field != NULL) ------------------ | Branch (2979:15): [True: 482, False: 28] ------------------ 2980| 482| { 2981| 482| YR_ARENA_REF ref; 2982| | 2983| 482| result = _yr_compiler_store_string( 2984| 482| compiler, (yyvsp[0].c_string), &ref); 2985| | 2986| 482| if (result == ERROR_SUCCESS) ------------------ | | 40| 482|#define ERROR_SUCCESS 0 ------------------ | Branch (2986:17): [True: 482, False: 0] ------------------ 2987| 482| result = yr_parser_emit_with_arg_reloc( 2988| 482| yyscanner, 2989| 482| OP_OBJ_FIELD, ------------------ | | 66| 482|#define OP_OBJ_FIELD 18 ------------------ 2990| 482| yr_arena_ref_to_ptr(compiler->arena, &ref), 2991| 482| NULL, 2992| 482| NULL); 2993| | 2994| 482| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 482|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 2995| 482| (yyval.expression).value.object = field; 2996| 482| (yyval.expression).identifier.ref = ref; 2997| 482| (yyval.expression).identifier.ptr = NULL; 2998| 482| } 2999| 28| else 3000| 28| { 3001| 28| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 306| 28| strlcpy( \ | | 307| 28| compiler->last_error_extra_info, \ | | 308| 28| info, \ | | 309| 28| sizeof(compiler->last_error_extra_info)); ------------------ 3002| 28| result = ERROR_INVALID_FIELD_NAME; ------------------ | | 80| 28|#define ERROR_INVALID_FIELD_NAME 33 ------------------ 3003| 28| } 3004| 510| } 3005| 31| else 3006| 31| { 3007| 31| yr_compiler_set_error_extra_info( ------------------ | | 306| 31| strlcpy( \ | | 307| 31| compiler->last_error_extra_info, \ | | 308| 62| info, \ | | ------------------ | | | Branch (308:7): [True: 12, False: 19] | | ------------------ | | 309| 31| sizeof(compiler->last_error_extra_info)); ------------------ 3008| 31| compiler, expression_identifier((yyvsp[-2].expression))); 3009| | 3010| 31| result = ERROR_NOT_A_STRUCTURE; ------------------ | | 82| 31|#define ERROR_NOT_A_STRUCTURE 35 ------------------ 3011| 31| } 3012| | 3013| 541| yr_free((yyvsp[0].c_string)); 3014| | 3015| 541| fail_if_error(result); ------------------ | | 135| 541| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.08k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 600|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 59, False: 482] | | | Branch (135:31): [True: 59, False: 0] | | ------------------ | | 136| 541| { \ | | 137| 59| fail_with_error(e); \ | | ------------------ | | | | 120| 59| { \ | | | | 121| 59| compiler->last_error = e; \ | | | | 122| 59| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 59|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 59| switch (e) \ | | | | 124| 59| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 59] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 59| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 59, False: 0] | | | | ------------------ | | | | 128| 59| YYERROR; \ | | | | ------------------ | | | | | | 1313| 59|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 59| } \ | | | | 130| 59| } | | ------------------ | | 138| 0| } ------------------ 3016| 482| } 3017| 0|#line 3018 "libyara/grammar.c" 3018| 0| break; 3019| | 3020| 46| case 68: /* identifier: identifier '[' primary_expression ']' */ ------------------ | Branch (3020:3): [True: 46, False: 634k] ------------------ 3021| 46|#line 1070 "libyara/grammar.y" 3022| 46| { 3023| 46| int result = ERROR_SUCCESS; ------------------ | | 40| 46|#define ERROR_SUCCESS 0 ------------------ 3024| 46| YR_OBJECT_ARRAY* array; 3025| 46| YR_OBJECT_DICTIONARY* dict; 3026| | 3027| 46| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 92|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3027:13): [True: 32, False: 14] ------------------ 3028| 46| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_ARRAY) ------------------ | | 61| 32|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (3028:13): [True: 0, False: 32] ------------------ 3029| 0| { 3030| 0| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3030:15): [True: 0, False: 0] ------------------ 3031| 0| { 3032| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3033| 0| compiler, "array indexes must be of integer type"); 3034| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 3035| 0| } 3036| | 3037| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3038| | 3039| 0| result = yr_parser_emit( 3040| 0| yyscanner, OP_INDEX_ARRAY, NULL); ------------------ | | 67| 0|#define OP_INDEX_ARRAY 19 ------------------ 3041| | 3042| 0| array = object_as_array((yyvsp[-3].expression).value.object); ------------------ | | 910| 0|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 3043| | 3044| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3045| 0| (yyval.expression).value.object = array->prototype_item; 3046| 0| (yyval.expression).identifier.ptr = array->identifier; 3047| 0| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 3048| 0| } 3049| 46| else if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 92|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3049:18): [True: 32, False: 14] ------------------ 3050| 46| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_DICTIONARY) ------------------ | | 63| 32|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (3050:18): [True: 32, False: 0] ------------------ 3051| 32| { 3052| 32| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 32|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3052:15): [True: 13, False: 19] ------------------ 3053| 13| { 3054| 13| yr_compiler_set_error_extra_info( ------------------ | | 306| 13| strlcpy( \ | | 307| 13| compiler->last_error_extra_info, \ | | 308| 13| info, \ | | 309| 13| sizeof(compiler->last_error_extra_info)); ------------------ 3055| 13| compiler, "dictionary keys must be of string type"); 3056| 13| result = ERROR_WRONG_TYPE; ------------------ | | 69| 13|#define ERROR_WRONG_TYPE 24 ------------------ 3057| 13| } 3058| | 3059| 32| fail_if_error(result); ------------------ | | 135| 32| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 64|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 45|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 13, False: 19] | | | Branch (135:31): [True: 13, False: 0] | | ------------------ | | 136| 32| { \ | | 137| 13| fail_with_error(e); \ | | ------------------ | | | | 120| 13| { \ | | | | 121| 13| compiler->last_error = e; \ | | | | 122| 13| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 13|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 13| switch (e) \ | | | | 124| 13| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 13] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 13| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 13, False: 0] | | | | ------------------ | | | | 128| 13| YYERROR; \ | | | | ------------------ | | | | | | 1313| 13|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 13| } \ | | | | 130| 13| } | | ------------------ | | 138| 0| } ------------------ 3060| | 3061| 19| result = yr_parser_emit( 3062| 19| yyscanner, OP_LOOKUP_DICT, NULL); ------------------ | | 90| 19|#define OP_LOOKUP_DICT 42 ------------------ 3063| | 3064| 19| dict = object_as_dictionary((yyvsp[-3].expression).value.object); ------------------ | | 911| 19|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 3065| | 3066| 19| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 19|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3067| 19| (yyval.expression).value.object = dict->prototype_item; 3068| 19| (yyval.expression).identifier.ptr = dict->identifier; 3069| 19| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 19| (YR_ARENA_REF) \ | | 44| 19| { \ | | 45| 19| UINT32_MAX, UINT32_MAX \ | | 46| 19| } ------------------ 3070| 19| } 3071| 14| else 3072| 14| { 3073| 14| yr_compiler_set_error_extra_info( ------------------ | | 306| 14| strlcpy( \ | | 307| 14| compiler->last_error_extra_info, \ | | 308| 28| info, \ | | ------------------ | | | Branch (308:7): [True: 14, False: 0] | | ------------------ | | 309| 14| sizeof(compiler->last_error_extra_info)); ------------------ 3074| 14| compiler, expression_identifier((yyvsp[-3].expression))); 3075| | 3076| 14| result = ERROR_NOT_INDEXABLE; ------------------ | | 83| 14|#define ERROR_NOT_INDEXABLE 36 ------------------ 3077| 14| } 3078| | 3079| 33| fail_if_error(result); ------------------ | | 135| 33| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 66|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 47|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 14, False: 19] | | | Branch (135:31): [True: 14, False: 0] | | ------------------ | | 136| 33| { \ | | 137| 14| fail_with_error(e); \ | | ------------------ | | | | 120| 14| { \ | | | | 121| 14| compiler->last_error = e; \ | | | | 122| 14| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 14|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 14| switch (e) \ | | | | 124| 14| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 14] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 14| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 14, False: 0] | | | | ------------------ | | | | 128| 14| YYERROR; \ | | | | ------------------ | | | | | | 1313| 14|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 14| } \ | | | | 130| 14| } | | ------------------ | | 138| 0| } ------------------ 3080| 19| } 3081| 0|#line 3082 "libyara/grammar.c" 3082| 0| break; 3083| | 3084| 32| case 69: /* identifier: identifier '(' arguments ')' */ ------------------ | Branch (3084:3): [True: 32, False: 634k] ------------------ 3085| 32|#line 1131 "libyara/grammar.y" 3086| 32| { 3087| 32| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 32| (YR_ARENA_REF) \ | | 44| 32| { \ | | 45| 32| UINT32_MAX, UINT32_MAX \ | | 46| 32| } ------------------ 3088| 32| int result = ERROR_SUCCESS; ------------------ | | 40| 32|#define ERROR_SUCCESS 0 ------------------ 3089| | 3090| 32| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 64|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3090:13): [True: 20, False: 12] ------------------ 3091| 32| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_FUNCTION) ------------------ | | 62| 20|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (3091:13): [True: 11, False: 9] ------------------ 3092| 11| { 3093| 11| YR_OBJECT_FUNCTION* function = object_as_function((yyvsp[-3].expression).value.object); ------------------ | | 912| 11|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 3094| | 3095| 11| result = yr_parser_check_types(compiler, function, (yyvsp[-1].c_string)); 3096| | 3097| 11| if (result == ERROR_SUCCESS) ------------------ | | 40| 11|#define ERROR_SUCCESS 0 ------------------ | Branch (3097:15): [True: 6, False: 5] ------------------ 3098| 6| result = _yr_compiler_store_string( 3099| 6| compiler, (yyvsp[-1].c_string), &ref); 3100| | 3101| 11| if (result == ERROR_SUCCESS) ------------------ | | 40| 11|#define ERROR_SUCCESS 0 ------------------ | Branch (3101:15): [True: 6, False: 5] ------------------ 3102| 6| result = yr_parser_emit_with_arg_reloc( 3103| 6| yyscanner, 3104| 6| OP_CALL, ------------------ | | 63| 6|#define OP_CALL 15 ------------------ 3105| 6| yr_arena_ref_to_ptr(compiler->arena, &ref), 3106| 6| NULL, 3107| 6| NULL); 3108| | 3109| 11| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 11|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3110| 11| (yyval.expression).value.object = function->return_obj; 3111| 11| (yyval.expression).identifier.ref = ref; 3112| 11| (yyval.expression).identifier.ptr = NULL; 3113| 11| } 3114| 21| else 3115| 21| { 3116| 21| yr_compiler_set_error_extra_info( ------------------ | | 306| 21| strlcpy( \ | | 307| 21| compiler->last_error_extra_info, \ | | 308| 42| info, \ | | ------------------ | | | Branch (308:7): [True: 12, False: 9] | | ------------------ | | 309| 21| sizeof(compiler->last_error_extra_info)); ------------------ 3117| 21| compiler, expression_identifier((yyvsp[-3].expression))); 3118| | 3119| 21| result = ERROR_NOT_A_FUNCTION; ------------------ | | 84| 21|#define ERROR_NOT_A_FUNCTION 37 ------------------ 3120| 21| } 3121| | 3122| 32| yr_free((yyvsp[-1].c_string)); 3123| | 3124| 32| fail_if_error(result); ------------------ | | 135| 32| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 64|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 58|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 26, False: 6] | | | Branch (135:31): [True: 26, False: 0] | | ------------------ | | 136| 32| { \ | | 137| 26| fail_with_error(e); \ | | ------------------ | | | | 120| 26| { \ | | | | 121| 26| compiler->last_error = e; \ | | | | 122| 26| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 26|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 26| switch (e) \ | | | | 124| 26| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 26] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 26| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 26, False: 0] | | | | ------------------ | | | | 128| 26| YYERROR; \ | | | | ------------------ | | | | | | 1313| 26|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 26| } \ | | | | 130| 26| } | | ------------------ | | 138| 0| } ------------------ 3125| 6| } 3126| 0|#line 3127 "libyara/grammar.c" 3127| 0| break; 3128| | 3129| 21| case 70: /* arguments: %empty */ ------------------ | Branch (3129:3): [True: 21, False: 634k] ------------------ 3130| 21|#line 1175 "libyara/grammar.y" 3131| 21| { (yyval.c_string) = yr_strdup(""); } 3132| 21|#line 3133 "libyara/grammar.c" 3133| 21| break; 3134| | 3135| 125| case 71: /* arguments: arguments_list */ ------------------ | Branch (3135:3): [True: 125, False: 634k] ------------------ 3136| 125|#line 1176 "libyara/grammar.y" 3137| 125| { (yyval.c_string) = (yyvsp[0].c_string); } 3138| 125|#line 3139 "libyara/grammar.c" 3139| 125| break; 3140| | 3141| 2.30k| case 72: /* arguments_list: expression */ ------------------ | Branch (3141:3): [True: 2.30k, False: 631k] ------------------ 3142| 2.30k|#line 1181 "libyara/grammar.y" 3143| 2.30k| { 3144| 2.30k| (yyval.c_string) = (char*) yr_malloc(YR_MAX_FUNCTION_ARGS + 1); ------------------ | | 130| 2.30k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3145| | 3146| 2.30k| if ((yyval.c_string) == NULL) ------------------ | Branch (3146:13): [True: 0, False: 2.30k] ------------------ 3147| 2.30k| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3148| | 3149| 2.30k| switch((yyvsp[0].expression).type) 3150| 2.30k| { 3151| 273| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 273|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3151:11): [True: 273, False: 2.02k] ------------------ 3152| 273| strlcpy((yyval.c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 273|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3153| 273| break; 3154| 558| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 558|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3154:11): [True: 558, False: 1.74k] ------------------ 3155| 558| strlcpy((yyval.c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 558|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3156| 558| break; 3157| 874| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 874|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3157:11): [True: 874, False: 1.42k] ------------------ 3158| 874| strlcpy((yyval.c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 874|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3159| 874| break; 3160| 420| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 420|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3160:11): [True: 420, False: 1.88k] ------------------ 3161| 420| strlcpy((yyval.c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 420|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3162| 420| break; 3163| 160| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 160|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3163:11): [True: 160, False: 2.14k] ------------------ 3164| 160| strlcpy((yyval.c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 160|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3165| 160| break; 3166| 17| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 17|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3166:11): [True: 17, False: 2.28k] ------------------ 3167| 17| yr_free((yyval.c_string)); 3168| 17| yr_compiler_set_error_extra_info( ------------------ | | 306| 17| strlcpy( \ | | 307| 17| compiler->last_error_extra_info, \ | | 308| 17| info, \ | | 309| 17| sizeof(compiler->last_error_extra_info)); ------------------ 3169| 17| compiler, "unknown type for argument 1 in function call"); 3170| 17| fail_with_error(ERROR_WRONG_TYPE); ------------------ | | 120| 17| { \ | | 121| 17| compiler->last_error = e; \ | | 122| 17| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 17|#define yyerror yara_yyerror | | ------------------ | | 123| 17| switch (e) \ | | 124| 17| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 17] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 17| default: \ | | ------------------ | | | Branch (127:7): [True: 17, False: 0] | | ------------------ | | 128| 17| YYERROR; \ | | ------------------ | | | | 1313| 17|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 17| } \ | | 130| 17| } ------------------ 3171| 0| break; 3172| 0| default: ------------------ | Branch (3172:11): [True: 0, False: 2.30k] ------------------ 3173| | // An unknown expression type is OK iff an error ocurred. 3174| 0| assert(compiler->last_error != ERROR_SUCCESS); 3175| 2.30k| } 3176| 2.30k| } 3177| 2.28k|#line 3178 "libyara/grammar.c" 3178| 2.28k| break; 3179| | 3180| 19.7k| case 73: /* arguments_list: arguments_list ',' expression */ ------------------ | Branch (3180:3): [True: 19.7k, False: 614k] ------------------ 3181| 19.7k|#line 1216 "libyara/grammar.y" 3182| 19.7k| { 3183| 19.7k| int result = ERROR_SUCCESS; ------------------ | | 40| 19.7k|#define ERROR_SUCCESS 0 ------------------ 3184| | 3185| 19.7k| if (strlen((yyvsp[-2].c_string)) == YR_MAX_FUNCTION_ARGS) ------------------ | | 130| 19.7k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ | Branch (3185:13): [True: 0, False: 19.7k] ------------------ 3186| 0| { 3187| 0| result = ERROR_TOO_MANY_ARGUMENTS; ------------------ | | 86| 0|#define ERROR_TOO_MANY_ARGUMENTS 39 ------------------ 3188| 0| } 3189| 19.7k| else 3190| 19.7k| { 3191| 19.7k| switch((yyvsp[0].expression).type) 3192| 19.7k| { 3193| 2.06k| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 2.06k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3193:13): [True: 2.06k, False: 17.7k] ------------------ 3194| 2.06k| strlcat((yyvsp[-2].c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 2.06k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3195| 2.06k| break; 3196| 1.36k| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 1.36k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3196:13): [True: 1.36k, False: 18.4k] ------------------ 3197| 1.36k| strlcat((yyvsp[-2].c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 1.36k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3198| 1.36k| break; 3199| 11.6k| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 11.6k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3199:13): [True: 11.6k, False: 8.11k] ------------------ 3200| 11.6k| strlcat((yyvsp[-2].c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 11.6k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3201| 11.6k| break; 3202| 3.50k| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 3.50k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3202:13): [True: 3.50k, False: 16.2k] ------------------ 3203| 3.50k| strlcat((yyvsp[-2].c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 3.50k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3204| 3.50k| break; 3205| 1.17k| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 1.17k|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3205:13): [True: 1.17k, False: 18.6k] ------------------ 3206| 1.17k| strlcat((yyvsp[-2].c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 1.17k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3207| 1.17k| break; 3208| 4| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 4|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3208:13): [True: 4, False: 19.7k] ------------------ 3209| 4| result = ERROR_WRONG_TYPE; ------------------ | | 69| 4|#define ERROR_WRONG_TYPE 24 ------------------ 3210| 4| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 4| snprintf( \ | | 313| 4| compiler->last_error_extra_info, \ | | 314| 4| sizeof(compiler->last_error_extra_info), \ | | 315| 4| fmt, \ | | 316| 4| __VA_ARGS__); ------------------ 3211| 4| compiler, "unknown type for argument %zu in function call", 3212| | // As we add one character per argument, the length of $1 is 3213| | // the number of arguments parsed so far, and the argument 3214| | // represented by is length of $1 plus one. 3215| 4| strlen((yyvsp[-2].c_string)) + 1); 3216| 4| break; 3217| 0| default: ------------------ | Branch (3217:13): [True: 0, False: 19.7k] ------------------ 3218| | // An unknown expression type is OK iff an error ocurred. 3219| 0| assert(compiler->last_error != ERROR_SUCCESS); 3220| 19.7k| } 3221| 19.7k| } 3222| | 3223| 19.7k| if (result != ERROR_SUCCESS) ------------------ | | 40| 19.7k|#define ERROR_SUCCESS 0 ------------------ | Branch (3223:13): [True: 4, False: 19.7k] ------------------ 3224| 4| yr_free((yyvsp[-2].c_string)); 3225| | 3226| 19.7k| fail_if_error(result); ------------------ | | 135| 19.7k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 39.5k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 19.7k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 4, False: 19.7k] | | | Branch (135:31): [True: 4, False: 0] | | ------------------ | | 136| 19.7k| { \ | | 137| 4| fail_with_error(e); \ | | ------------------ | | | | 120| 4| { \ | | | | 121| 4| compiler->last_error = e; \ | | | | 122| 4| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 4|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 4| switch (e) \ | | | | 124| 4| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 4] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 4| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 4, False: 0] | | | | ------------------ | | | | 128| 4| YYERROR; \ | | | | ------------------ | | | | | | 1313| 4|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 4| } \ | | | | 130| 4| } | | ------------------ | | 138| 0| } ------------------ 3227| | 3228| 19.7k| (yyval.c_string) = (yyvsp[-2].c_string); 3229| 19.7k| } 3230| 0|#line 3231 "libyara/grammar.c" 3231| 0| break; 3232| | 3233| 1.76k| case 74: /* regexp: "regular expression" */ ------------------ | Branch (3233:3): [True: 1.76k, False: 632k] ------------------ 3234| 1.76k|#line 1269 "libyara/grammar.y" 3235| 1.76k| { 3236| 1.76k| YR_ARENA_REF re_ref; 3237| 1.76k| RE_ERROR error; 3238| | 3239| 1.76k| int result = ERROR_SUCCESS; ------------------ | | 40| 1.76k|#define ERROR_SUCCESS 0 ------------------ 3240| 1.76k| int re_flags = 0; 3241| 1.76k| int parser_flags = RE_PARSER_FLAG_NONE; 3242| | 3243| 1.76k| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_NO_CASE) ------------------ | | 39| 1.76k|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ | Branch (3243:13): [True: 37, False: 1.72k] ------------------ 3244| 37| re_flags |= RE_FLAGS_NO_CASE; ------------------ | | 98| 37|#define RE_FLAGS_NO_CASE 0x20 ------------------ 3245| | 3246| 1.76k| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_DOT_ALL) ------------------ | | 43| 1.76k|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ | Branch (3246:13): [True: 66, False: 1.69k] ------------------ 3247| 66| re_flags |= RE_FLAGS_DOT_ALL; ------------------ | | 100| 66|#define RE_FLAGS_DOT_ALL 0x80 ------------------ 3248| | 3249| 1.76k| if (compiler->strict_escape) ------------------ | Branch (3249:13): [True: 0, False: 1.76k] ------------------ 3250| 0| parser_flags |= RE_PARSER_FLAG_ENABLE_STRICT_ESCAPE_SEQUENCES; 3251| | 3252| 1.76k| result = yr_re_compile( 3253| 1.76k| (yyvsp[0].sized_string)->c_string, 3254| 1.76k| re_flags, 3255| 1.76k| parser_flags, 3256| 1.76k| compiler->arena, 3257| 1.76k| &re_ref, 3258| 1.76k| &error); 3259| | 3260| 1.76k| yr_free((yyvsp[0].sized_string)); 3261| | 3262| 1.76k| if (result == ERROR_INVALID_REGULAR_EXPRESSION) ------------------ | | 54| 1.76k|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ | Branch (3262:13): [True: 182, False: 1.57k] ------------------ 3263| 182| yr_compiler_set_error_extra_info(compiler, error.message); ------------------ | | 306| 182| strlcpy( \ | | 307| 182| compiler->last_error_extra_info, \ | | 308| 182| info, \ | | 309| 182| sizeof(compiler->last_error_extra_info)); ------------------ 3264| | 3265| 1.76k| if (result == ERROR_SUCCESS || result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 40| 3.52k|#define ERROR_SUCCESS 0 ------------------ if (result == ERROR_SUCCESS || result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 204|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (3265:13): [True: 1.55k, False: 204] | Branch (3265:40): [True: 0, False: 204] ------------------ 3266| 1.55k| { 3267| 1.55k| if (result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 1.55k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (3267:15): [True: 0, False: 1.55k] ------------------ 3268| 0| { 3269| 0| yywarning( ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3270| 0| yyscanner, 3271| 0| "unknown escape sequence"); 3272| 0| } 3273| 1.55k| result = yr_parser_emit_with_arg_reloc( 3274| 1.55k| yyscanner, 3275| 1.55k| OP_PUSH, ------------------ | | 61| 1.55k|#define OP_PUSH 13 ------------------ 3276| 1.55k| yr_arena_ref_to_ptr(compiler->arena, &re_ref), 3277| 1.55k| NULL, 3278| 1.55k| NULL); 3279| 1.55k| } 3280| | 3281| 1.76k| fail_if_error(result); ------------------ | | 135| 1.76k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.52k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.96k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 204, False: 1.55k] | | | Branch (135:31): [True: 204, False: 0] | | ------------------ | | 136| 1.76k| { \ | | 137| 204| fail_with_error(e); \ | | ------------------ | | | | 120| 204| { \ | | | | 121| 204| compiler->last_error = e; \ | | | | 122| 204| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 204|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 204| switch (e) \ | | | | 124| 204| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 204] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 204| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 204, False: 0] | | | | ------------------ | | | | 128| 204| YYERROR; \ | | | | ------------------ | | | | | | 1313| 204|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 204| } \ | | | | 130| 204| } | | ------------------ | | 138| 0| } ------------------ 3282| | 3283| 1.55k| (yyval.expression).type = EXPRESSION_TYPE_REGEXP; ------------------ | | 49| 1.55k|#define EXPRESSION_TYPE_REGEXP 8 ------------------ 3284| 1.55k| } 3285| 0|#line 3286 "libyara/grammar.c" 3286| 0| break; 3287| | 3288| 22.6k| case 75: /* boolean_expression: expression */ ------------------ | Branch (3288:3): [True: 22.6k, False: 611k] ------------------ 3289| 22.6k|#line 1324 "libyara/grammar.y" 3290| 22.6k| { 3291| 22.6k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 22.6k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3291:13): [True: 267, False: 22.3k] ------------------ 3292| 267| { 3293| 267| if (!YR_ARENA_IS_NULL_REF((yyvsp[0].expression).value.sized_string_ref)) ------------------ | | 49| 267| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 267| (YR_ARENA_REF) \ | | | | 44| 267| { \ | | | | 45| 267| UINT32_MAX, UINT32_MAX \ | | | | 46| 267| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 267| (YR_ARENA_REF) \ | | | | 44| 267| { \ | | | | 45| 267| UINT32_MAX, UINT32_MAX \ | | | | 46| 267| } | | ------------------ ------------------ | Branch (3293:15): [True: 158, False: 109] ------------------ 3294| 158| { 3295| 158| SIZED_STRING* sized_string = yr_arena_ref_to_ptr( 3296| 158| compiler->arena, &(yyvsp[0].expression).value.sized_string_ref); 3297| | 3298| 158| yywarning(yyscanner, ------------------ | | 50| 158|#define yywarning yara_yywarning ------------------ 3299| 158| "using literal string \"%s\" in a boolean operation.", 3300| 158| sized_string->c_string); 3301| 158| } 3302| | 3303| 267| fail_if_error(yr_parser_emit( ------------------ | | 135| 267| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 534|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 267|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 267] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 267| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3304| 267| yyscanner, OP_STR_TO_BOOL, NULL)); 3305| 267| } 3306| 22.6k| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_BOOLEAN) ------------------ | | 46| 22.6k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3306:13): [True: 1.44k, False: 21.1k] ------------------ 3307| 1.44k| { 3308| 1.44k| (yyval.expression).required_strings.count = 0; 3309| 1.44k| } 3310| 21.1k| else 3311| 21.1k| { 3312| 21.1k| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count; 3313| 21.1k| } 3314| | 3315| 22.6k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 22.6k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3316| 22.6k| } 3317| 0|#line 3318 "libyara/grammar.c" 3318| 0| break; 3319| | 3320| 8| case 76: /* expression: "" */ ------------------ | Branch (3320:3): [True: 8, False: 634k] ------------------ 3321| 8|#line 1355 "libyara/grammar.y" 3322| 8| { 3323| 8| fail_if_error(yr_parser_emit_push_const(yyscanner, 1)); ------------------ | | 135| 8| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 16|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 8|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 8] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 8| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3324| | 3325| 8| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3326| 8| (yyval.expression).required_strings.count = 0; 3327| 8| } 3328| 0|#line 3329 "libyara/grammar.c" 3329| 0| break; 3330| | 3331| 216| case 77: /* expression: "" */ ------------------ | Branch (3331:3): [True: 216, False: 633k] ------------------ 3332| 216|#line 1362 "libyara/grammar.y" 3333| 216| { 3334| 216| fail_if_error(yr_parser_emit_push_const(yyscanner, 0)); ------------------ | | 135| 216| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 432|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 216|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 216] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 216| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3335| | 3336| 216| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 216|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3337| 216| (yyval.expression).required_strings.count = 0; 3338| 216| } 3339| 0|#line 3340 "libyara/grammar.c" 3340| 0| break; 3341| | 3342| 35| case 78: /* expression: primary_expression "" regexp */ ------------------ | Branch (3342:3): [True: 35, False: 634k] ------------------ 3343| 35|#line 1369 "libyara/grammar.y" 3344| 35| { 3345| 35| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "matches"); ------------------ | | 175| 35| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 35| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 23, False: 12] | | | | ------------------ | | | | 146| 35| { \ | | | | 147| 23| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 23] | | | | ------------------ | | | | 148| 23| { \ | | | | 149| 15| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 15|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 15, False: 8] | | | | ------------------ | | | | 150| 15| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 15| strlcpy( \ | | | | | | 307| 15| compiler->last_error_extra_info, \ | | | | | | 308| 15| info, \ | | | | | | 309| 15| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 15| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 15| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 23] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 23] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 15] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 23| } \ | | | | 166| 23| cleanup; \ | | | | 167| 23| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 23|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 23| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 23|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 23| YYERROR; \ | | | | ------------------ | | | | | | 1313| 23|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 23| } | | ------------------ ------------------ 3346| 12| check_type((yyvsp[0].expression), EXPRESSION_TYPE_REGEXP, "matches"); ------------------ | | 175| 12| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 12| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 12] | | | | ------------------ | | | | 146| 12| { \ | | | | 147| 0| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 0] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 0] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 0] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 0] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3347| | 3348| 12| fail_if_error(yr_parser_emit( ------------------ | | 135| 12| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 24|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 12|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 12] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 12| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3349| 12| yyscanner, 3350| 12| OP_MATCHES, 3351| 12| NULL)); 3352| | 3353| 12| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 12|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3354| 12| (yyval.expression).required_strings.count = 0; 3355| 12| } 3356| 0|#line 3357 "libyara/grammar.c" 3357| 0| break; 3358| | 3359| 73| case 79: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3359:3): [True: 73, False: 634k] ------------------ 3360| 73|#line 1382 "libyara/grammar.y" 3361| 73| { 3362| 73| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 175| 73| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 73| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 39, False: 34] | | | | ------------------ | | | | 146| 73| { \ | | | | 147| 39| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 39] | | | | ------------------ | | | | 148| 39| { \ | | | | 149| 7| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 7|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 7, False: 32] | | | | ------------------ | | | | 150| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 7| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 7| break; \ | | | | 153| 28| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 28|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 28, False: 11] | | | | ------------------ | | | | 154| 28| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 28| strlcpy( \ | | | | | | 307| 28| compiler->last_error_extra_info, \ | | | | | | 308| 28| info, \ | | | | | | 309| 28| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 28| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 28| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 39] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 35] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 39| } \ | | | | 166| 39| cleanup; \ | | | | 167| 39| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 39|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 39| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 39|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 39| YYERROR; \ | | | | ------------------ | | | | | | 1313| 39|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 39| } | | ------------------ ------------------ 3363| 34| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 175| 34| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 34| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 4, False: 30] | | | | ------------------ | | | | 146| 34| { \ | | | | 147| 4| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 4] | | | | ------------------ | | | | 148| 4| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 4] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 0] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 4] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 4] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 4| } \ | | | | 166| 4| cleanup; \ | | | | 167| 4| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 4|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 4| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 4|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 4| YYERROR; \ | | | | ------------------ | | | | | | 1313| 4|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 4| } | | ------------------ ------------------ 3364| | 3365| 30| fail_if_error(yr_parser_emit( ------------------ | | 135| 30| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 60|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 30|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 30] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 30| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3366| 30| yyscanner, OP_CONTAINS, NULL)); 3367| | 3368| 30| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 30|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3369| 30| (yyval.expression).required_strings.count = 0; 3370| 30| } 3371| 0|#line 3372 "libyara/grammar.c" 3372| 0| break; 3373| | 3374| 78| case 80: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3374:3): [True: 78, False: 634k] ------------------ 3375| 78|#line 1393 "libyara/grammar.y" 3376| 78| { 3377| 78| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 175| 78| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 78| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 36, False: 42] | | | | ------------------ | | | | 146| 78| { \ | | | | 147| 36| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 17, False: 19] | | | | ------------------ | | | | 148| 36| { \ | | | | 149| 15| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 15|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 15, False: 21] | | | | ------------------ | | | | 150| 15| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 15| strlcpy( \ | | | | | | 307| 15| compiler->last_error_extra_info, \ | | | | | | 308| 15| info, \ | | | | | | 309| 15| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 15| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 15| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 32] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 36] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 36] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 36| } \ | | | | 166| 36| cleanup; \ | | | | 167| 36| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 36|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 36| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 36|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 36| YYERROR; \ | | | | ------------------ | | | | | | 1313| 36|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 36| } | | ------------------ ------------------ 3378| 42| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 175| 42| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 42| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 42, False: 0] | | | | ------------------ | | | | 146| 42| { \ | | | | 147| 42| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 4, False: 38] | | | | ------------------ | | | | 148| 42| { \ | | | | 149| 18| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 18|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 18, False: 24] | | | | ------------------ | | | | 150| 18| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 18| strlcpy( \ | | | | | | 307| 18| compiler->last_error_extra_info, \ | | | | | | 308| 18| info, \ | | | | | | 309| 18| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 18| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 18| break; \ | | | | 153| 7| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 7|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 7, False: 35] | | | | ------------------ | | | | 154| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 7| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 7| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 42] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 13| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 13|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 13, False: 29] | | | | ------------------ | | | | 162| 13| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 13| strlcpy( \ | | | | | | 307| 13| compiler->last_error_extra_info, \ | | | | | | 308| 13| info, \ | | | | | | 309| 13| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 13| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 13| break; \ | | | | 165| 42| } \ | | | | 166| 42| cleanup; \ | | | | 167| 42| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 42|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 42| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 42|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 42| YYERROR; \ | | | | ------------------ | | | | | | 1313| 42|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 42| } | | ------------------ ------------------ 3379| | 3380| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3381| 0| yyscanner, OP_ICONTAINS, NULL)); 3382| | 3383| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3384| 0| (yyval.expression).required_strings.count = 0; 3385| 0| } 3386| 0|#line 3387 "libyara/grammar.c" 3387| 0| break; 3388| | 3389| 56| case 81: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3389:3): [True: 56, False: 634k] ------------------ 3390| 56|#line 1404 "libyara/grammar.y" 3391| 56| { 3392| 56| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "startswith"); ------------------ | | 175| 56| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 56| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 25, False: 31] | | | | ------------------ | | | | 146| 56| { \ | | | | 147| 25| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 7, False: 18] | | | | ------------------ | | | | 148| 25| { \ | | | | 149| 9| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 9|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 9, False: 16] | | | | ------------------ | | | | 150| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 9| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 9| break; \ | | | | 153| 5| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 5|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 5, False: 20] | | | | ------------------ | | | | 154| 5| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 5| strlcpy( \ | | | | | | 307| 5| compiler->last_error_extra_info, \ | | | | | | 308| 5| info, \ | | | | | | 309| 5| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 5| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 5| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 25] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 21] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 25| } \ | | | | 166| 25| cleanup; \ | | | | 167| 25| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 25|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 25| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 25|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 25| YYERROR; \ | | | | ------------------ | | | | | | 1313| 25|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 25| } | | ------------------ ------------------ 3393| 31| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "startswith"); ------------------ | | 175| 31| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 31| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 15, False: 16] | | | | ------------------ | | | | 146| 31| { \ | | | | 147| 15| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 7, False: 8] | | | | ------------------ | | | | 148| 15| { \ | | | | 149| 4| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 4|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 4, False: 11] | | | | ------------------ | | | | 150| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 4| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 4| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 11] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 15] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 15] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 15| } \ | | | | 166| 15| cleanup; \ | | | | 167| 15| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 15|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 15| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 15|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 15| YYERROR; \ | | | | ------------------ | | | | | | 1313| 15|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 15| } | | ------------------ ------------------ 3394| | 3395| 16| fail_if_error(yr_parser_emit( ------------------ | | 135| 16| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 32|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 16|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 16] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 16| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3396| 16| yyscanner, OP_STARTSWITH, NULL)); 3397| | 3398| 16| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 16|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3399| 16| (yyval.expression).required_strings.count = 0; 3400| 16| } 3401| 0|#line 3402 "libyara/grammar.c" 3402| 0| break; 3403| | 3404| 129| case 82: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3404:3): [True: 129, False: 634k] ------------------ 3405| 129|#line 1415 "libyara/grammar.y" 3406| 129| { 3407| 129| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "istartswith"); ------------------ | | 175| 129| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 129| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 20, False: 109] | | | | ------------------ | | | | 146| 129| { \ | | | | 147| 20| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 4, False: 16] | | | | ------------------ | | | | 148| 20| { \ | | | | 149| 9| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 9|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 9, False: 11] | | | | ------------------ | | | | 150| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 9| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 9| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 20] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 20] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 7| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 7|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 7, False: 13] | | | | ------------------ | | | | 162| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 7| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 7| break; \ | | | | 165| 20| } \ | | | | 166| 20| cleanup; \ | | | | 167| 20| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 20|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 20| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 20|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 20| YYERROR; \ | | | | ------------------ | | | | | | 1313| 20|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 20| } | | ------------------ ------------------ 3408| 109| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "istartswith"); ------------------ | | 175| 109| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 109| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 9, False: 100] | | | | ------------------ | | | | 146| 109| { \ | | | | 147| 9| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 9, False: 0] | | | | ------------------ | | | | 148| 9| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 9] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 9] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 9] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 9] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 9| } \ | | | | 166| 9| cleanup; \ | | | | 167| 9| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 9|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 9| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 9|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 9| YYERROR; \ | | | | ------------------ | | | | | | 1313| 9|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 9| } | | ------------------ ------------------ 3409| | 3410| 100| fail_if_error(yr_parser_emit( ------------------ | | 135| 100| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 200|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 100|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 100] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 100| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3411| 100| yyscanner, OP_ISTARTSWITH, NULL)); 3412| | 3413| 100| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 100|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3414| 100| (yyval.expression).required_strings.count = 0; 3415| 100| } 3416| 0|#line 3417 "libyara/grammar.c" 3417| 0| break; 3418| | 3419| 49| case 83: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3419:3): [True: 49, False: 634k] ------------------ 3420| 49|#line 1426 "libyara/grammar.y" 3421| 49| { 3422| 49| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 175| 49| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 49| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 12, False: 37] | | | | ------------------ | | | | 146| 49| { \ | | | | 147| 12| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 12] | | | | ------------------ | | | | 148| 12| { \ | | | | 149| 12| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 12|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 12, False: 0] | | | | ------------------ | | | | 150| 12| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 12| strlcpy( \ | | | | | | 307| 12| compiler->last_error_extra_info, \ | | | | | | 308| 12| info, \ | | | | | | 309| 12| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 12| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 12| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 12] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 12] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 12] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 12| } \ | | | | 166| 12| cleanup; \ | | | | 167| 12| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 12|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 12| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 12|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 12| YYERROR; \ | | | | ------------------ | | | | | | 1313| 12|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 12| } | | ------------------ ------------------ 3423| 37| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 175| 37| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 37| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 4, False: 33] | | | | ------------------ | | | | 146| 37| { \ | | | | 147| 4| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 4] | | | | ------------------ | | | | 148| 4| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 4] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 0] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 4] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 4] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 4| } \ | | | | 166| 4| cleanup; \ | | | | 167| 4| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 4|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 4| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 4|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 4| YYERROR; \ | | | | ------------------ | | | | | | 1313| 4|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 4| } | | ------------------ ------------------ 3424| | 3425| 33| fail_if_error(yr_parser_emit( ------------------ | | 135| 33| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 66|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 33|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 33] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 33| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3426| 33| yyscanner, OP_ENDSWITH, NULL)); 3427| | 3428| 33| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 33|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3429| 33| (yyval.expression).required_strings.count = 0; 3430| 33| } 3431| 0|#line 3432 "libyara/grammar.c" 3432| 0| break; 3433| | 3434| 49| case 84: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3434:3): [True: 49, False: 634k] ------------------ 3435| 49|#line 1437 "libyara/grammar.y" 3436| 49| { 3437| 49| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 175| 49| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 49| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 49] | | | | ------------------ | | | | 146| 49| { \ | | | | 147| 0| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 0] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 0] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 0] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 0] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3438| 49| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 175| 49| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 49| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 49] | | | | ------------------ | | | | 146| 49| { \ | | | | 147| 0| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 0] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 0] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 0] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 0] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3439| | 3440| 49| fail_if_error(yr_parser_emit( ------------------ | | 135| 49| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 98|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 49|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 49] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 49| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3441| 49| yyscanner, OP_IENDSWITH, NULL)); 3442| | 3443| 49| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 49|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3444| 49| (yyval.expression).required_strings.count = 0; 3445| 49| } 3446| 0|#line 3447 "libyara/grammar.c" 3447| 0| break; 3448| | 3449| 0| case 85: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3449:3): [True: 0, False: 634k] ------------------ 3450| 0|#line 1448 "libyara/grammar.y" 3451| 0| { 3452| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "iequals"); ------------------ | | 175| 0| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 0| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 0] | | | | ------------------ | | | | 146| 0| { \ | | | | 147| 0| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 0] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 0] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 0] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 0] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3453| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "iequals"); ------------------ | | 175| 0| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 0| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 0] | | | | ------------------ | | | | 146| 0| { \ | | | | 147| 0| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 0] | | | | ------------------ | | | | 148| 0| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 0] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 0] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 0] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 0] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3454| | 3455| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3456| 0| yyscanner, OP_IEQUALS, NULL)); 3457| | 3458| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3459| 0| (yyval.expression).required_strings.count = 0; 3460| 0| } 3461| 0|#line 3462 "libyara/grammar.c" 3462| 0| break; 3463| | 3464| 490| case 86: /* expression: "string identifier" */ ------------------ | Branch (3464:3): [True: 490, False: 633k] ------------------ 3465| 490|#line 1459 "libyara/grammar.y" 3466| 490| { 3467| 490| int result = yr_parser_reduce_string_identifier( 3468| 490| yyscanner, 3469| 490| (yyvsp[0].c_string), 3470| 490| OP_FOUND, ------------------ | | 70| 490|#define OP_FOUND 22 ------------------ 3471| 490| YR_UNDEFINED); ------------------ | | 38| 490|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 3472| | 3473| 490| yr_free((yyvsp[0].c_string)); 3474| | 3475| 490| fail_if_error(result); ------------------ | | 135| 490| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 980|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 530|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 40, False: 450] | | | Branch (135:31): [True: 40, False: 0] | | ------------------ | | 136| 490| { \ | | 137| 40| fail_with_error(e); \ | | ------------------ | | | | 120| 40| { \ | | | | 121| 40| compiler->last_error = e; \ | | | | 122| 40| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 40|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 40| switch (e) \ | | | | 124| 40| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 40] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 40| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 40, False: 0] | | | | ------------------ | | | | 128| 40| YYERROR; \ | | | | ------------------ | | | | | | 1313| 40|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 40| } \ | | | | 130| 40| } | | ------------------ | | 138| 0| } ------------------ 3476| | 3477| 450| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 450|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3478| 450| (yyval.expression).required_strings.count = 1; 3479| 450| } 3480| 0|#line 3481 "libyara/grammar.c" 3481| 0| break; 3482| | 3483| 749| case 87: /* expression: "string identifier" "" primary_expression */ ------------------ | Branch (3483:3): [True: 749, False: 633k] ------------------ 3484| 749|#line 1474 "libyara/grammar.y" 3485| 749| { 3486| 749| int result; 3487| | 3488| 749| check_type_with_cleanup((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "at", yr_free((yyvsp[-2].c_string))); ------------------ | | 145| 749| if (((expression.type) & (expected_type)) == 0) \ | | ------------------ | | | Branch (145:9): [True: 15, False: 734] | | ------------------ | | 146| 749| { \ | | 147| 15| switch(expression.type) \ | | ------------------ | | | Branch (147:14): [True: 0, False: 15] | | ------------------ | | 148| 15| { \ | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | ------------------ | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | ------------------ | | | Branch (149:9): [True: 0, False: 15] | | ------------------ | | 150| 0| yr_compiler_set_error_extra_info( \ | | ------------------ | | | | 306| 0| strlcpy( \ | | | | 307| 0| compiler->last_error_extra_info, \ | | | | 308| 0| info, \ | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | 152| 0| break; \ | | 153| 8| case EXPRESSION_TYPE_FLOAT: \ | | ------------------ | | | | 51| 8|#define EXPRESSION_TYPE_FLOAT 32 | | ------------------ | | | Branch (153:9): [True: 8, False: 7] | | ------------------ | | 154| 8| yr_compiler_set_error_extra_info( \ | | ------------------ | | | | 306| 8| strlcpy( \ | | | | 307| 8| compiler->last_error_extra_info, \ | | | | 308| 8| info, \ | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 155| 8| compiler, "wrong type \"float\" for " op " operator"); \ | | 156| 8| break; \ | | 157| 7| case EXPRESSION_TYPE_STRING: \ | | ------------------ | | | | 48| 7|#define EXPRESSION_TYPE_STRING 4 | | ------------------ | | | Branch (157:9): [True: 7, False: 8] | | ------------------ | | 158| 7| yr_compiler_set_error_extra_info( \ | | ------------------ | | | | 306| 7| strlcpy( \ | | | | 307| 7| compiler->last_error_extra_info, \ | | | | 308| 7| info, \ | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 159| 7| compiler, "wrong type \"string\" for " op " operator"); \ | | 160| 7| break; \ | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | ------------------ | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | ------------------ | | | Branch (161:9): [True: 0, False: 15] | | ------------------ | | 162| 0| yr_compiler_set_error_extra_info( \ | | ------------------ | | | | 306| 0| strlcpy( \ | | | | 307| 0| compiler->last_error_extra_info, \ | | | | 308| 0| info, \ | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | 164| 0| break; \ | | 165| 15| } \ | | 166| 15| cleanup; \ | | 167| 15| compiler->last_error = ERROR_WRONG_TYPE; \ | | ------------------ | | | | 69| 15|#define ERROR_WRONG_TYPE 24 | | ------------------ | | 168| 15| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 15|#define yyerror yara_yyerror | | ------------------ | | 169| 15| YYERROR; \ | | ------------------ | | | | 1313| 15|#define YYERROR goto yyerrorlab | | ------------------ | | 170| 15| } ------------------ 3489| | 3490| 734| result = yr_parser_reduce_string_identifier( 3491| 734| yyscanner, (yyvsp[-2].c_string), OP_FOUND_AT, (yyvsp[0].expression).value.integer); ------------------ | | 71| 734|#define OP_FOUND_AT 23 ------------------ 3492| | 3493| 734| yr_free((yyvsp[-2].c_string)); 3494| | 3495| 734| fail_if_error(result); ------------------ | | 135| 734| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.46k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 735|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 1, False: 733] | | | Branch (135:31): [True: 1, False: 0] | | ------------------ | | 136| 734| { \ | | 137| 1| fail_with_error(e); \ | | ------------------ | | | | 120| 1| { \ | | | | 121| 1| compiler->last_error = e; \ | | | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 1|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 1| switch (e) \ | | | | 124| 1| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 1] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 1| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 1, False: 0] | | | | ------------------ | | | | 128| 1| YYERROR; \ | | | | ------------------ | | | | | | 1313| 1|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 1| } \ | | | | 130| 1| } | | ------------------ | | 138| 0| } ------------------ 3496| | 3497| 733| (yyval.expression).required_strings.count = 1; 3498| 733| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 733|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3499| 733| } 3500| 0|#line 3501 "libyara/grammar.c" 3501| 0| break; 3502| | 3503| 47| case 88: /* expression: "string identifier" "" range */ ------------------ | Branch (3503:3): [True: 47, False: 634k] ------------------ 3504| 47|#line 1490 "libyara/grammar.y" 3505| 47| { 3506| 47| int result = yr_parser_reduce_string_identifier( 3507| 47| yyscanner, (yyvsp[-2].c_string), OP_FOUND_IN, YR_UNDEFINED); ------------------ | | 72| 47|#define OP_FOUND_IN 24 ------------------ yyscanner, (yyvsp[-2].c_string), OP_FOUND_IN, YR_UNDEFINED); ------------------ | | 38| 47|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 3508| | 3509| 47| yr_free((yyvsp[-2].c_string)); 3510| | 3511| 47| fail_if_error(result); ------------------ | | 135| 47| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 94|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 72|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 25, False: 22] | | | Branch (135:31): [True: 25, False: 0] | | ------------------ | | 136| 47| { \ | | 137| 25| fail_with_error(e); \ | | ------------------ | | | | 120| 25| { \ | | | | 121| 25| compiler->last_error = e; \ | | | | 122| 25| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 25|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 25| switch (e) \ | | | | 124| 25| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 25] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 25| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 25, False: 0] | | | | ------------------ | | | | 128| 25| YYERROR; \ | | | | ------------------ | | | | | | 1313| 25|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 25| } \ | | | | 130| 25| } | | ------------------ | | 138| 0| } ------------------ 3512| | 3513| 22| (yyval.expression).required_strings.count = 1; 3514| 22| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 22|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3515| 22| } 3516| 0|#line 3517 "libyara/grammar.c" 3517| 0| break; 3518| | 3519| 1.87k| case 89: /* expression: "" for_expression error */ ------------------ | Branch (3519:3): [True: 1.87k, False: 632k] ------------------ 3520| 1.87k|#line 1502 "libyara/grammar.y" 3521| 1.87k| { 3522| | // Free all the loop variable identifiers, including the variables for 3523| | // the current loop (represented by loop_index), and set loop_index to 3524| | // -1. This is OK even if we have nested loops. If an error occurs while 3525| | // parsing the inner loop, it will be propagated to the outer loop 3526| | // anyways, so it's safe to do this cleanup while processing the error 3527| | // for the inner loop. 3528| | 3529| 3.71k| for (int i = 0; i <= compiler->loop_index; i++) ------------------ | Branch (3529:25): [True: 1.84k, False: 1.87k] ------------------ 3530| 1.84k| { 3531| 1.84k| loop_vars_cleanup(i); ------------------ | | 179| 1.84k| { \ | | 180| 1.84k| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 3.87k| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 2.03k, False: 1.84k] | | ------------------ | | 182| 2.03k| { \ | | 183| 2.03k| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 2.03k| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 2.03k| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 2.03k| (YR_ARENA_REF) \ | | | | 44| 2.03k| { \ | | | | 45| 2.03k| UINT32_MAX, UINT32_MAX \ | | | | 46| 2.03k| } | | ------------------ | | 186| 2.03k| } \ | | 187| 1.84k| loop_ctx->vars_count = 0; \ | | 188| 1.84k| } \ ------------------ 3532| 1.84k| } 3533| | 3534| 1.87k| compiler->loop_index = -1; 3535| 1.87k| YYERROR; ------------------ | | 1313| 1.87k|#define YYERROR goto yyerrorlab ------------------ 3536| 47| } 3537| 0|#line 3538 "libyara/grammar.c" 3538| 0| break; 3539| | 3540| 1.98k| case 90: /* $@6: %empty */ ------------------ | Branch (3540:3): [True: 1.98k, False: 632k] ------------------ 3541| 1.98k|#line 1576 "libyara/grammar.y" 3542| 1.98k| { 3543| | // var_frame is used for accessing local variables used in this loop. 3544| | // All local variables are accessed using var_frame as a reference, 3545| | // like var_frame + 0, var_frame + 1, etc. Here we initialize var_frame 3546| | // with the correct value, which depends on the number of variables 3547| | // defined by any outer loops. 3548| | 3549| 1.98k| int var_frame; 3550| 1.98k| int result = ERROR_SUCCESS; ------------------ | | 40| 1.98k|#define ERROR_SUCCESS 0 ------------------ 3551| | 3552| 1.98k| if (compiler->loop_index + 1 == YR_MAX_LOOP_NESTING) ------------------ | | 95| 1.98k|#define YR_MAX_LOOP_NESTING 4 ------------------ | Branch (3552:13): [True: 17, False: 1.96k] ------------------ 3553| 17| result = ERROR_LOOP_NESTING_LIMIT_EXCEEDED; ------------------ | | 57| 17|#define ERROR_LOOP_NESTING_LIMIT_EXCEEDED 12 ------------------ 3554| | 3555| 1.98k| fail_if_error(result); ------------------ | | 135| 1.98k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.97k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.00k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 17, False: 1.96k] | | | Branch (135:31): [True: 17, False: 0] | | ------------------ | | 136| 1.98k| { \ | | 137| 17| fail_with_error(e); \ | | ------------------ | | | | 120| 17| { \ | | | | 121| 17| compiler->last_error = e; \ | | | | 122| 17| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 17|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 17| switch (e) \ | | | | 124| 17| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 17] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 17| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 17, False: 0] | | | | ------------------ | | | | 128| 17| YYERROR; \ | | | | ------------------ | | | | | | 1313| 17|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 17| } \ | | | | 130| 17| } | | ------------------ | | 138| 0| } ------------------ 3556| | 3557| 1.96k| compiler->loop_index++; 3558| | 3559| | // This loop uses internal variables besides the ones explicitly 3560| | // defined by the user. 3561| 1.96k| compiler->loop[compiler->loop_index].vars_internal_count = \ 3562| 1.96k| YR_INTERNAL_LOOP_VARS; ------------------ | | 76| 1.96k|#define YR_INTERNAL_LOOP_VARS 3 ------------------ 3563| | 3564| | // Initialize the number of variables, this number will be incremented 3565| | // as variable declaration are processed by for_variables. 3566| 1.96k| compiler->loop[compiler->loop_index].vars_count = 0; 3567| | 3568| 1.96k| var_frame = _yr_compiler_get_var_frame(compiler); 3569| | 3570| 1.96k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.96k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.93k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.96k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.96k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.96k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3571| 1.96k| yyscanner, OP_CLEAR_M, var_frame + 0, NULL, NULL)); 3572| | 3573| 1.96k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.96k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.93k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.96k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.96k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.96k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3574| 1.96k| yyscanner, OP_CLEAR_M, var_frame + 1, NULL, NULL)); 3575| | 3576| 1.96k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.96k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.93k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.96k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.96k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.96k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3577| 1.96k| yyscanner, OP_POP_M, var_frame + 2, NULL, NULL)); 3578| 1.96k| } 3579| 0|#line 3580 "libyara/grammar.c" 3580| 0| break; 3581| | 3582| 774| case 91: /* $@7: %empty */ ------------------ | Branch (3582:3): [True: 774, False: 633k] ------------------ 3583| 774|#line 1614 "libyara/grammar.y" 3584| 774| { 3585| 774| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 3586| 774| YR_FIXUP* fixup; 3587| | 3588| 774| YR_ARENA_REF loop_start_ref; 3589| 774| YR_ARENA_REF jmp_offset_ref; 3590| | 3591| 774| int var_frame = _yr_compiler_get_var_frame(compiler); 3592| | 3593| 774| fail_if_error(yr_parser_emit( ------------------ | | 135| 774| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.54k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 774|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 774] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 774| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3594| 774| yyscanner, OP_ITER_NEXT, &loop_start_ref)); 3595| | 3596| | // For each variable generate an instruction that pops the value from 3597| | // the stack and store it into one memory slot starting at var_frame + 3598| | // YR_INTERNAL_LOOP_VARS because the first YR_INTERNAL_LOOP_VARS slots 3599| | // in the frame are for the internal variables. 3600| | 3601| 1.70k| for (int i = 0; i < loop_ctx->vars_count; i++) ------------------ | Branch (3601:25): [True: 926, False: 774] ------------------ 3602| 926| { 3603| 926| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 926| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.85k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 926|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 926] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 926| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3604| 926| yyscanner, 3605| 926| OP_POP_M, 3606| 926| var_frame + YR_INTERNAL_LOOP_VARS + i, 3607| 926| NULL, 3608| 926| NULL)); 3609| 926| } 3610| | 3611| 774| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 774| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.54k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 774|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 774] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 774| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3612| 774| yyscanner, 3613| 774| OP_JTRUE_P, 3614| 774| 0, // still don't know the jump offset, use 0 for now. 3615| 774| NULL, 3616| 774| &jmp_offset_ref)); 3617| | 3618| | // We still don't know the jump's target, so we push a fixup entry 3619| | // in the stack, so that the jump's offset can be set once we know it. 3620| | 3621| 774| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3622| | 3623| 774| if (fixup == NULL) ------------------ | Branch (3623:13): [True: 0, False: 774] ------------------ 3624| 774| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3625| | 3626| 774| fixup->ref = jmp_offset_ref; 3627| 774| fixup->next = compiler->fixup_stack_head; 3628| 774| compiler->fixup_stack_head = fixup; 3629| | 3630| 774| loop_ctx->start_ref = loop_start_ref; 3631| 774| } 3632| 0|#line 3633 "libyara/grammar.c" 3633| 0| break; 3634| | 3635| 126| case 92: /* expression: "" for_expression $@6 for_iteration ':' $@7 '(' boolean_expression ')' */ ------------------ | Branch (3635:3): [True: 126, False: 634k] ------------------ 3636| 126|#line 1663 "libyara/grammar.y" 3637| 126| { 3638| 126| int32_t jmp_offset; 3639| 126| YR_FIXUP* fixup; 3640| 126| YR_ARENA_REF pop_ref; 3641| | 3642| 126| int var_frame = _yr_compiler_get_var_frame(compiler); 3643| | 3644| 126| if ((yyvsp[-5].integer) == FOR_ITERATION_STRING_SET) ------------------ | | 113| 126|#define FOR_ITERATION_STRING_SET 2 ------------------ | Branch (3644:13): [True: 27, False: 99] ------------------ 3645| 27| { 3646| 27| compiler->loop_for_of_var_index = -1; 3647| 27| } 3648| | 3649| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3650| 126| yyscanner, OP_INCR_M, var_frame + 1, NULL, NULL)); 3651| | 3652| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3653| 126| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3654| | 3655| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3656| 126| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3657| | 3658| 126| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_CONDITION, NULL)); ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3659| | 3660| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3661| 126| yyscanner, OP_ADD_M, var_frame + 0, NULL, NULL)); 3662| | 3663| 126| jmp_offset = \ 3664| 126| compiler->loop[compiler->loop_index].start_ref.offset - 3665| 126| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION); ------------------ | | 63| 126|#define YR_CODE_SECTION 6 ------------------ 3666| | 3667| 126| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3668| 126| yyscanner, 3669| 126| OP_JTRUE_P, 3670| 126| jmp_offset, 3671| 126| NULL, 3672| 126| NULL)); 3673| | 3674| 126| fail_if_error(yr_parser_emit( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3675| 126| yyscanner, OP_POP, &pop_ref)); 3676| | 3677| | // Pop from the stack the fixup entry containing the reference to 3678| | // the jump offset that needs to be fixed. 3679| | 3680| 126| fixup = compiler->fixup_stack_head; 3681| 126| compiler->fixup_stack_head = fixup->next; 3682| | 3683| | // The fixup entry has a reference to the jump offset that need 3684| | // to be fixed, convert the address into a pointer. 3685| 126| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3686| 126| compiler->arena, &fixup->ref); 3687| | 3688| | // The reference in the fixup entry points to the jump's offset 3689| | // but the jump instruction is one byte before, that's why we add 3690| | // one to the offset. 3691| 126| jmp_offset = pop_ref.offset - fixup->ref.offset + 1; 3692| | 3693| | // Fix the jump's offset. 3694| 126| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3695| | 3696| 126| yr_free(fixup); 3697| | 3698| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3699| 126| yyscanner, OP_PUSH_M, var_frame + 1, NULL, NULL)); 3700| | 3701| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3702| 126| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3703| | 3704| 126| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3705| 126| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3706| | 3707| 126| fail_if_error(yr_parser_emit( ------------------ | | 135| 126| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 252|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 126|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 126] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 126| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3708| 126| yyscanner, OP_ITER_END, NULL)); 3709| | 3710| 126| loop_vars_cleanup(compiler->loop_index); ------------------ | | 179| 126| { \ | | 180| 126| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 351| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 225, False: 126] | | ------------------ | | 182| 225| { \ | | 183| 225| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 225| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 225| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 225| (YR_ARENA_REF) \ | | | | 44| 225| { \ | | | | 45| 225| UINT32_MAX, UINT32_MAX \ | | | | 46| 225| } | | ------------------ | | 186| 225| } \ | | 187| 126| loop_ctx->vars_count = 0; \ | | 188| 126| } \ ------------------ 3711| | 3712| 126| compiler->loop_index--; 3713| | 3714| 126| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 126|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3715| 126| (yyval.expression).required_strings.count = 0; 3716| 126| } 3717| 0|#line 3718 "libyara/grammar.c" 3718| 0| break; 3719| | 3720| 1.45k| case 93: /* expression: for_expression "" string_set */ ------------------ | Branch (3720:3): [True: 1.45k, False: 632k] ------------------ 3721| 1.45k|#line 1744 "libyara/grammar.y" 3722| 1.45k| { 3723| 1.45k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].integer)) ------------------ | | 47| 2.90k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3723:13): [True: 1.37k, False: 81] | Branch (3723:71): [True: 663, False: 708] ------------------ 3724| 663| { 3725| 663| yywarning(yyscanner, ------------------ | | 50| 663|#define yywarning yara_yywarning ------------------ 3726| 663| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].integer)); 3727| 663| } 3728| | 3729| 1.45k| if (((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > 0) || ------------------ | | 47| 2.90k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3729:14): [True: 1.37k, False: 81] | Branch (3729:72): [True: 1.36k, False: 8] ------------------ 3730| 1.45k| ((yyvsp[-2].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 178|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3730:16): [True: 79, False: 10] ------------------ 3731| 89| ((yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 158|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 8|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3731:20): [True: 71, False: 8] | Branch (3731:82): [True: 8, False: 0] ------------------ 3732| 1.44k| { 3733| 1.44k| (yyval.expression).required_strings.count = 1; 3734| 1.44k| } 3735| 10| else 3736| 10| { 3737| 10| (yyval.expression).required_strings.count = 0; 3738| 10| } 3739| | 3740| 1.45k| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 74| 1.45k|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 42| 1.45k|#define OF_STRING_SET 0 ------------------ 3741| | 3742| 1.45k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 1.45k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3743| 1.45k| } 3744| 1.45k|#line 3745 "libyara/grammar.c" 3745| 1.45k| break; 3746| | 3747| 44| case 94: /* expression: for_expression "" rule_set */ ------------------ | Branch (3747:3): [True: 44, False: 634k] ------------------ 3748| 44|#line 1767 "libyara/grammar.y" 3749| 44| { 3750| 44| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].integer)) ------------------ | | 47| 88|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3750:13): [True: 23, False: 21] | Branch (3750:71): [True: 0, False: 23] ------------------ 3751| 0| { 3752| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3753| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].integer)); 3754| 0| } 3755| 44| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 74| 44|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 44|#define OF_RULE_SET 1 ------------------ 3756| | 3757| 44| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 44|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3758| 44| (yyval.expression).required_strings.count = 0; 3759| 44| } 3760| 44|#line 3761 "libyara/grammar.c" 3761| 44| break; 3762| | 3763| 25| case 95: /* expression: primary_expression '%' "" string_set */ ------------------ | Branch (3763:3): [True: 25, False: 634k] ------------------ 3764| 25|#line 1779 "libyara/grammar.y" 3765| 25| { 3766| 25| check_type((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 25| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 25| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 10, False: 15] | | | | ------------------ | | | | 146| 25| { \ | | | | 147| 10| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 10] | | | | ------------------ | | | | 148| 10| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 10] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 6] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 10] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 6| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 6|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 6, False: 4] | | | | ------------------ | | | | 162| 6| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 6| strlcpy( \ | | | | | | 307| 6| compiler->last_error_extra_info, \ | | | | | | 308| 6| info, \ | | | | | | 309| 6| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 6| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 6| break; \ | | | | 165| 10| } \ | | | | 166| 10| cleanup; \ | | | | 167| 10| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 10|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 10| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 10|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 10| YYERROR; \ | | | | ------------------ | | | | | | 1313| 10|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 10| } | | ------------------ ------------------ 3767| | 3768| | // The value of primary_expression can be undefined because 3769| | // it could be a variable for which don't know the value during 3770| | // compiling time. However, if the value is defined it should be 3771| | // in the range [1,100]. 3772| 15| if (!IS_UNDEFINED((yyvsp[-3].expression).value.integer) && ------------------ | | 39| 30|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 15|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3772:13): [True: 11, False: 4] ------------------ 3773| 15| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3773:14): [True: 4, False: 7] | Branch (3773:58): [True: 7, False: 0] ------------------ 3774| 11| { 3775| 11| yr_compiler_set_error_extra_info( ------------------ | | 306| 11| strlcpy( \ | | 307| 11| compiler->last_error_extra_info, \ | | 308| 11| info, \ | | 309| 11| sizeof(compiler->last_error_extra_info)); ------------------ 3776| 11| compiler, "percentage must be between 1 and 100 (inclusive)"); 3777| | 3778| 11| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 11| { \ | | 121| 11| compiler->last_error = e; \ | | 122| 11| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 11|#define yyerror yara_yyerror | | ------------------ | | 123| 11| switch (e) \ | | 124| 11| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 11] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 11| default: \ | | ------------------ | | | Branch (127:7): [True: 11, False: 0] | | ------------------ | | 128| 11| YYERROR; \ | | ------------------ | | | | 1313| 11|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 11| } \ | | 130| 11| } ------------------ 3779| 0| } 3780| | 3781| 4| if (!IS_UNDEFINED((yyvsp[-3].expression).value.integer)) ------------------ | | 39| 4|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 4|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3781:13): [True: 0, False: 4] ------------------ 3782| 0| { 3783| 0| (yyval.expression).required_strings.count = 1; 3784| 0| } 3785| 4| else 3786| 4| { 3787| 4| (yyval.expression).required_strings.count = 0; 3788| 4| } 3789| | 3790| 4| yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_STRING_SET, NULL, NULL); ------------------ | | 122| 4|#define OP_OF_PERCENT 74 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_STRING_SET, NULL, NULL); ------------------ | | 42| 4|#define OF_STRING_SET 0 ------------------ 3791| 4| } 3792| 0|#line 3793 "libyara/grammar.c" 3793| 0| break; 3794| | 3795| 42| case 96: /* expression: primary_expression '%' "" rule_set */ ------------------ | Branch (3795:3): [True: 42, False: 634k] ------------------ 3796| 42|#line 1807 "libyara/grammar.y" 3797| 42| { 3798| 42| check_type((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 42| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 42| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 14, False: 28] | | | | ------------------ | | | | 146| 42| { \ | | | | 147| 14| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 1, False: 13] | | | | ------------------ | | | | 148| 14| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 14] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 10] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 1| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 1|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 1, False: 13] | | | | ------------------ | | | | 158| 1| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 1| strlcpy( \ | | | | | | 307| 1| compiler->last_error_extra_info, \ | | | | | | 308| 1| info, \ | | | | | | 309| 1| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 1| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 1| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 6] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 14| } \ | | | | 166| 14| cleanup; \ | | | | 167| 14| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 14|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 14| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 14|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 14| YYERROR; \ | | | | ------------------ | | | | | | 1313| 14|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 14| } | | ------------------ ------------------ 3799| | 3800| | // The value of primary_expression can be undefined because 3801| | // it could be a variable for which don't know the value during 3802| | // compiling time. However, if the value is defined it should be 3803| | // in the range [1,100]. 3804| 28| if (!IS_UNDEFINED((yyvsp[-3].expression).value.integer) && ------------------ | | 39| 56|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 28|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3804:13): [True: 28, False: 0] ------------------ 3805| 28| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3805:14): [True: 5, False: 23] | Branch (3805:58): [True: 7, False: 16] ------------------ 3806| 12| { 3807| 12| yr_compiler_set_error_extra_info( ------------------ | | 306| 12| strlcpy( \ | | 307| 12| compiler->last_error_extra_info, \ | | 308| 12| info, \ | | 309| 12| sizeof(compiler->last_error_extra_info)); ------------------ 3808| 12| compiler, "percentage must be between 1 and 100 (inclusive)"); 3809| | 3810| 12| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 12| { \ | | 121| 12| compiler->last_error = e; \ | | 122| 12| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 12|#define yyerror yara_yyerror | | ------------------ | | 123| 12| switch (e) \ | | 124| 12| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 12] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 12| default: \ | | ------------------ | | | Branch (127:7): [True: 12, False: 0] | | ------------------ | | 128| 12| YYERROR; \ | | ------------------ | | | | 1313| 12|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 12| } \ | | 130| 12| } ------------------ 3811| 0| } 3812| | 3813| 16| yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 122| 16|#define OP_OF_PERCENT 74 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 16|#define OF_RULE_SET 1 ------------------ 3814| 16| } 3815| 0|#line 3816 "libyara/grammar.c" 3816| 0| break; 3817| | 3818| 178| case 97: /* expression: for_expression "" string_set "" range */ ------------------ | Branch (3818:3): [True: 178, False: 634k] ------------------ 3819| 178|#line 1826 "libyara/grammar.y" 3820| 178| { 3821| 178| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].integer)) ------------------ | | 47| 356|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3821:13): [True: 15, False: 163] | Branch (3821:71): [True: 4, False: 11] ------------------ 3822| 4| { 3823| 4| yywarning(yyscanner, ------------------ | | 50| 4|#define yywarning yara_yywarning ------------------ 3824| 4| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].integer)); 3825| 4| } 3826| | 3827| 178| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > 0) || ------------------ | | 47| 356|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3827:14): [True: 15, False: 163] | Branch (3827:72): [True: 4, False: 11] ------------------ 3828| 178| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 348|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3828:16): [True: 159, False: 15] ------------------ 3829| 174| ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 318|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 128|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3829:20): [True: 31, False: 128] | Branch (3829:82): [True: 128, False: 0] ------------------ 3830| 163| { 3831| 163| (yyval.expression).required_strings.count = 1; 3832| 163| } 3833| 15| else 3834| 15| { 3835| 15| (yyval.expression).required_strings.count = 0; 3836| 15| } 3837| | 3838| 178| yr_parser_emit(yyscanner, OP_OF_FOUND_IN, NULL); ------------------ | | 123| 178|#define OP_OF_FOUND_IN 75 ------------------ 3839| | 3840| 178| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 178|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3841| 178| } 3842| 178|#line 3843 "libyara/grammar.c" 3843| 178| break; 3844| | 3845| 8.08k| case 98: /* expression: for_expression "" string_set "" primary_expression */ ------------------ | Branch (3845:3): [True: 8.08k, False: 626k] ------------------ 3846| 8.08k|#line 1849 "libyara/grammar.y" 3847| 8.08k| { 3848| 8.08k| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 8.08k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3848:13): [True: 9, False: 8.07k] ------------------ 3849| 9| { 3850| 9| yr_compiler_set_error_extra_info(compiler, ------------------ | | 306| 9| strlcpy( \ | | 307| 9| compiler->last_error_extra_info, \ | | 308| 9| info, \ | | 309| 9| sizeof(compiler->last_error_extra_info)); ------------------ 3851| 9| "at expression must be an integer"); 3852| | 3853| 9| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 9| { \ | | 121| 9| compiler->last_error = e; \ | | 122| 9| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 9|#define yyerror yara_yyerror | | ------------------ | | 123| 9| switch (e) \ | | 124| 9| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 9] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 9| default: \ | | ------------------ | | | Branch (127:7): [True: 9, False: 0] | | ------------------ | | 128| 9| YYERROR; \ | | ------------------ | | | | 1313| 9|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 9| } \ | | 130| 9| } ------------------ 3854| 0| } 3855| | 3856| 8.07k| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].integer)) ------------------ | | 47| 16.1k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3856:13): [True: 4.56k, False: 3.51k] | Branch (3856:71): [True: 250, False: 4.31k] ------------------ 3857| 250| { 3858| 250| yywarning(yyscanner, ------------------ | | 50| 250|#define yywarning yara_yywarning ------------------ 3859| 250| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].integer)); 3860| 250| } 3861| | 3862| | // Both of these are warnings: 3863| | // 3864| | // "N of them at 0" where N > 1 3865| | // 3866| | //"all of them at 0" where there is more than 1 in "them". 3867| | // 3868| | // This means you can do "all of them at 0" if you only have one string 3869| | // defined in the set. 3870| 8.07k| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 16.1k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3870:14): [True: 4.56k, False: 3.51k] ------------------ 3871| 8.07k| !IS_UNDEFINED((yyvsp[-4].expression).value.integer) && (yyvsp[-4].expression).value.integer > 1) || ------------------ | | 39| 12.6k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 4.56k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3871:15): [True: 4.23k, False: 323] | Branch (3871:70): [True: 250, False: 3.98k] ------------------ 3872| 8.07k| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 15.6k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3872:16): [True: 3.18k, False: 4.64k] ------------------ 3873| 7.82k| (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL && (yyvsp[-2].integer) > 1)) ------------------ | | 108| 11.0k|#define FOR_EXPRESSION_ALL 1 ------------------ | Branch (3873:15): [True: 2.01k, False: 1.17k] | Branch (3873:77): [True: 319, False: 1.69k] ------------------ 3874| 569| { 3875| 569| yywarning(yyscanner, ------------------ | | 50| 569|#define yywarning yara_yywarning ------------------ 3876| 569| "multiple strings at an offset is usually false."); 3877| 569| } 3878| | 3879| 8.07k| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > 0) || ------------------ | | 47| 16.1k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3879:14): [True: 4.56k, False: 3.51k] | Branch (3879:72): [True: 2.90k, False: 1.65k] ------------------ 3880| 8.07k| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 10.3k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3880:16): [True: 3.18k, False: 1.99k] ------------------ 3881| 5.17k| ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 6.36k|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 1.17k|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3881:20): [True: 2.01k, False: 1.17k] | Branch (3881:82): [True: 1.17k, False: 0] ------------------ 3882| 6.08k| { 3883| 6.08k| (yyval.expression).required_strings.count = 1; 3884| 6.08k| } 3885| 1.99k| else 3886| 1.99k| { 3887| 1.99k| (yyval.expression).required_strings.count = 0; 3888| 1.99k| } 3889| | 3890| 8.07k| yr_parser_emit(yyscanner, OP_OF_FOUND_AT, NULL); ------------------ | | 127| 8.07k|#define OP_OF_FOUND_AT 79 ------------------ 3891| | 3892| 8.07k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 8.07k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3893| 8.07k| } 3894| 0|#line 3895 "libyara/grammar.c" 3895| 0| break; 3896| | 3897| 167| case 99: /* expression: "" boolean_expression */ ------------------ | Branch (3897:3): [True: 167, False: 634k] ------------------ 3898| 167|#line 1897 "libyara/grammar.y" 3899| 167| { 3900| 167| yr_parser_emit(yyscanner, OP_NOT, NULL); ------------------ | | 51| 167|#define OP_NOT 3 ------------------ 3901| | 3902| 167| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 167|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3903| 167| (yyval.expression).required_strings.count = 0; 3904| 167| } 3905| 167|#line 3906 "libyara/grammar.c" 3906| 167| break; 3907| | 3908| 0| case 100: /* expression: "" boolean_expression */ ------------------ | Branch (3908:3): [True: 0, False: 634k] ------------------ 3909| 0|#line 1904 "libyara/grammar.y" 3910| 0| { 3911| 0| yr_parser_emit(yyscanner, OP_DEFINED, NULL); ------------------ | | 125| 0|#define OP_DEFINED 77 ------------------ 3912| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3913| 0| (yyval.expression).required_strings.count = 0; 3914| 0| } 3915| 0|#line 3916 "libyara/grammar.c" 3916| 0| break; 3917| | 3918| 91| case 101: /* $@8: %empty */ ------------------ | Branch (3918:3): [True: 91, False: 634k] ------------------ 3919| 91|#line 1910 "libyara/grammar.y" 3920| 91| { 3921| 91| YR_FIXUP* fixup; 3922| 91| YR_ARENA_REF jmp_offset_ref; 3923| | 3924| 91| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 91| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 182|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 91|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 91] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 91| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3925| 91| yyscanner, 3926| 91| OP_JFALSE, 3927| 91| 0, // still don't know the jump offset, use 0 for now. 3928| 91| NULL, 3929| 91| &jmp_offset_ref)); 3930| | 3931| | // Create a fixup entry for the jump and push it in the stack. 3932| 91| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3933| | 3934| 91| if (fixup == NULL) ------------------ | Branch (3934:13): [True: 0, False: 91] ------------------ 3935| 91| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3936| | 3937| 91| fixup->ref = jmp_offset_ref; 3938| 91| fixup->next = compiler->fixup_stack_head; 3939| 91| compiler->fixup_stack_head = fixup; 3940| 91| } 3941| 0|#line 3942 "libyara/grammar.c" 3942| 0| break; 3943| | 3944| 90| case 102: /* expression: boolean_expression "" $@8 boolean_expression */ ------------------ | Branch (3944:3): [True: 90, False: 634k] ------------------ 3945| 90|#line 1932 "libyara/grammar.y" 3946| 90| { 3947| 90| YR_FIXUP* fixup; 3948| | 3949| 90| fail_if_error(yr_parser_emit(yyscanner, OP_AND, NULL)); ------------------ | | 135| 90| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 180|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 90|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 90] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 90| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3950| | 3951| 90| fixup = compiler->fixup_stack_head; 3952| | 3953| 90| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3954| 90| compiler->arena, &fixup->ref); 3955| | 3956| 90| int32_t jmp_offset = \ 3957| 90| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 90|#define YR_CODE_SECTION 6 ------------------ 3958| 90| fixup->ref.offset + 1; 3959| | 3960| 90| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3961| | 3962| | // Remove fixup from the stack. 3963| 90| compiler->fixup_stack_head = fixup->next; 3964| 90| yr_free(fixup); 3965| | 3966| 90| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 90|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3967| 90| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count + (yyvsp[-3].expression).required_strings.count; 3968| 90| } 3969| 0|#line 3970 "libyara/grammar.c" 3970| 0| break; 3971| | 3972| 11.7k| case 103: /* $@9: %empty */ ------------------ | Branch (3972:3): [True: 11.7k, False: 622k] ------------------ 3973| 11.7k|#line 1956 "libyara/grammar.y" 3974| 11.7k| { 3975| 11.7k| YR_FIXUP* fixup; 3976| 11.7k| YR_ARENA_REF jmp_offset_ref; 3977| | 3978| 11.7k| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 11.7k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 23.5k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 11.7k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 11.7k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 11.7k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3979| 11.7k| yyscanner, 3980| 11.7k| OP_JTRUE, 3981| 11.7k| 0, // still don't know the jump destination, use 0 for now. 3982| 11.7k| NULL, 3983| 11.7k| &jmp_offset_ref)); 3984| | 3985| 11.7k| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3986| | 3987| 11.7k| if (fixup == NULL) ------------------ | Branch (3987:13): [True: 0, False: 11.7k] ------------------ 3988| 11.7k| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1313| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3989| | 3990| 11.7k| fixup->ref = jmp_offset_ref; 3991| 11.7k| fixup->next = compiler->fixup_stack_head; 3992| 11.7k| compiler->fixup_stack_head = fixup; 3993| 11.7k| } 3994| 0|#line 3995 "libyara/grammar.c" 3995| 0| break; 3996| | 3997| 9.50k| case 104: /* expression: boolean_expression "" $@9 boolean_expression */ ------------------ | Branch (3997:3): [True: 9.50k, False: 624k] ------------------ 3998| 9.50k|#line 1977 "libyara/grammar.y" 3999| 9.50k| { 4000| 9.50k| YR_FIXUP* fixup; 4001| | 4002| 9.50k| fail_if_error(yr_parser_emit(yyscanner, OP_OR, NULL)); ------------------ | | 135| 9.50k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 19.0k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 9.50k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 9.50k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 9.50k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4003| | 4004| 9.50k| fixup = compiler->fixup_stack_head; 4005| | 4006| 9.50k| int32_t jmp_offset = \ 4007| 9.50k| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 9.50k|#define YR_CODE_SECTION 6 ------------------ 4008| 9.50k| fixup->ref.offset + 1; 4009| | 4010| 9.50k| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 4011| 9.50k| compiler->arena, &fixup->ref); 4012| | 4013| 9.50k| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 4014| | 4015| | // Remove fixup from the stack. 4016| 9.50k| compiler->fixup_stack_head = fixup->next; 4017| 9.50k| yr_free(fixup); 4018| | 4019| 9.50k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 9.50k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4020| | 4021| | // Set required string count to minimum from both parts 4022| 9.50k| if ((yyvsp[-3].expression).required_strings.count > (yyvsp[0].expression).required_strings.count) { ------------------ | Branch (4022:13): [True: 345, False: 9.16k] ------------------ 4023| 345| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count; 4024| 9.16k| } else { 4025| 9.16k| (yyval.expression).required_strings.count = (yyvsp[-3].expression).required_strings.count; 4026| 9.16k| } 4027| 9.50k| } 4028| 0|#line 4029 "libyara/grammar.c" 4029| 0| break; 4030| | 4031| 1.28k| case 105: /* expression: primary_expression "<" primary_expression */ ------------------ | Branch (4031:3): [True: 1.28k, False: 632k] ------------------ 4032| 1.28k|#line 2007 "libyara/grammar.y" 4033| 1.28k| { 4034| 1.28k| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 1.28k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 2.56k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.29k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 7, False: 1.27k] | | | Branch (135:31): [True: 7, False: 0] | | ------------------ | | 136| 1.28k| { \ | | 137| 7| fail_with_error(e); \ | | ------------------ | | | | 120| 7| { \ | | | | 121| 7| compiler->last_error = e; \ | | | | 122| 7| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 7|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 7| switch (e) \ | | | | 124| 7| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 7] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 7| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 7, False: 0] | | | | ------------------ | | | | 128| 7| YYERROR; \ | | | | ------------------ | | | | | | 1313| 7|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 7| } \ | | | | 130| 7| } | | ------------------ | | 138| 0| } ------------------ 4035| 1.28k| yyscanner, "<", (yyvsp[-2].expression), (yyvsp[0].expression))); 4036| | 4037| 1.27k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 1.27k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4038| 1.27k| (yyval.expression).required_strings.count = 0; 4039| 1.27k| } 4040| 0|#line 4041 "libyara/grammar.c" 4041| 0| break; 4042| | 4043| 1.05k| case 106: /* expression: primary_expression ">" primary_expression */ ------------------ | Branch (4043:3): [True: 1.05k, False: 633k] ------------------ 4044| 1.05k|#line 2015 "libyara/grammar.y" 4045| 1.05k| { 4046| 1.05k| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 1.05k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 2.11k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.10k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 41, False: 1.01k] | | | Branch (135:31): [True: 41, False: 0] | | ------------------ | | 136| 1.05k| { \ | | 137| 41| fail_with_error(e); \ | | ------------------ | | | | 120| 41| { \ | | | | 121| 41| compiler->last_error = e; \ | | | | 122| 41| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 41|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 41| switch (e) \ | | | | 124| 41| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 41] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 41| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 41, False: 0] | | | | ------------------ | | | | 128| 41| YYERROR; \ | | | | ------------------ | | | | | | 1313| 41|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 41| } \ | | | | 130| 41| } | | ------------------ | | 138| 0| } ------------------ 4047| 1.05k| yyscanner, ">", (yyvsp[-2].expression), (yyvsp[0].expression))); 4048| | 4049| 1.01k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 1.01k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4050| 1.01k| (yyval.expression).required_strings.count = 0; 4051| 1.01k| } 4052| 0|#line 4053 "libyara/grammar.c" 4053| 0| break; 4054| | 4055| 3.77k| case 107: /* expression: primary_expression "<=" primary_expression */ ------------------ | Branch (4055:3): [True: 3.77k, False: 630k] ------------------ 4056| 3.77k|#line 2023 "libyara/grammar.y" 4057| 3.77k| { 4058| 3.77k| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 3.77k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 7.55k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 3.77k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 3.77k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 3.77k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4059| 3.77k| yyscanner, "<=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4060| | 4061| 3.77k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 3.77k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4062| 3.77k| (yyval.expression).required_strings.count = 0; 4063| 3.77k| } 4064| 0|#line 4065 "libyara/grammar.c" 4065| 0| break; 4066| | 4067| 667| case 108: /* expression: primary_expression ">=" primary_expression */ ------------------ | Branch (4067:3): [True: 667, False: 633k] ------------------ 4068| 667|#line 2031 "libyara/grammar.y" 4069| 667| { 4070| 667| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 667| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.33k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 674|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 7, False: 660] | | | Branch (135:31): [True: 7, False: 0] | | ------------------ | | 136| 667| { \ | | 137| 7| fail_with_error(e); \ | | ------------------ | | | | 120| 7| { \ | | | | 121| 7| compiler->last_error = e; \ | | | | 122| 7| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 7|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 7| switch (e) \ | | | | 124| 7| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 7] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 7| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 7, False: 0] | | | | ------------------ | | | | 128| 7| YYERROR; \ | | | | ------------------ | | | | | | 1313| 7|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 7| } \ | | | | 130| 7| } | | ------------------ | | 138| 0| } ------------------ 4071| 667| yyscanner, ">=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4072| | 4073| 660| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 660|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4074| 660| (yyval.expression).required_strings.count = 0; 4075| 660| } 4076| 0|#line 4077 "libyara/grammar.c" 4077| 0| break; 4078| | 4079| 798| case 109: /* expression: primary_expression "==" primary_expression */ ------------------ | Branch (4079:3): [True: 798, False: 633k] ------------------ 4080| 798|#line 2039 "libyara/grammar.y" 4081| 798| { 4082| 798| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 798| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.59k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 798|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 798] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 798| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4083| 798| yyscanner, "==", (yyvsp[-2].expression), (yyvsp[0].expression))); 4084| | 4085| 798| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 798|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4086| 798| (yyval.expression).required_strings.count = 0; 4087| 798| } 4088| 0|#line 4089 "libyara/grammar.c" 4089| 0| break; 4090| | 4091| 681| case 110: /* expression: primary_expression "!=" primary_expression */ ------------------ | Branch (4091:3): [True: 681, False: 633k] ------------------ 4092| 681|#line 2047 "libyara/grammar.y" 4093| 681| { 4094| 681| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 681| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.36k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 692|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 11, False: 670] | | | Branch (135:31): [True: 11, False: 0] | | ------------------ | | 136| 681| { \ | | 137| 11| fail_with_error(e); \ | | ------------------ | | | | 120| 11| { \ | | | | 121| 11| compiler->last_error = e; \ | | | | 122| 11| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 11|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 11| switch (e) \ | | | | 124| 11| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 11] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 11| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 11, False: 0] | | | | ------------------ | | | | 128| 11| YYERROR; \ | | | | ------------------ | | | | | | 1313| 11|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 11| } \ | | | | 130| 11| } | | ------------------ | | 138| 0| } ------------------ 4095| 681| yyscanner, "!=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4096| | 4097| 670| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 670|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4098| 670| (yyval.expression).required_strings.count = 0; 4099| 670| } 4100| 0|#line 4101 "libyara/grammar.c" 4101| 0| break; 4102| | 4103| 15.1k| case 111: /* expression: primary_expression */ ------------------ | Branch (4103:3): [True: 15.1k, False: 619k] ------------------ 4104| 15.1k|#line 2055 "libyara/grammar.y" 4105| 15.1k| { 4106| 15.1k| (yyval.expression) = (yyvsp[0].expression); 4107| 15.1k| } 4108| 15.1k|#line 4109 "libyara/grammar.c" 4109| 15.1k| break; 4110| | 4111| 502| case 112: /* expression: '(' expression ')' */ ------------------ | Branch (4111:3): [True: 502, False: 633k] ------------------ 4112| 502|#line 2059 "libyara/grammar.y" 4113| 502| { 4114| 502| (yyval.expression) = (yyvsp[-1].expression); 4115| 502| } 4116| 502|#line 4117 "libyara/grammar.c" 4117| 502| break; 4118| | 4119| 699| case 113: /* for_iteration: for_variables "" iterator */ ------------------ | Branch (4119:3): [True: 699, False: 633k] ------------------ 4120| 699|#line 2066 "libyara/grammar.y" 4121| 699| { (yyval.integer) = FOR_ITERATION_ITERATOR; } ------------------ | | 112| 699|#define FOR_ITERATION_ITERATOR 1 ------------------ 4122| 699|#line 4123 "libyara/grammar.c" 4123| 699| break; 4124| | 4125| 220| case 114: /* for_iteration: "" string_iterator */ ------------------ | Branch (4125:3): [True: 220, False: 633k] ------------------ 4126| 220|#line 2068 "libyara/grammar.y" 4127| 220| { 4128| 220| int var_frame; 4129| 220| int result = ERROR_SUCCESS; ------------------ | | 40| 220|#define ERROR_SUCCESS 0 ------------------ 4130| | 4131| 220| if (compiler->loop_for_of_var_index != -1) ------------------ | Branch (4131:13): [True: 29, False: 191] ------------------ 4132| 29| result = ERROR_NESTED_FOR_OF_LOOP; ------------------ | | 79| 29|#define ERROR_NESTED_FOR_OF_LOOP 32 ------------------ 4133| | 4134| 220| fail_if_error(result); ------------------ | | 135| 220| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 440|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 249|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 29, False: 191] | | | Branch (135:31): [True: 29, False: 0] | | ------------------ | | 136| 220| { \ | | 137| 29| fail_with_error(e); \ | | ------------------ | | | | 120| 29| { \ | | | | 121| 29| compiler->last_error = e; \ | | | | 122| 29| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 29|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 29| switch (e) \ | | | | 124| 29| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 29] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 29| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 29, False: 0] | | | | ------------------ | | | | 128| 29| YYERROR; \ | | | | ------------------ | | | | | | 1313| 29|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 29| } \ | | | | 130| 29| } | | ------------------ | | 138| 0| } ------------------ 4135| | 4136| | // Simulate that we have 1 variable with string loops 4137| 191| compiler->loop[compiler->loop_index].vars_count = 1; 4138| | 4139| | // Set where we can find our string in case $ is in 4140| | // the body of the loop 4141| 191| var_frame = _yr_compiler_get_var_frame(compiler); 4142| 191| compiler->loop_for_of_var_index = var_frame + 4143| 191| compiler->loop[compiler->loop_index].vars_internal_count; 4144| | 4145| 191| (yyval.integer) = FOR_ITERATION_STRING_SET; ------------------ | | 113| 191|#define FOR_ITERATION_STRING_SET 2 ------------------ 4146| 191| } 4147| 0|#line 4148 "libyara/grammar.c" 4148| 0| break; 4149| | 4150| 1.73k| case 115: /* for_variables: "identifier" */ ------------------ | Branch (4150:3): [True: 1.73k, False: 632k] ------------------ 4151| 1.73k|#line 2093 "libyara/grammar.y" 4152| 1.73k| { 4153| 1.73k| int result = ERROR_SUCCESS; ------------------ | | 40| 1.73k|#define ERROR_SUCCESS 0 ------------------ 4154| | 4155| 1.73k| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4156| | 4157| 1.73k| if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4157:13): [True: 15, False: 1.72k] ------------------ 4158| 15| { 4159| 15| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 306| 15| strlcpy( \ | | 307| 15| compiler->last_error_extra_info, \ | | 308| 15| info, \ | | 309| 15| sizeof(compiler->last_error_extra_info)); ------------------ 4160| 15| yr_free((yyvsp[0].c_string)); 4161| | 4162| 15| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 15|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4163| 15| } 4164| | 4165| 1.73k| fail_if_error(result); ------------------ | | 135| 1.73k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.47k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.75k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 15, False: 1.72k] | | | Branch (135:31): [True: 15, False: 0] | | ------------------ | | 136| 1.73k| { \ | | 137| 15| fail_with_error(e); \ | | ------------------ | | | | 120| 15| { \ | | | | 121| 15| compiler->last_error = e; \ | | | | 122| 15| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 15|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 15| switch (e) \ | | | | 124| 15| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 15] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 15| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 15, False: 0] | | | | ------------------ | | | | 128| 15| YYERROR; \ | | | | ------------------ | | | | | | 1313| 15|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 15| } \ | | | | 130| 15| } | | ------------------ | | 138| 0| } ------------------ 4166| | 4167| 1.72k| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4168| | 4169| 1.72k| assert(loop_ctx->vars_count <= YR_MAX_LOOP_VARS); 4170| 1.72k| } 4171| 1.72k|#line 4172 "libyara/grammar.c" 4172| 1.72k| break; 4173| | 4174| 1.72k| case 116: /* for_variables: for_variables ',' "identifier" */ ------------------ | Branch (4174:3): [True: 358, False: 633k] ------------------ 4175| 358|#line 2113 "libyara/grammar.y" 4176| 358| { 4177| 358| int result = ERROR_SUCCESS; ------------------ | | 40| 358|#define ERROR_SUCCESS 0 ------------------ 4178| | 4179| 358| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4180| | 4181| 358| if (loop_ctx->vars_count == YR_MAX_LOOP_VARS) ------------------ | | 102| 358|#define YR_MAX_LOOP_VARS 2 ------------------ | Branch (4181:13): [True: 0, False: 358] ------------------ 4182| 0| { 4183| 0| yr_compiler_set_error_extra_info(compiler, "too many loop variables"); ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4184| 0| yr_free((yyvsp[0].c_string)); 4185| | 4186| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4187| 0| } 4188| 358| else if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4188:18): [True: 8, False: 350] ------------------ 4189| 8| { 4190| 8| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 306| 8| strlcpy( \ | | 307| 8| compiler->last_error_extra_info, \ | | 308| 8| info, \ | | 309| 8| sizeof(compiler->last_error_extra_info)); ------------------ 4191| 8| yr_free((yyvsp[0].c_string)); 4192| | 4193| 8| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 8|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4194| 8| } 4195| | 4196| 358| fail_if_error(result); ------------------ | | 135| 358| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 716|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 366|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 8, False: 350] | | | Branch (135:31): [True: 8, False: 0] | | ------------------ | | 136| 358| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 8| switch (e) \ | | | | 124| 8| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 8] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1313| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 4197| | 4198| 350| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4199| 350| } 4200| 0|#line 4201 "libyara/grammar.c" 4201| 0| break; 4202| | 4203| 217| case 117: /* iterator: identifier */ ------------------ | Branch (4203:3): [True: 217, False: 633k] ------------------ 4204| 217|#line 2141 "libyara/grammar.y" 4205| 217| { 4206| 217| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4207| | 4208| | // Initially we assume that the identifier is from a non-iterable type, 4209| | // this will change later if it's iterable. 4210| 217| int result = ERROR_WRONG_TYPE; ------------------ | | 69| 217|#define ERROR_WRONG_TYPE 24 ------------------ 4211| | 4212| 217| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 217|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4212:13): [True: 216, False: 1] ------------------ 4213| 216| { 4214| 216| switch((yyvsp[0].expression).value.object->type) ------------------ | Branch (4214:18): [True: 1, False: 215] ------------------ 4215| 216| { 4216| 13| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 13|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (4216:13): [True: 13, False: 203] ------------------ 4217| | // If iterating an array the loop must define a single variable 4218| | // that will hold the current item. If a different number of 4219| | // variables were defined that's an error. 4220| 13| if (loop_ctx->vars_count == 1) ------------------ | Branch (4220:19): [True: 6, False: 7] ------------------ 4221| 6| { 4222| 6| loop_ctx->vars[0].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 6|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4223| 6| loop_ctx->vars[0].value.object = \ 4224| 6| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 910| 6|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4225| | 4226| 6| result = yr_parser_emit(yyscanner, OP_ITER_START_ARRAY, NULL); ------------------ | | 102| 6|#define OP_ITER_START_ARRAY 54 ------------------ 4227| 6| } 4228| 7| else 4229| 7| { 4230| 7| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 7| snprintf( \ | | 313| 7| compiler->last_error_extra_info, \ | | 314| 7| sizeof(compiler->last_error_extra_info), \ | | 315| 7| fmt, \ | | 316| 14| __VA_ARGS__); | | ------------------ | | | Branch (316:7): [True: 0, False: 7] | | ------------------ ------------------ 4231| 7| compiler, 4232| 7| "iterator for \"%s\" yields a single item on each iteration" 4233| 7| ", but the loop expects %d", 4234| 7| expression_identifier((yyvsp[0].expression)), 4235| 7| loop_ctx->vars_count); 4236| | 4237| 7| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 7|#define ERROR_SYNTAX_ERROR 11 ------------------ 4238| 7| } 4239| 13| break; 4240| | 4241| 202| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 202|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (4241:13): [True: 202, False: 14] ------------------ 4242| | // If iterating a dictionary the loop must define exactly two 4243| | // variables, one for the key and another for the value . If a 4244| | // different number of variables were defined that's an error. 4245| 202| if (loop_ctx->vars_count == 2) ------------------ | Branch (4245:19): [True: 198, False: 4] ------------------ 4246| 198| { 4247| 198| loop_ctx->vars[0].type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 198|#define EXPRESSION_TYPE_STRING 4 ------------------ 4248| 198| loop_ctx->vars[0].value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 198| (YR_ARENA_REF) \ | | 44| 198| { \ | | 45| 198| UINT32_MAX, UINT32_MAX \ | | 46| 198| } ------------------ 4249| 198| loop_ctx->vars[1].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 198|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4250| 198| loop_ctx->vars[1].value.object = \ 4251| 198| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 910| 198|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4252| | 4253| 198| result = yr_parser_emit(yyscanner, OP_ITER_START_DICT, NULL); ------------------ | | 103| 198|#define OP_ITER_START_DICT 55 ------------------ 4254| 198| } 4255| 4| else 4256| 4| { 4257| 4| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 4| snprintf( \ | | 313| 4| compiler->last_error_extra_info, \ | | 314| 4| sizeof(compiler->last_error_extra_info), \ | | 315| 4| fmt, \ | | 316| 8| __VA_ARGS__); | | ------------------ | | | Branch (316:7): [True: 0, False: 4] | | ------------------ ------------------ 4258| 4| compiler, 4259| 4| "iterator for \"%s\" yields a key,value pair item on each iteration", 4260| 4| expression_identifier((yyvsp[0].expression))); 4261| | 4262| 4| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 4|#define ERROR_SYNTAX_ERROR 11 ------------------ 4263| 4| } 4264| 202| break; 4265| 216| } 4266| 216| } 4267| | 4268| 217| if (result == ERROR_WRONG_TYPE) ------------------ | | 69| 217|#define ERROR_WRONG_TYPE 24 ------------------ | Branch (4268:13): [True: 2, False: 215] ------------------ 4269| 2| { 4270| 2| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 2| snprintf( \ | | 313| 2| compiler->last_error_extra_info, \ | | 314| 2| sizeof(compiler->last_error_extra_info), \ | | 315| 2| fmt, \ | | 316| 4| __VA_ARGS__); | | ------------------ | | | Branch (316:7): [True: 2, False: 0] | | ------------------ ------------------ 4271| 2| compiler, 4272| 2| "identifier \"%s\" is not iterable", 4273| 2| expression_identifier((yyvsp[0].expression))); 4274| 2| } 4275| | 4276| 217| fail_if_error(result); ------------------ | | 135| 217| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 434|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 230|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 13, False: 204] | | | Branch (135:31): [True: 13, False: 0] | | ------------------ | | 136| 217| { \ | | 137| 13| fail_with_error(e); \ | | ------------------ | | | | 120| 13| { \ | | | | 121| 13| compiler->last_error = e; \ | | | | 122| 13| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 13|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 13| switch (e) \ | | | | 124| 13| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 13] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 13| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 13, False: 0] | | | | ------------------ | | | | 128| 13| YYERROR; \ | | | | ------------------ | | | | | | 1313| 13|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 13| } \ | | | | 130| 13| } | | ------------------ | | 138| 0| } ------------------ 4277| 204| } 4278| 0|#line 4279 "libyara/grammar.c" 4279| 0| break; 4280| | 4281| 527| case 118: /* iterator: set */ ------------------ | Branch (4281:3): [True: 527, False: 633k] ------------------ 4282| 527|#line 2215 "libyara/grammar.y" 4283| 527| { 4284| 527| int result = ERROR_SUCCESS; ------------------ | | 40| 527|#define ERROR_SUCCESS 0 ------------------ 4285| | 4286| 527| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4287| | 4288| 527| if (loop_ctx->vars_count == 1) ------------------ | Branch (4288:13): [True: 495, False: 32] ------------------ 4289| 495| { 4290| 495| loop_ctx->vars[0].type = (yyvsp[0].enumeration).type; 4291| | 4292| 495| if ((yyvsp[0].enumeration).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 495|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4292:15): [True: 13, False: 482] ------------------ 4293| 13| loop_ctx->vars[0].value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 13| (YR_ARENA_REF) \ | | 44| 13| { \ | | 45| 13| UINT32_MAX, UINT32_MAX \ | | 46| 13| } ------------------ 4294| 482| else 4295| 482| loop_ctx->vars[0].value.integer = YR_UNDEFINED; ------------------ | | 38| 482|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4296| 495| } 4297| 32| else 4298| 32| { 4299| 32| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 32| snprintf( \ | | 313| 32| compiler->last_error_extra_info, \ | | 314| 32| sizeof(compiler->last_error_extra_info), \ | | 315| 32| fmt, \ | | 316| 32| __VA_ARGS__); ------------------ 4300| 32| compiler, 4301| 32| "iterator yields one value on each iteration " 4302| 32| ", but the loop expects %d", 4303| 32| loop_ctx->vars_count); 4304| | 4305| 32| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 32|#define ERROR_SYNTAX_ERROR 11 ------------------ 4306| 32| } 4307| | 4308| 527| fail_if_error(result); ------------------ | | 135| 527| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.05k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 559|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 32, False: 495] | | | Branch (135:31): [True: 32, False: 0] | | ------------------ | | 136| 527| { \ | | 137| 32| fail_with_error(e); \ | | ------------------ | | | | 120| 32| { \ | | | | 121| 32| compiler->last_error = e; \ | | | | 122| 32| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 32|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 32| switch (e) \ | | | | 124| 32| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 32] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 32| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 32, False: 0] | | | | ------------------ | | | | 128| 32| YYERROR; \ | | | | ------------------ | | | | | | 1313| 32|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 32| } \ | | | | 130| 32| } | | ------------------ | | 138| 0| } ------------------ 4309| 495| } 4310| 0|#line 4311 "libyara/grammar.c" 4311| 0| break; 4312| | 4313| 501| case 119: /* set: '(' enumeration ')' */ ------------------ | Branch (4313:3): [True: 501, False: 633k] ------------------ 4314| 501|#line 2247 "libyara/grammar.y" 4315| 501| { 4316| | // $2.count contains the number of items in the enumeration 4317| 501| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[-1].enumeration).count)); ------------------ | | 135| 501| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.00k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 501|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 501] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 501| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4318| | 4319| 501| if ((yyvsp[-1].enumeration).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 501|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4319:13): [True: 477, False: 24] ------------------ 4320| 477| { 4321| 477| fail_if_error(yr_parser_emit( ------------------ | | 135| 477| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 954|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 477|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 477] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 477| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4322| 477| yyscanner, OP_ITER_START_INT_ENUM, NULL)); 4323| 477| } 4324| 24| else 4325| 24| { 4326| 24| fail_if_error(yr_parser_emit( ------------------ | | 135| 24| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 48|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 24|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 24] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 24| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4327| 24| yyscanner, OP_ITER_START_TEXT_STRING_SET, NULL)); 4328| 24| } 4329| | 4330| 501| (yyval.enumeration).type = (yyvsp[-1].enumeration).type; 4331| 501| } 4332| 0|#line 4333 "libyara/grammar.c" 4333| 0| break; 4334| | 4335| 26| case 120: /* set: range */ ------------------ | Branch (4335:3): [True: 26, False: 634k] ------------------ 4336| 26|#line 2265 "libyara/grammar.y" 4337| 26| { 4338| 26| fail_if_error(yr_parser_emit( ------------------ | | 135| 26| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 52|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 26|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 26] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 26| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4339| 26| yyscanner, OP_ITER_START_INT_RANGE, NULL)); 4340| | 4341| 26| (yyval.enumeration).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 26|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4342| 26| } 4343| 0|#line 4344 "libyara/grammar.c" 4344| 0| break; 4345| | 4346| 337| case 121: /* range: '(' primary_expression ".." primary_expression ')' */ ------------------ | Branch (4346:3): [True: 337, False: 633k] ------------------ 4347| 337|#line 2276 "libyara/grammar.y" 4348| 337| { 4349| 337| int result = ERROR_SUCCESS; ------------------ | | 40| 337|#define ERROR_SUCCESS 0 ------------------ 4350| | 4351| 337| if ((yyvsp[-3].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 337|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4351:13): [True: 30, False: 307] ------------------ 4352| 30| { 4353| 30| yr_compiler_set_error_extra_info( ------------------ | | 306| 30| strlcpy( \ | | 307| 30| compiler->last_error_extra_info, \ | | 308| 30| info, \ | | 309| 30| sizeof(compiler->last_error_extra_info)); ------------------ 4354| 30| compiler, "wrong type for range's lower bound"); 4355| 30| result = ERROR_WRONG_TYPE; ------------------ | | 69| 30|#define ERROR_WRONG_TYPE 24 ------------------ 4356| 30| } 4357| | 4358| 337| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 337|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4358:13): [True: 0, False: 337] ------------------ 4359| 0| { 4360| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4361| 0| compiler, "wrong type for range's upper bound"); 4362| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4363| 0| } 4364| | 4365| | // If we can statically determine lower and upper bounds, ensure 4366| | // lower < upper. Check for upper bound here because some things (like 4367| | // string count) are EXPRESSION_TYPE_INTEGER. 4368| 337| if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 674|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 316|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (4368:13): [True: 316, False: 21] | Branch (4368:69): [True: 316, False: 0] ------------------ 4369| 316| { 4370| 316| if ((yyvsp[-3].expression).value.integer > (yyvsp[-1].expression).value.integer) ------------------ | Branch (4370:15): [True: 12, False: 304] ------------------ 4371| 12| { 4372| 12| yr_compiler_set_error_extra_info( ------------------ | | 306| 12| strlcpy( \ | | 307| 12| compiler->last_error_extra_info, \ | | 308| 12| info, \ | | 309| 12| sizeof(compiler->last_error_extra_info)); ------------------ 4373| 12| compiler, "range lower bound must be less than upper bound"); 4374| 12| result = ERROR_INVALID_VALUE; ------------------ | | 111| 12|#define ERROR_INVALID_VALUE 64 ------------------ 4375| 12| } 4376| 304| else if ((yyvsp[-3].expression).value.integer < 0) ------------------ | Branch (4376:20): [True: 16, False: 288] ------------------ 4377| 16| { 4378| 16| yr_compiler_set_error_extra_info( ------------------ | | 306| 16| strlcpy( \ | | 307| 16| compiler->last_error_extra_info, \ | | 308| 16| info, \ | | 309| 16| sizeof(compiler->last_error_extra_info)); ------------------ 4379| 16| compiler, "range lower bound can not be negative"); 4380| 16| result = ERROR_INVALID_VALUE; ------------------ | | 111| 16|#define ERROR_INVALID_VALUE 64 ------------------ 4381| 16| } 4382| 316| } 4383| | 4384| 337| fail_if_error(result); ------------------ | | 135| 337| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 674|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 378|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 41, False: 296] | | | Branch (135:31): [True: 41, False: 0] | | ------------------ | | 136| 337| { \ | | 137| 41| fail_with_error(e); \ | | ------------------ | | | | 120| 41| { \ | | | | 121| 41| compiler->last_error = e; \ | | | | 122| 41| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 41|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 41| switch (e) \ | | | | 124| 41| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 41] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 41| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 41, False: 0] | | | | ------------------ | | | | 128| 41| YYERROR; \ | | | | ------------------ | | | | | | 1313| 41|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 41| } \ | | | | 130| 41| } | | ------------------ | | 138| 0| } ------------------ 4385| 296| } 4386| 0|#line 4387 "libyara/grammar.c" 4387| 0| break; 4388| | 4389| 634| case 122: /* enumeration: primary_expression */ ------------------ | Branch (4389:3): [True: 634, False: 633k] ------------------ 4390| 634|#line 2319 "libyara/grammar.y" 4391| 634| { 4392| 634| int result = ERROR_SUCCESS; ------------------ | | 40| 634|#define ERROR_SUCCESS 0 ------------------ 4393| | 4394| 634| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 47| 1.26k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 48|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4394:13): [True: 48, False: 586] | Branch (4394:70): [True: 16, False: 32] ------------------ 4395| 16| { 4396| 16| yr_compiler_set_error_extra_info( ------------------ | | 306| 16| strlcpy( \ | | 307| 16| compiler->last_error_extra_info, \ | | 308| 16| info, \ | | 309| 16| sizeof(compiler->last_error_extra_info)); ------------------ 4397| 16| compiler, "wrong type for enumeration item"); 4398| 16| result = ERROR_WRONG_TYPE; ------------------ | | 69| 16|#define ERROR_WRONG_TYPE 24 ------------------ 4399| 16| } 4400| | 4401| 634| fail_if_error(result); ------------------ | | 135| 634| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.26k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 650|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 16, False: 618] | | | Branch (135:31): [True: 16, False: 0] | | ------------------ | | 136| 634| { \ | | 137| 16| fail_with_error(e); \ | | ------------------ | | | | 120| 16| { \ | | | | 121| 16| compiler->last_error = e; \ | | | | 122| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 16| switch (e) \ | | | | 124| 16| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 16] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 16| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 16, False: 0] | | | | ------------------ | | | | 128| 16| YYERROR; \ | | | | ------------------ | | | | | | 1313| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 16| } \ | | | | 130| 16| } | | ------------------ | | 138| 0| } ------------------ 4402| | 4403| 618| (yyval.enumeration).type = (yyvsp[0].expression).type; 4404| 618| (yyval.enumeration).count = 1; 4405| 618| } 4406| 0|#line 4407 "libyara/grammar.c" 4407| 0| break; 4408| | 4409| 131| case 123: /* enumeration: enumeration ',' primary_expression */ ------------------ | Branch (4409:3): [True: 131, False: 634k] ------------------ 4410| 131|#line 2335 "libyara/grammar.y" 4411| 131| { 4412| 131| int result = ERROR_SUCCESS; ------------------ | | 40| 131|#define ERROR_SUCCESS 0 ------------------ 4413| | 4414| 131| if ((yyvsp[0].expression).type != (yyvsp[-2].enumeration).type) ------------------ | Branch (4414:13): [True: 0, False: 131] ------------------ 4415| 0| { 4416| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4417| 0| compiler, "enumerations must be all the same type"); 4418| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4419| 0| } 4420| | 4421| 131| fail_if_error(result); ------------------ | | 135| 131| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 262|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 131|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 131] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 131| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4422| | 4423| 131| (yyval.enumeration).type = (yyvsp[-2].enumeration).type; 4424| 131| (yyval.enumeration).count = (yyvsp[-2].enumeration).count + 1; 4425| 131| } 4426| 0|#line 4427 "libyara/grammar.c" 4427| 0| break; 4428| | 4429| 220| case 124: /* string_iterator: string_set */ ------------------ | Branch (4429:3): [True: 220, False: 633k] ------------------ 4430| 220|#line 2355 "libyara/grammar.y" 4431| 220| { 4432| 220| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].integer))); ------------------ | | 135| 220| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 440|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 220|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 220] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 220| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4433| 220| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_START_STRING_SET, ------------------ | | 135| 220| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 440|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 220|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 220] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 220| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4434| 220| NULL)); 4435| 220| } 4436| 0|#line 4437 "libyara/grammar.c" 4437| 0| break; 4438| | 4439| 9.97k| case 125: /* $@10: %empty */ ------------------ | Branch (4439:3): [True: 9.97k, False: 624k] ------------------ 4440| 9.97k|#line 2364 "libyara/grammar.y" 4441| 9.97k| { 4442| | // Push end-of-list marker 4443| 9.97k| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 9.97k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4444| 9.97k| } 4445| 9.97k|#line 4446 "libyara/grammar.c" 4446| 9.97k| break; 4447| | 4448| 9.94k| case 126: /* string_set: '(' $@10 string_enumeration ')' */ ------------------ | Branch (4448:3): [True: 9.94k, False: 624k] ------------------ 4449| 9.94k|#line 2369 "libyara/grammar.y" 4450| 9.94k| { 4451| 9.94k| (yyval.integer) = (yyvsp[-1].integer); 4452| 9.94k| } 4453| 9.94k|#line 4454 "libyara/grammar.c" 4454| 9.94k| break; 4455| | 4456| 29| case 127: /* string_set: "" */ ------------------ | Branch (4456:3): [True: 29, False: 634k] ------------------ 4457| 29|#line 2373 "libyara/grammar.y" 4458| 29| { 4459| 29| fail_if_error(yr_parser_emit_push_const(yyscanner, YR_UNDEFINED)); ------------------ | | 135| 29| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 58|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 29|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 29] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 29| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4460| | 4461| 29| int count = 0; 4462| 29| fail_if_error(yr_parser_emit_pushes_for_strings( ------------------ | | 135| 29| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 58|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 29|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 29] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 29| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4463| 29| yyscanner, "$*", &count)); 4464| | 4465| 29| (yyval.integer) = count; 4466| 29| } 4467| 0|#line 4468 "libyara/grammar.c" 4468| 0| break; 4469| | 4470| 9.95k| case 128: /* string_enumeration: string_enumeration_item */ ------------------ | Branch (4470:3): [True: 9.95k, False: 624k] ------------------ 4471| 9.95k|#line 2386 "libyara/grammar.y" 4472| 9.95k| { (yyval.integer) = (yyvsp[0].integer); } 4473| 9.95k|#line 4474 "libyara/grammar.c" 4474| 9.95k| break; 4475| | 4476| 1.35k| case 129: /* string_enumeration: string_enumeration ',' string_enumeration_item */ ------------------ | Branch (4476:3): [True: 1.35k, False: 632k] ------------------ 4477| 1.35k|#line 2387 "libyara/grammar.y" 4478| 1.35k| { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); } 4479| 1.35k|#line 4480 "libyara/grammar.c" 4480| 1.35k| break; 4481| | 4482| 10.9k| case 130: /* string_enumeration_item: "string identifier" */ ------------------ | Branch (4482:3): [True: 10.9k, False: 623k] ------------------ 4483| 10.9k|#line 2393 "libyara/grammar.y" 4484| 10.9k| { 4485| 10.9k| int count = 0; 4486| 10.9k| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &count); 4487| 10.9k| yr_free((yyvsp[0].c_string)); 4488| | 4489| 10.9k| fail_if_error(result); ------------------ | | 135| 10.9k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 21.9k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 10.9k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 17, False: 10.9k] | | | Branch (135:31): [True: 17, False: 0] | | ------------------ | | 136| 10.9k| { \ | | 137| 17| fail_with_error(e); \ | | ------------------ | | | | 120| 17| { \ | | | | 121| 17| compiler->last_error = e; \ | | | | 122| 17| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 17|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 17| switch (e) \ | | | | 124| 17| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 17] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 17| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 17, False: 0] | | | | ------------------ | | | | 128| 17| YYERROR; \ | | | | ------------------ | | | | | | 1313| 17|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 17| } \ | | | | 130| 17| } | | ------------------ | | 138| 0| } ------------------ 4490| | 4491| 10.9k| (yyval.integer) = count; 4492| 10.9k| } 4493| 0|#line 4494 "libyara/grammar.c" 4494| 0| break; 4495| | 4496| 371| case 131: /* string_enumeration_item: "string identifier with wildcard" */ ------------------ | Branch (4496:3): [True: 371, False: 633k] ------------------ 4497| 371|#line 2403 "libyara/grammar.y" 4498| 371| { 4499| 371| int count = 0; 4500| 371| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &count); 4501| 371| yr_free((yyvsp[0].c_string)); 4502| | 4503| 371| fail_if_error(result); ------------------ | | 135| 371| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 742|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 372|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 1, False: 370] | | | Branch (135:31): [True: 1, False: 0] | | ------------------ | | 136| 371| { \ | | 137| 1| fail_with_error(e); \ | | ------------------ | | | | 120| 1| { \ | | | | 121| 1| compiler->last_error = e; \ | | | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 1|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 1| switch (e) \ | | | | 124| 1| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 1] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 1| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 1, False: 0] | | | | ------------------ | | | | 128| 1| YYERROR; \ | | | | ------------------ | | | | | | 1313| 1|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 1| } \ | | | | 130| 1| } | | ------------------ | | 138| 0| } ------------------ 4504| | 4505| 370| (yyval.integer) = count; 4506| 370| } 4507| 0|#line 4508 "libyara/grammar.c" 4508| 0| break; 4509| | 4510| 227| case 132: /* $@11: %empty */ ------------------ | Branch (4510:3): [True: 227, False: 633k] ------------------ 4511| 227|#line 2417 "libyara/grammar.y" 4512| 227| { 4513| | // Push end-of-list marker 4514| 227| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 227|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4515| 227| } 4516| 227|#line 4517 "libyara/grammar.c" 4517| 227| break; 4518| | 4519| 86| case 133: /* rule_set: '(' $@11 rule_enumeration ')' */ ------------------ | Branch (4519:3): [True: 86, False: 634k] ------------------ 4520| 86|#line 2422 "libyara/grammar.y" 4521| 86| { 4522| 86| (yyval.integer) = (yyvsp[-1].integer); 4523| 86| } 4524| 86|#line 4525 "libyara/grammar.c" 4525| 86| break; 4526| | 4527| 104| case 134: /* rule_enumeration: rule_enumeration_item */ ------------------ | Branch (4527:3): [True: 104, False: 634k] ------------------ 4528| 104|#line 2429 "libyara/grammar.y" 4529| 104| { (yyval.integer) = (yyvsp[0].integer); } 4530| 104|#line 4531 "libyara/grammar.c" 4531| 104| break; 4532| | 4533| 1.07k| case 135: /* rule_enumeration: rule_enumeration ',' rule_enumeration_item */ ------------------ | Branch (4533:3): [True: 1.07k, False: 633k] ------------------ 4534| 1.07k|#line 2430 "libyara/grammar.y" 4535| 1.07k| { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); } 4536| 1.07k|#line 4537 "libyara/grammar.c" 4537| 1.07k| break; 4538| | 4539| 144| case 136: /* rule_enumeration_item: "identifier" */ ------------------ | Branch (4539:3): [True: 144, False: 634k] ------------------ 4540| 144|#line 2436 "libyara/grammar.y" 4541| 144| { 4542| 144| int result = ERROR_SUCCESS; ------------------ | | 40| 144|#define ERROR_SUCCESS 0 ------------------ 4543| | 4544| 144| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4545| 144| compiler->arena, 4546| 144| YR_NAMESPACES_TABLE, ------------------ | | 57| 144|#define YR_NAMESPACES_TABLE 0 ------------------ 4547| 144| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4548| | 4549| 144| uint32_t rule_idx = yr_hash_table_lookup_uint32( 4550| 144| compiler->rules_table, (yyvsp[0].c_string), ns->name); 4551| | 4552| 144| if (rule_idx != UINT32_MAX) ------------------ | Branch (4552:13): [True: 96, False: 48] ------------------ 4553| 96| { 4554| 96| result = yr_parser_emit_with_arg( 4555| 96| yyscanner, 4556| 96| OP_PUSH_RULE, ------------------ | | 75| 96|#define OP_PUSH_RULE 27 ------------------ 4557| 96| rule_idx, 4558| 96| NULL, 4559| 96| NULL); 4560| 96| } 4561| 48| else 4562| 48| { 4563| 48| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 306| 48| strlcpy( \ | | 307| 48| compiler->last_error_extra_info, \ | | 308| 48| info, \ | | 309| 48| sizeof(compiler->last_error_extra_info)); ------------------ 4564| 48| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 48|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 4565| 48| } 4566| | 4567| 144| yr_free((yyvsp[0].c_string)); 4568| | 4569| 144| fail_if_error(result); ------------------ | | 135| 144| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 288|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 192|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 48, False: 96] | | | Branch (135:31): [True: 48, False: 0] | | ------------------ | | 136| 144| { \ | | 137| 48| fail_with_error(e); \ | | ------------------ | | | | 120| 48| { \ | | | | 121| 48| compiler->last_error = e; \ | | | | 122| 48| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 48|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 48| switch (e) \ | | | | 124| 48| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 48] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 48| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 48, False: 0] | | | | ------------------ | | | | 128| 48| YYERROR; \ | | | | ------------------ | | | | | | 1313| 48|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 48| } \ | | | | 130| 48| } | | ------------------ | | 138| 0| } ------------------ 4570| | 4571| 96| (yyval.integer) = 1; 4572| 96| } 4573| 0|#line 4574 "libyara/grammar.c" 4574| 0| break; 4575| | 4576| 1.17k| case 137: /* rule_enumeration_item: "identifier" '*' */ ------------------ | Branch (4576:3): [True: 1.17k, False: 633k] ------------------ 4577| 1.17k|#line 2469 "libyara/grammar.y" 4578| 1.17k| { 4579| 1.17k| int count = 0; 4580| 1.17k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4581| 1.17k| compiler->arena, 4582| 1.17k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.17k|#define YR_NAMESPACES_TABLE 0 ------------------ 4583| 1.17k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4584| | 4585| 1.17k| yr_hash_table_add_uint32( 4586| 1.17k| compiler->wildcard_identifiers_table, 4587| 1.17k| (yyvsp[-1].c_string), 4588| 1.17k| ns->name, 4589| 1.17k| 1); 4590| | 4591| 1.17k| int result = yr_parser_emit_pushes_for_rules(yyscanner, (yyvsp[-1].c_string), &count); 4592| 1.17k| yr_free((yyvsp[-1].c_string)); 4593| | 4594| 1.17k| fail_if_error(result); ------------------ | | 135| 1.17k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 2.34k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.25k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 84, False: 1.08k] | | | Branch (135:31): [True: 84, False: 0] | | ------------------ | | 136| 1.17k| { \ | | 137| 84| fail_with_error(e); \ | | ------------------ | | | | 120| 84| { \ | | | | 121| 84| compiler->last_error = e; \ | | | | 122| 84| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 84|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 84| switch (e) \ | | | | 124| 84| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 84] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 84| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 84, False: 0] | | | | ------------------ | | | | 128| 84| YYERROR; \ | | | | ------------------ | | | | | | 1313| 84|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 84| } \ | | | | 130| 84| } | | ------------------ | | 138| 0| } ------------------ 4595| | 4596| 1.08k| (yyval.integer) = count; 4597| 1.08k| } 4598| 0|#line 4599 "libyara/grammar.c" 4599| 0| break; 4600| | 4601| 8.08k| case 138: /* for_expression: primary_expression */ ------------------ | Branch (4601:3): [True: 8.08k, False: 626k] ------------------ 4602| 8.08k|#line 2494 "libyara/grammar.y" 4603| 8.08k| { 4604| 8.08k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 47| 16.1k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 39| 7.66k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 7.66k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4604:13): [True: 7.66k, False: 422] | Branch (4604:70): [True: 7.31k, False: 348] ------------------ 4605| 7.31k| { 4606| 7.31k| if ((yyvsp[0].expression).value.integer == 0) ------------------ | Branch (4606:15): [True: 1.86k, False: 5.45k] ------------------ 4607| 1.86k| { 4608| 1.86k| yywarning(yyscanner, ------------------ | | 50| 1.86k|#define yywarning yara_yywarning ------------------ 4609| 1.86k| "consider using \"none\" keyword, it is less ambiguous."); 4610| 1.86k| } 4611| | 4612| 7.31k| if ((yyvsp[0].expression).value.integer < 0) ------------------ | Branch (4612:15): [True: 1, False: 7.31k] ------------------ 4613| 1| { 4614| 1| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 312| 1| snprintf( \ | | 313| 1| compiler->last_error_extra_info, \ | | 314| 1| sizeof(compiler->last_error_extra_info), \ | | 315| 1| fmt, \ | | 316| 1| __VA_ARGS__); ------------------ 4615| 1| "%" PRId64, (yyvsp[0].expression).value.integer); 4616| | 4617| 1| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 1| { \ | | 121| 1| compiler->last_error = e; \ | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 123| 1| switch (e) \ | | 124| 1| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 1] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 1| default: \ | | ------------------ | | | Branch (127:7): [True: 1, False: 0] | | ------------------ | | 128| 1| YYERROR; \ | | ------------------ | | | | 1313| 1|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 1| } \ | | 130| 1| } ------------------ 4618| 0| } 4619| 7.31k| } 4620| | 4621| 8.08k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 8.08k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (4621:13): [True: 5, False: 8.07k] ------------------ 4622| 5| { 4623| 5| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 312| 5| snprintf( \ | | 313| 5| compiler->last_error_extra_info, \ | | 314| 5| sizeof(compiler->last_error_extra_info), \ | | 315| 5| fmt, \ | | 316| 5| __VA_ARGS__); ------------------ 4624| 5| "%a", (yyvsp[0].expression).value.double_); 4625| | 4626| 5| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 5| { \ | | 121| 5| compiler->last_error = e; \ | | 122| 5| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 5|#define yyerror yara_yyerror | | ------------------ | | 123| 5| switch (e) \ | | 124| 5| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 5] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 5| default: \ | | ------------------ | | | Branch (127:7): [True: 5, False: 0] | | ------------------ | | 128| 5| YYERROR; \ | | ------------------ | | | | 1313| 5|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 5| } \ | | 130| 5| } ------------------ 4627| 0| } 4628| | 4629| 8.07k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 8.07k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4629:13): [True: 14, False: 8.06k] ------------------ 4630| 14| { 4631| 14| SIZED_STRING* ss = yr_arena_ref_to_ptr(compiler->arena, 4632| 14| &(yyvsp[0].expression).value.sized_string_ref); 4633| | // If the expression is an external string variable we need to get 4634| | // it some other way. 4635| 14| if (ss != NULL) ------------------ | Branch (4635:15): [True: 6, False: 8] ------------------ 4636| 6| { 4637| 6| yr_compiler_set_error_extra_info_fmt(compiler, "%s", ss->c_string); ------------------ | | 312| 6| snprintf( \ | | 313| 6| compiler->last_error_extra_info, \ | | 314| 6| sizeof(compiler->last_error_extra_info), \ | | 315| 6| fmt, \ | | 316| 6| __VA_ARGS__); ------------------ 4638| 6| } 4639| 8| else 4640| 8| { 4641| 8| yr_compiler_set_error_extra_info(compiler, ------------------ | | 306| 8| strlcpy( \ | | 307| 8| compiler->last_error_extra_info, \ | | 308| 8| info, \ | | 309| 8| sizeof(compiler->last_error_extra_info)); ------------------ 4642| 8| "string in for_expression is invalid"); 4643| 8| } 4644| | 4645| 14| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 14| { \ | | 121| 14| compiler->last_error = e; \ | | 122| 14| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 14|#define yyerror yara_yyerror | | ------------------ | | 123| 14| switch (e) \ | | 124| 14| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 14] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 14| default: \ | | ------------------ | | | Branch (127:7): [True: 14, False: 0] | | ------------------ | | 128| 14| YYERROR; \ | | ------------------ | | | | 1313| 14|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 14| } \ | | 130| 14| } ------------------ 4646| 0| } 4647| | 4648| 8.06k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_REGEXP) ------------------ | | 49| 8.06k|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (4648:13): [True: 12, False: 8.05k] ------------------ 4649| 12| { 4650| 12| yr_compiler_set_error_extra_info(compiler, ------------------ | | 306| 12| strlcpy( \ | | 307| 12| compiler->last_error_extra_info, \ | | 308| 12| info, \ | | 309| 12| sizeof(compiler->last_error_extra_info)); ------------------ 4651| 12| "regexp in for_expression is invalid"); 4652| | 4653| 12| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 12| { \ | | 121| 12| compiler->last_error = e; \ | | 122| 12| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 12|#define yyerror yara_yyerror | | ------------------ | | 123| 12| switch (e) \ | | 124| 12| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 12] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1312| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 12| default: \ | | ------------------ | | | Branch (127:7): [True: 12, False: 0] | | ------------------ | | 128| 12| YYERROR; \ | | ------------------ | | | | 1313| 12|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 12| } \ | | 130| 12| } ------------------ 4654| 0| } 4655| | 4656| 8.05k| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4657| 8.05k| } 4658| 0|#line 4659 "libyara/grammar.c" 4659| 0| break; 4660| | 4661| 3.89k| case 139: /* for_expression: for_quantifier */ ------------------ | Branch (4661:3): [True: 3.89k, False: 630k] ------------------ 4662| 3.89k|#line 2550 "libyara/grammar.y" 4663| 3.89k| { 4664| 3.89k| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4665| 3.89k| } 4666| 3.89k|#line 4667 "libyara/grammar.c" 4667| 3.89k| break; 4668| | 4669| 2.56k| case 140: /* for_quantifier: "" */ ------------------ | Branch (4669:3): [True: 2.56k, False: 631k] ------------------ 4670| 2.56k|#line 2557 "libyara/grammar.y" 4671| 2.56k| { 4672| 2.56k| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 2.56k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4673| 2.56k| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 2.56k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4674| 2.56k| (yyval.expression).value.integer = FOR_EXPRESSION_ALL; ------------------ | | 108| 2.56k|#define FOR_EXPRESSION_ALL 1 ------------------ 4675| 2.56k| } 4676| 2.56k|#line 4677 "libyara/grammar.c" 4677| 2.56k| break; 4678| | 4679| 1.32k| case 141: /* for_quantifier: "" */ ------------------ | Branch (4679:3): [True: 1.32k, False: 632k] ------------------ 4680| 1.32k|#line 2563 "libyara/grammar.y" 4681| 1.32k| { 4682| 1.32k| yr_parser_emit_push_const(yyscanner, 1); 4683| 1.32k| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 1.32k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4684| 1.32k| (yyval.expression).value.integer = FOR_EXPRESSION_ANY; ------------------ | | 109| 1.32k|#define FOR_EXPRESSION_ANY 2 ------------------ 4685| 1.32k| } 4686| 1.32k|#line 4687 "libyara/grammar.c" 4687| 1.32k| break; 4688| | 4689| 0| case 142: /* for_quantifier: "" */ ------------------ | Branch (4689:3): [True: 0, False: 634k] ------------------ 4690| 0|#line 2569 "libyara/grammar.y" 4691| 0| { 4692| 0| yr_parser_emit_push_const(yyscanner, 0); 4693| 0| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4694| 0| (yyval.expression).value.integer = FOR_EXPRESSION_NONE; ------------------ | | 110| 0|#define FOR_EXPRESSION_NONE 3 ------------------ 4695| 0| } 4696| 0|#line 4697 "libyara/grammar.c" 4697| 0| break; 4698| | 4699| 441| case 143: /* primary_expression: '(' primary_expression ')' */ ------------------ | Branch (4699:3): [True: 441, False: 633k] ------------------ 4700| 441|#line 2579 "libyara/grammar.y" 4701| 441| { 4702| 441| (yyval.expression) = (yyvsp[-1].expression); 4703| 441| } 4704| 441|#line 4705 "libyara/grammar.c" 4705| 441| break; 4706| | 4707| 214| case 144: /* primary_expression: "" */ ------------------ | Branch (4707:3): [True: 214, False: 633k] ------------------ 4708| 214|#line 2583 "libyara/grammar.y" 4709| 214| { 4710| 214| fail_if_error(yr_parser_emit( ------------------ | | 135| 214| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 428|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 214|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 214] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 214| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4711| 214| yyscanner, OP_FILESIZE, NULL)); 4712| | 4713| 214| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 214|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4714| 214| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 214|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4715| 214| } 4716| 0|#line 4717 "libyara/grammar.c" 4717| 0| break; 4718| | 4719| 39| case 145: /* primary_expression: "" */ ------------------ | Branch (4719:3): [True: 39, False: 634k] ------------------ 4720| 39|#line 2591 "libyara/grammar.y" 4721| 39| { 4722| 39| yywarning(yyscanner, ------------------ | | 50| 39|#define yywarning yara_yywarning ------------------ 4723| 39| "using deprecated \"entrypoint\" keyword. Use the \"entry_point\" " 4724| 39| "function from PE module instead."); 4725| | 4726| 39| fail_if_error(yr_parser_emit( ------------------ | | 135| 39| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 78|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 39|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 39] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 39| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4727| 39| yyscanner, OP_ENTRYPOINT, NULL)); 4728| | 4729| 39| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 39|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4730| 39| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 39|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4731| 39| } 4732| 0|#line 4733 "libyara/grammar.c" 4733| 0| break; 4734| | 4735| 29| case 146: /* primary_expression: "integer function" '(' primary_expression ')' */ ------------------ | Branch (4735:3): [True: 29, False: 634k] ------------------ 4736| 29|#line 2603 "libyara/grammar.y" 4737| 29| { 4738| 29| check_type((yyvsp[-1].expression), EXPRESSION_TYPE_INTEGER, "intXXXX or uintXXXX"); ------------------ | | 175| 29| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 29| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 22, False: 7] | | | | ------------------ | | | | 146| 29| { \ | | | | 147| 22| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 14] | | | | ------------------ | | | | 148| 22| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 22] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 22] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 10| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 10|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 10, False: 12] | | | | ------------------ | | | | 158| 10| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 10| strlcpy( \ | | | | | | 307| 10| compiler->last_error_extra_info, \ | | | | | | 308| 10| info, \ | | | | | | 309| 10| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 10| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 10| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 18] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 22| } \ | | | | 166| 22| cleanup; \ | | | | 167| 22| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 22|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 22| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 22|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 22| YYERROR; \ | | | | ------------------ | | | | | | 1313| 22|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 22| } | | ------------------ ------------------ 4739| | 4740| | // _INTEGER_FUNCTION_ could be any of int8, int16, int32, uint8, 4741| | // uint32, etc. $1 contains an index that added to OP_READ_INT results 4742| | // in the proper OP_INTXX opcode. 4743| | 4744| 7| fail_if_error(yr_parser_emit( ------------------ | | 135| 7| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 14|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 7|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 7] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 7| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4745| 7| yyscanner, (uint8_t) (OP_READ_INT + (yyvsp[-3].integer)), NULL)); 4746| | 4747| 7| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 7|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4748| 7| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 7|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4749| 7| } 4750| 0|#line 4751 "libyara/grammar.c" 4751| 0| break; 4752| | 4753| 39.6k| case 147: /* primary_expression: "integer number" */ ------------------ | Branch (4753:3): [True: 39.6k, False: 594k] ------------------ 4754| 39.6k|#line 2617 "libyara/grammar.y" 4755| 39.6k| { 4756| 39.6k| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].integer))); ------------------ | | 135| 39.6k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 79.2k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 39.6k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 39.6k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 39.6k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4757| | 4758| 39.6k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 39.6k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4759| 39.6k| (yyval.expression).value.integer = (yyvsp[0].integer); 4760| 39.6k| } 4761| 0|#line 4762 "libyara/grammar.c" 4762| 0| break; 4763| | 4764| 3.75k| case 148: /* primary_expression: "floating point number" */ ------------------ | Branch (4764:3): [True: 3.75k, False: 630k] ------------------ 4765| 3.75k|#line 2624 "libyara/grammar.y" 4766| 3.75k| { 4767| 3.75k| fail_if_error(yr_parser_emit_with_arg_double( ------------------ | | 135| 3.75k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 7.51k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 3.75k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 3.75k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 3.75k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4768| 3.75k| yyscanner, OP_PUSH, (yyvsp[0].double_), NULL, NULL)); 4769| | 4770| 3.75k| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 3.75k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4771| 3.75k| } 4772| 0|#line 4773 "libyara/grammar.c" 4773| 0| break; 4774| | 4775| 4.97k| case 149: /* primary_expression: "text string" */ ------------------ | Branch (4775:3): [True: 4.97k, False: 629k] ------------------ 4776| 4.97k|#line 2631 "libyara/grammar.y" 4777| 4.97k| { 4778| 4.97k| YR_ARENA_REF ref; 4779| | 4780| 4.97k| int result = _yr_compiler_store_data( 4781| 4.97k| compiler, 4782| 4.97k| (yyvsp[0].sized_string), 4783| 4.97k| (yyvsp[0].sized_string)->length + sizeof(SIZED_STRING), 4784| 4.97k| &ref); 4785| | 4786| 4.97k| yr_free((yyvsp[0].sized_string)); 4787| | 4788| 4.97k| if (result == ERROR_SUCCESS) ------------------ | | 40| 4.97k|#define ERROR_SUCCESS 0 ------------------ | Branch (4788:13): [True: 4.97k, False: 0] ------------------ 4789| 4.97k| result = yr_parser_emit_with_arg_reloc( 4790| 4.97k| yyscanner, 4791| 4.97k| OP_PUSH, ------------------ | | 61| 4.97k|#define OP_PUSH 13 ------------------ 4792| 4.97k| yr_arena_ref_to_ptr(compiler->arena, &ref), 4793| 4.97k| NULL, 4794| 4.97k| NULL); 4795| | 4796| 4.97k| fail_if_error(result); ------------------ | | 135| 4.97k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 9.94k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 4.97k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 4.97k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 4.97k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4797| | 4798| 4.97k| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 4.97k|#define EXPRESSION_TYPE_STRING 4 ------------------ 4799| 4.97k| (yyval.expression).value.sized_string_ref = ref; 4800| 4.97k| } 4801| 0|#line 4802 "libyara/grammar.c" 4802| 0| break; 4803| | 4804| 45| case 150: /* primary_expression: "string count" "" range */ ------------------ | Branch (4804:3): [True: 45, False: 634k] ------------------ 4805| 45|#line 2656 "libyara/grammar.y" 4806| 45| { 4807| 45| int result = yr_parser_reduce_string_identifier( 4808| 45| yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 124| 45|#define OP_COUNT_IN 76 ------------------ yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 38| 45|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4809| | 4810| 45| yr_free((yyvsp[-2].c_string)); 4811| | 4812| 45| fail_if_error(result); ------------------ | | 135| 45| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 90|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 77|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 32, False: 13] | | | Branch (135:31): [True: 32, False: 0] | | ------------------ | | 136| 45| { \ | | 137| 32| fail_with_error(e); \ | | ------------------ | | | | 120| 32| { \ | | | | 121| 32| compiler->last_error = e; \ | | | | 122| 32| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 32|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 32| switch (e) \ | | | | 124| 32| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 32] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 32| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 32, False: 0] | | | | ------------------ | | | | 128| 32| YYERROR; \ | | | | ------------------ | | | | | | 1313| 32|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 32| } \ | | | | 130| 32| } | | ------------------ | | 138| 0| } ------------------ 4813| | 4814| 13| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 13|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4815| 13| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 13|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4816| 13| } 4817| 0|#line 4818 "libyara/grammar.c" 4818| 0| break; 4819| | 4820| 3.28k| case 151: /* primary_expression: "string count" */ ------------------ | Branch (4820:3): [True: 3.28k, False: 630k] ------------------ 4821| 3.28k|#line 2668 "libyara/grammar.y" 4822| 3.28k| { 4823| 3.28k| int result = yr_parser_reduce_string_identifier( 4824| 3.28k| yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 68| 3.28k|#define OP_COUNT 20 ------------------ yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 38| 3.28k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4825| | 4826| 3.28k| yr_free((yyvsp[0].c_string)); 4827| | 4828| 3.28k| fail_if_error(result); ------------------ | | 135| 3.28k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 6.57k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 3.29k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 9, False: 3.28k] | | | Branch (135:31): [True: 9, False: 0] | | ------------------ | | 136| 3.28k| { \ | | 137| 9| fail_with_error(e); \ | | ------------------ | | | | 120| 9| { \ | | | | 121| 9| compiler->last_error = e; \ | | | | 122| 9| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 9|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 9| switch (e) \ | | | | 124| 9| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 9] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 9| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 9, False: 0] | | | | ------------------ | | | | 128| 9| YYERROR; \ | | | | ------------------ | | | | | | 1313| 9|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 9| } \ | | | | 130| 9| } | | ------------------ | | 138| 0| } ------------------ 4829| | 4830| 3.28k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 3.28k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4831| 3.28k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 3.28k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4832| 3.28k| } 4833| 0|#line 4834 "libyara/grammar.c" 4834| 0| break; 4835| | 4836| 293| case 152: /* primary_expression: "string offset" '[' primary_expression ']' */ ------------------ | Branch (4836:3): [True: 293, False: 633k] ------------------ 4837| 293|#line 2680 "libyara/grammar.y" 4838| 293| { 4839| 293| int result = yr_parser_reduce_string_identifier( 4840| 293| yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 293|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 293|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4841| | 4842| 293| yr_free((yyvsp[-3].c_string)); 4843| | 4844| 293| fail_if_error(result); ------------------ | | 135| 293| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 586|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 293|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 293] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 293| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4845| | 4846| 293| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 293|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4847| 293| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 293|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4848| 293| } 4849| 0|#line 4850 "libyara/grammar.c" 4850| 0| break; 4851| | 4852| 3.51k| case 153: /* primary_expression: "string offset" */ ------------------ | Branch (4852:3): [True: 3.51k, False: 630k] ------------------ 4853| 3.51k|#line 2692 "libyara/grammar.y" 4854| 3.51k| { 4855| 3.51k| int result = yr_parser_emit_push_const(yyscanner, 1); 4856| | 4857| 3.51k| if (result == ERROR_SUCCESS) ------------------ | | 40| 3.51k|#define ERROR_SUCCESS 0 ------------------ | Branch (4857:13): [True: 3.51k, False: 0] ------------------ 4858| 3.51k| result = yr_parser_reduce_string_identifier( 4859| 3.51k| yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 3.51k|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 3.51k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4860| | 4861| 3.51k| yr_free((yyvsp[0].c_string)); 4862| | 4863| 3.51k| fail_if_error(result); ------------------ | | 135| 3.51k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 7.02k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 3.55k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 45, False: 3.46k] | | | Branch (135:31): [True: 45, False: 0] | | ------------------ | | 136| 3.51k| { \ | | 137| 45| fail_with_error(e); \ | | ------------------ | | | | 120| 45| { \ | | | | 121| 45| compiler->last_error = e; \ | | | | 122| 45| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 45|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 45| switch (e) \ | | | | 124| 45| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 45] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 45| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 45, False: 0] | | | | ------------------ | | | | 128| 45| YYERROR; \ | | | | ------------------ | | | | | | 1313| 45|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 45| } \ | | | | 130| 45| } | | ------------------ | | 138| 0| } ------------------ 4864| | 4865| 3.46k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 3.46k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4866| 3.46k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 3.46k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4867| 3.46k| } 4868| 0|#line 4869 "libyara/grammar.c" 4869| 0| break; 4870| | 4871| 421| case 154: /* primary_expression: "string length" '[' primary_expression ']' */ ------------------ | Branch (4871:3): [True: 421, False: 633k] ------------------ 4872| 421|#line 2707 "libyara/grammar.y" 4873| 421| { 4874| 421| int result = yr_parser_reduce_string_identifier( 4875| 421| yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 421|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 421|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4876| | 4877| 421| yr_free((yyvsp[-3].c_string)); 4878| | 4879| 421| fail_if_error(result); ------------------ | | 135| 421| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 842|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 436|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 15, False: 406] | | | Branch (135:31): [True: 15, False: 0] | | ------------------ | | 136| 421| { \ | | 137| 15| fail_with_error(e); \ | | ------------------ | | | | 120| 15| { \ | | | | 121| 15| compiler->last_error = e; \ | | | | 122| 15| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 15|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 15| switch (e) \ | | | | 124| 15| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 15] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 15| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 15, False: 0] | | | | ------------------ | | | | 128| 15| YYERROR; \ | | | | ------------------ | | | | | | 1313| 15|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 15| } \ | | | | 130| 15| } | | ------------------ | | 138| 0| } ------------------ 4880| | 4881| 406| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 406|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4882| 406| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 406|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4883| 406| } 4884| 0|#line 4885 "libyara/grammar.c" 4885| 0| break; 4886| | 4887| 10.0k| case 155: /* primary_expression: "string length" */ ------------------ | Branch (4887:3): [True: 10.0k, False: 624k] ------------------ 4888| 10.0k|#line 2719 "libyara/grammar.y" 4889| 10.0k| { 4890| 10.0k| int result = yr_parser_emit_push_const(yyscanner, 1); 4891| | 4892| 10.0k| if (result == ERROR_SUCCESS) ------------------ | | 40| 10.0k|#define ERROR_SUCCESS 0 ------------------ | Branch (4892:13): [True: 10.0k, False: 0] ------------------ 4893| 10.0k| result = yr_parser_reduce_string_identifier( 4894| 10.0k| yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 10.0k|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 10.0k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4895| | 4896| 10.0k| yr_free((yyvsp[0].c_string)); 4897| | 4898| 10.0k| fail_if_error(result); ------------------ | | 135| 10.0k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 20.1k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 10.0k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 3, False: 10.0k] | | | Branch (135:31): [True: 3, False: 0] | | ------------------ | | 136| 10.0k| { \ | | 137| 3| fail_with_error(e); \ | | ------------------ | | | | 120| 3| { \ | | | | 121| 3| compiler->last_error = e; \ | | | | 122| 3| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 3|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 3| switch (e) \ | | | | 124| 3| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 3] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 3| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 3, False: 0] | | | | ------------------ | | | | 128| 3| YYERROR; \ | | | | ------------------ | | | | | | 1313| 3|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 3| } \ | | | | 130| 3| } | | ------------------ | | 138| 0| } ------------------ 4899| | 4900| 10.0k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 10.0k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4901| 10.0k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 10.0k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4902| 10.0k| } 4903| 0|#line 4904 "libyara/grammar.c" 4904| 0| break; 4905| | 4906| 11.9k| case 156: /* primary_expression: identifier */ ------------------ | Branch (4906:3): [True: 11.9k, False: 622k] ------------------ 4907| 11.9k|#line 2734 "libyara/grammar.y" 4908| 11.9k| { 4909| 11.9k| int result = ERROR_SUCCESS; ------------------ | | 40| 11.9k|#define ERROR_SUCCESS 0 ------------------ 4910| | 4911| 11.9k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 11.9k|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4911:13): [True: 4.73k, False: 7.23k] ------------------ 4912| 4.73k| { 4913| 4.73k| result = yr_parser_emit( 4914| 4.73k| yyscanner, OP_OBJ_VALUE, NULL); ------------------ | | 65| 4.73k|#define OP_OBJ_VALUE 17 ------------------ 4915| | 4916| 4.73k| switch((yyvsp[0].expression).value.object->type) 4917| 4.73k| { 4918| 40| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 40|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (4918:13): [True: 40, False: 4.69k] ------------------ 4919| 40| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 40|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4920| 40| (yyval.expression).value.integer = (yyvsp[0].expression).value.object->value.i; 4921| 40| break; 4922| 0| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (4922:13): [True: 0, False: 4.73k] ------------------ 4923| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4924| 0| break; 4925| 4.65k| case OBJECT_TYPE_STRING: ------------------ | | 59| 4.65k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (4925:13): [True: 4.65k, False: 74] ------------------ 4926| 4.65k| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 4.65k|#define EXPRESSION_TYPE_STRING 4 ------------------ 4927| 4.65k| (yyval.expression).value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 4.65k| (YR_ARENA_REF) \ | | 44| 4.65k| { \ | | 45| 4.65k| UINT32_MAX, UINT32_MAX \ | | 46| 4.65k| } ------------------ 4928| 4.65k| break; 4929| 34| default: ------------------ | Branch (4929:13): [True: 34, False: 4.69k] ------------------ 4930| | // In a primary expression any identifier that corresponds to an 4931| | // object must be of type integer, float or string. If "foobar" is 4932| | // either a function, structure, dictionary or array you can not 4933| | // use it as: 4934| | // condition: foobar 4935| 34| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 34| snprintf( \ | | 313| 34| compiler->last_error_extra_info, \ | | 314| 34| sizeof(compiler->last_error_extra_info), \ | | 315| 34| fmt, \ | | 316| 68| __VA_ARGS__); | | ------------------ | | | Branch (316:7): [True: 24, False: 10] | | ------------------ ------------------ 4936| 34| compiler, 4937| 34| "wrong usage of identifier \"%s\"", 4938| 34| expression_identifier((yyvsp[0].expression))); 4939| | 4940| 34| result = ERROR_WRONG_TYPE; ------------------ | | 69| 34|#define ERROR_WRONG_TYPE 24 ------------------ 4941| 4.73k| } 4942| 4.73k| } 4943| 7.23k| else 4944| 7.23k| { 4945| 7.23k| (yyval.expression) = (yyvsp[0].expression); 4946| 7.23k| } 4947| | 4948| 11.9k| fail_if_error(result); ------------------ | | 135| 11.9k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 23.9k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 12.0k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 34, False: 11.9k] | | | Branch (135:31): [True: 34, False: 0] | | ------------------ | | 136| 11.9k| { \ | | 137| 34| fail_with_error(e); \ | | ------------------ | | | | 120| 34| { \ | | | | 121| 34| compiler->last_error = e; \ | | | | 122| 34| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 34|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 34| switch (e) \ | | | | 124| 34| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 34] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 34| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 34, False: 0] | | | | ------------------ | | | | 128| 34| YYERROR; \ | | | | ------------------ | | | | | | 1313| 34|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 34| } \ | | | | 130| 34| } | | ------------------ | | 138| 0| } ------------------ 4949| 11.9k| } 4950| 0|#line 4951 "libyara/grammar.c" 4951| 0| break; 4952| | 4953| 12.8k| case 157: /* primary_expression: '-' primary_expression */ ------------------ | Branch (4953:3): [True: 12.8k, False: 621k] ------------------ 4954| 12.8k|#line 2777 "libyara/grammar.y" 4955| 12.8k| { 4956| 12.8k| int result = ERROR_SUCCESS; ------------------ | | 40| 12.8k|#define ERROR_SUCCESS 0 ------------------ 4957| | 4958| 12.8k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER | EXPRESSION_TYPE_FLOAT, "-"); ------------------ | | 175| 12.8k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 12.8k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 12, False: 12.8k] | | | | ------------------ | | | | 146| 12.8k| { \ | | | | 147| 12| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 12] | | | | ------------------ | | | | 148| 12| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 12] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 12] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 8| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 8|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 8, False: 4] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 8| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 8| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 8] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 12| } \ | | | | 166| 12| cleanup; \ | | | | 167| 12| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 12|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 12| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 12|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 12| YYERROR; \ | | | | ------------------ | | | | | | 1313| 12|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 12| } | | ------------------ ------------------ 4959| | 4960| 12.8k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 12.8k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4960:13): [True: 11.1k, False: 1.72k] ------------------ 4961| 11.1k| { 4962| 11.1k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 11.1k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4963| 11.1k| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 11.1k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (4963:46): [True: 1.93k, False: 9.20k] ------------------ 4964| 9.20k| YR_UNDEFINED : -((yyvsp[0].expression).value.integer); ------------------ | | 38| 1.93k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4965| 11.1k| result = yr_parser_emit(yyscanner, OP_INT_MINUS, NULL); ------------------ | | 152| 11.1k|#define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 141| 11.1k|#define OP_INT_BEGIN 100 | | ------------------ | | #define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 11.1k|#define _OP_MINUS 10 | | ------------------ ------------------ 4966| 11.1k| } 4967| 1.72k| else if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 1.72k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (4967:18): [True: 1.72k, False: 0] ------------------ 4968| 1.72k| { 4969| 1.72k| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 1.72k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4970| 1.72k| result = yr_parser_emit(yyscanner, OP_DBL_MINUS, NULL); ------------------ | | 166| 1.72k|#define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 155| 1.72k|#define OP_DBL_BEGIN 120 | | ------------------ | | #define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 1.72k|#define _OP_MINUS 10 | | ------------------ ------------------ 4971| 1.72k| } 4972| | 4973| 12.8k| fail_if_error(result); ------------------ | | 135| 12.8k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 25.7k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 12.8k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 12.8k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 12.8k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4974| 12.8k| } 4975| 0|#line 4976 "libyara/grammar.c" 4976| 0| break; 4977| | 4978| 4.84k| case 158: /* primary_expression: primary_expression '+' primary_expression */ ------------------ | Branch (4978:3): [True: 4.84k, False: 629k] ------------------ 4979| 4.84k|#line 2798 "libyara/grammar.y" 4980| 4.84k| { 4981| 4.84k| int result = yr_parser_reduce_operation( 4982| 4.84k| yyscanner, "+", (yyvsp[-2].expression), (yyvsp[0].expression)); 4983| | 4984| 4.84k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 9.69k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4984:13): [True: 3.62k, False: 1.22k] ------------------ 4985| 4.84k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 3.62k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4985:13): [True: 2.64k, False: 978] ------------------ 4986| 2.64k| { 4987| 2.64k| int64_t i1 = (yyvsp[-2].expression).value.integer; 4988| 2.64k| int64_t i2 = (yyvsp[0].expression).value.integer; 4989| | 4990| 2.64k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 5.29k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.64k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 4.40k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.75k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4990:15): [True: 1.75k, False: 894] | Branch (4990:36): [True: 1.70k, False: 44] ------------------ 4991| 2.64k| ( 4992| 1.70k| (i2 > 0 && i1 > INT64_MAX - i2) || ------------------ | Branch (4992:18): [True: 585, False: 1.12k] | Branch (4992:28): [True: 4, False: 581] ------------------ 4993| 1.70k| (i2 < 0 && i1 < INT64_MIN - i2) ------------------ | Branch (4993:18): [True: 531, False: 1.17k] | Branch (4993:28): [True: 4, False: 527] ------------------ 4994| 1.70k| )) 4995| 8| { 4996| 8| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 8| snprintf( \ | | 313| 8| compiler->last_error_extra_info, \ | | 314| 8| sizeof(compiler->last_error_extra_info), \ | | 315| 8| fmt, \ | | 316| 8| __VA_ARGS__); ------------------ 4997| 8| compiler, "%" PRId64 " + %" PRId64, i1, i2); 4998| | 4999| 8| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 8|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5000| 8| } 5001| 2.63k| else 5002| 2.63k| { 5003| 2.63k| (yyval.expression).value.integer = OPERATION(+, i1, i2); ------------------ | | 197| 2.63k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 5.27k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 2.63k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 894, False: 1.74k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.74k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.74k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 44, False: 1.70k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 938|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5004| 2.63k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.63k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5005| 2.63k| } 5006| 2.64k| } 5007| 2.19k| else 5008| 2.19k| { 5009| 2.19k| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 2.19k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5010| 2.19k| } 5011| | 5012| 4.84k| fail_if_error(result); ------------------ | | 135| 4.84k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 9.69k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 4.85k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 8, False: 4.83k] | | | Branch (135:31): [True: 8, False: 0] | | ------------------ | | 136| 4.84k| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 8| switch (e) \ | | | | 124| 8| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 8] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1313| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 5013| 4.83k| } 5014| 0|#line 5015 "libyara/grammar.c" 5015| 0| break; 5016| | 5017| 5.71k| case 159: /* primary_expression: primary_expression '-' primary_expression */ ------------------ | Branch (5017:3): [True: 5.71k, False: 628k] ------------------ 5018| 5.71k|#line 2833 "libyara/grammar.y" 5019| 5.71k| { 5020| 5.71k| int result = yr_parser_reduce_operation( 5021| 5.71k| yyscanner, "-", (yyvsp[-2].expression), (yyvsp[0].expression)); 5022| | 5023| 5.71k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 11.4k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5023:13): [True: 5.21k, False: 496] ------------------ 5024| 5.71k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 5.21k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5024:13): [True: 4.56k, False: 647] ------------------ 5025| 4.56k| { 5026| 4.56k| int64_t i1 = (yyvsp[-2].expression).value.integer; 5027| 4.56k| int64_t i2 = (yyvsp[0].expression).value.integer; 5028| | 5029| 4.56k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 9.13k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 4.56k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 6.47k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.91k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5029:15): [True: 1.91k, False: 2.65k] | Branch (5029:36): [True: 1.37k, False: 539] ------------------ 5030| 4.56k| ( 5031| 1.37k| (i2 < 0 && i1 > INT64_MAX + i2) || ------------------ | Branch (5031:18): [True: 455, False: 916] | Branch (5031:28): [True: 7, False: 448] ------------------ 5032| 1.37k| (i2 > 0 && i1 < INT64_MIN + i2) ------------------ | Branch (5032:18): [True: 866, False: 498] | Branch (5032:28): [True: 7, False: 859] ------------------ 5033| 1.37k| )) 5034| 14| { 5035| 14| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 14| snprintf( \ | | 313| 14| compiler->last_error_extra_info, \ | | 314| 14| sizeof(compiler->last_error_extra_info), \ | | 315| 14| fmt, \ | | 316| 14| __VA_ARGS__); ------------------ 5036| 14| compiler, "%" PRId64 " - %" PRId64, i1, i2); 5037| | 5038| 14| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 14|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5039| 14| } 5040| 4.55k| else 5041| 4.55k| { 5042| 4.55k| (yyval.expression).value.integer = OPERATION(-, i1, i2); ------------------ | | 197| 4.55k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 9.10k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 4.55k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 2.65k, False: 1.89k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.89k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.89k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 539, False: 1.35k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 3.19k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5043| 4.55k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 4.55k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5044| 4.55k| } 5045| 4.56k| } 5046| 1.14k| else 5047| 1.14k| { 5048| 1.14k| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 1.14k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5049| 1.14k| } 5050| | 5051| 5.71k| fail_if_error(result); ------------------ | | 135| 5.71k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 11.4k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 5.73k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 28, False: 5.68k] | | | Branch (135:31): [True: 28, False: 0] | | ------------------ | | 136| 5.71k| { \ | | 137| 28| fail_with_error(e); \ | | ------------------ | | | | 120| 28| { \ | | | | 121| 28| compiler->last_error = e; \ | | | | 122| 28| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 28|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 28| switch (e) \ | | | | 124| 28| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 28] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 28| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 28, False: 0] | | | | ------------------ | | | | 128| 28| YYERROR; \ | | | | ------------------ | | | | | | 1313| 28|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 28| } \ | | | | 130| 28| } | | ------------------ | | 138| 0| } ------------------ 5052| 5.68k| } 5053| 0|#line 5054 "libyara/grammar.c" 5054| 0| break; 5055| | 5056| 2.78k| case 160: /* primary_expression: primary_expression '*' primary_expression */ ------------------ | Branch (5056:3): [True: 2.78k, False: 631k] ------------------ 5057| 2.78k|#line 2868 "libyara/grammar.y" 5058| 2.78k| { 5059| 2.78k| int result = yr_parser_reduce_operation( 5060| 2.78k| yyscanner, "*", (yyvsp[-2].expression), (yyvsp[0].expression)); 5061| | 5062| 2.78k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 5.57k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5062:13): [True: 2.51k, False: 271] ------------------ 5063| 2.78k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 2.51k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5063:13): [True: 2.14k, False: 370] ------------------ 5064| 2.14k| { 5065| 2.14k| int64_t i1 = (yyvsp[-2].expression).value.integer; 5066| 2.14k| int64_t i2 = (yyvsp[0].expression).value.integer; 5067| | 5068| 2.14k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 4.29k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.14k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 4.12k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.98k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5068:15): [True: 1.98k, False: 162] | Branch (5068:36): [True: 1.05k, False: 928] ------------------ 5069| 2.14k| ( 5070| 1.05k| i2 != 0 && llabs(i1) > INT64_MAX / llabs(i2) ------------------ | Branch (5070:17): [True: 474, False: 581] | Branch (5070:28): [True: 6, False: 468] ------------------ 5071| 1.05k| )) 5072| 6| { 5073| 6| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 6| snprintf( \ | | 313| 6| compiler->last_error_extra_info, \ | | 314| 6| sizeof(compiler->last_error_extra_info), \ | | 315| 6| fmt, \ | | 316| 6| __VA_ARGS__); ------------------ 5074| 6| compiler, "%" PRId64 " * %" PRId64, i1, i2); 5075| | 5076| 6| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 6|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5077| 6| } 5078| 2.13k| else 5079| 2.13k| { 5080| 2.13k| (yyval.expression).value.integer = OPERATION(*, i1, i2); ------------------ | | 197| 2.13k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 4.27k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 2.13k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 162, False: 1.97k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.97k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.97k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 928, False: 1.04k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.09k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5081| 2.13k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.13k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5082| 2.13k| } 5083| 2.14k| } 5084| 641| else 5085| 641| { 5086| 641| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 641|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5087| 641| } 5088| | 5089| 2.78k| fail_if_error(result); ------------------ | | 135| 2.78k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 5.57k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.79k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 6, False: 2.78k] | | | Branch (135:31): [True: 6, False: 0] | | ------------------ | | 136| 2.78k| { \ | | 137| 6| fail_with_error(e); \ | | ------------------ | | | | 120| 6| { \ | | | | 121| 6| compiler->last_error = e; \ | | | | 122| 6| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 6|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 6| switch (e) \ | | | | 124| 6| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 6] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 6| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 6, False: 0] | | | | ------------------ | | | | 128| 6| YYERROR; \ | | | | ------------------ | | | | | | 1313| 6|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 6| } \ | | | | 130| 6| } | | ------------------ | | 138| 0| } ------------------ 5090| 2.78k| } 5091| 0|#line 5092 "libyara/grammar.c" 5092| 0| break; 5093| | 5094| 1.88k| case 161: /* primary_expression: primary_expression '\\' primary_expression */ ------------------ | Branch (5094:3): [True: 1.88k, False: 632k] ------------------ 5095| 1.88k|#line 2902 "libyara/grammar.y" 5096| 1.88k| { 5097| 1.88k| int result = yr_parser_reduce_operation( 5098| 1.88k| yyscanner, "\\", (yyvsp[-2].expression), (yyvsp[0].expression)); 5099| | 5100| 1.88k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 3.76k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5100:13): [True: 1.68k, False: 198] ------------------ 5101| 1.88k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 1.68k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5101:13): [True: 1.39k, False: 287] ------------------ 5102| 1.39k| { 5103| 1.39k| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (5103:15): [True: 1.39k, False: 0] ------------------ 5104| 1.39k| { 5105| 1.39k| (yyval.expression).value.integer = OPERATION(/, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.39k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 2.79k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.39k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 763, False: 635] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 635|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 635|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 311, False: 324] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.07k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5106| 1.39k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.39k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5107| 1.39k| } 5108| 0| else 5109| 0| { 5110| 0| result = ERROR_DIVISION_BY_ZERO; ------------------ | | 91| 0|#define ERROR_DIVISION_BY_ZERO 44 ------------------ 5111| 0| } 5112| 1.39k| } 5113| 485| else 5114| 485| { 5115| 485| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 485|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5116| 485| } 5117| | 5118| 1.88k| fail_if_error(result); ------------------ | | 135| 1.88k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.76k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.88k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.88k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.88k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5119| 1.88k| } 5120| 0|#line 5121 "libyara/grammar.c" 5121| 0| break; 5122| | 5123| 558| case 162: /* primary_expression: primary_expression '%' primary_expression */ ------------------ | Branch (5123:3): [True: 558, False: 633k] ------------------ 5124| 558|#line 2927 "libyara/grammar.y" 5125| 558| { 5126| 558| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 558| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 558| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 11, False: 547] | | | | ------------------ | | | | 146| 558| { \ | | | | 147| 11| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 5, False: 6] | | | | ------------------ | | | | 148| 11| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 11] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 11] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 6| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 6|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 6, False: 5] | | | | ------------------ | | | | 158| 6| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 6| strlcpy( \ | | | | | | 307| 6| compiler->last_error_extra_info, \ | | | | | | 308| 6| info, \ | | | | | | 309| 6| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 6| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 6| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 11] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 11| } \ | | | | 166| 11| cleanup; \ | | | | 167| 11| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 11|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 11| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 11|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 11| YYERROR; \ | | | | ------------------ | | | | | | 1313| 11|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 11| } | | ------------------ ------------------ 5127| 547| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 547| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 547| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 14, False: 533] | | | | ------------------ | | | | 146| 547| { \ | | | | 147| 14| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 14] | | | | ------------------ | | | | 148| 14| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 14] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 10] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 6| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 6|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 6, False: 8] | | | | ------------------ | | | | 158| 6| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 6| strlcpy( \ | | | | | | 307| 6| compiler->last_error_extra_info, \ | | | | | | 308| 6| info, \ | | | | | | 309| 6| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 6| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 6| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 10] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 14| } \ | | | | 166| 14| cleanup; \ | | | | 167| 14| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 14|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 14| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 14|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 14| YYERROR; \ | | | | ------------------ | | | | | | 1313| 14|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 14| } | | ------------------ ------------------ 5128| | 5129| 533| fail_if_error(yr_parser_emit(yyscanner, OP_MOD, NULL)); ------------------ | | 135| 533| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 1.06k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 533|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 533] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 533| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5130| | 5131| 533| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (5131:13): [True: 521, False: 12] ------------------ 5132| 521| { 5133| 521| (yyval.expression).value.integer = OPERATION(%, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 521| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.04k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 521|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 35, False: 486] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 486|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 486|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 214, False: 272] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 249|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5134| 521| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 521|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5135| 521| } 5136| 12| else 5137| 12| { 5138| 12| fail_if_error(ERROR_DIVISION_BY_ZERO); ------------------ | | 135| 12| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 24|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 12|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [Folded - Ignored] | | | Branch (135:31): [Folded - Ignored] | | ------------------ | | 136| 12| { \ | | 137| 12| fail_with_error(e); \ | | ------------------ | | | | 120| 12| { \ | | | | 121| 12| compiler->last_error = e; \ | | | | 122| 12| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 12|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 12| switch (e) \ | | | | 124| 12| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 12] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 12| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 12, False: 0] | | | | ------------------ | | | | 128| 12| YYERROR; \ | | | | ------------------ | | | | | | 1313| 12|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 12| } \ | | | | 130| 12| } | | ------------------ | | 138| 0| } ------------------ 5139| 0| } 5140| 533| } 5141| 521|#line 5142 "libyara/grammar.c" 5142| 521| break; 5143| | 5144| 2.02k| case 163: /* primary_expression: primary_expression '^' primary_expression */ ------------------ | Branch (5144:3): [True: 2.02k, False: 632k] ------------------ 5145| 2.02k|#line 2944 "libyara/grammar.y" 5146| 2.02k| { 5147| 2.02k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 2.02k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.02k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 40, False: 1.98k] | | | | ------------------ | | | | 146| 2.02k| { \ | | | | 147| 40| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 20, False: 20] | | | | ------------------ | | | | 148| 40| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 40] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 40] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 20| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 20|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 20, False: 20] | | | | ------------------ | | | | 158| 20| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 20| strlcpy( \ | | | | | | 307| 20| compiler->last_error_extra_info, \ | | | | | | 308| 20| info, \ | | | | | | 309| 20| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 20| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 20| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 40] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 40| } \ | | | | 166| 40| cleanup; \ | | | | 167| 40| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 40|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 40| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 40|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 40| YYERROR; \ | | | | ------------------ | | | | | | 1313| 40|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 40| } | | ------------------ ------------------ 5148| 1.98k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 1.98k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.98k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 14, False: 1.97k] | | | | ------------------ | | | | 146| 1.98k| { \ | | | | 147| 14| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 14] | | | | ------------------ | | | | 148| 14| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 14] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 7| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 7|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 7, False: 7] | | | | ------------------ | | | | 154| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 7| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 7| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 14] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 7| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 7|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 7, False: 7] | | | | ------------------ | | | | 162| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 7| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 7| break; \ | | | | 165| 14| } \ | | | | 166| 14| cleanup; \ | | | | 167| 14| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 14|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 14| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 14|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 14| YYERROR; \ | | | | ------------------ | | | | | | 1313| 14|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 14| } | | ------------------ ------------------ 5149| | 5150| 1.97k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_XOR, NULL)); ------------------ | | 135| 1.97k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.94k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.97k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.97k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.97k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5151| | 5152| 1.97k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.97k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5153| 1.97k| (yyval.expression).value.integer = OPERATION(^, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.97k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 3.94k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.97k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 1.68k, False: 286] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 286|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 286|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 232, False: 54] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.92k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5154| 1.97k| } 5155| 0|#line 5156 "libyara/grammar.c" 5156| 0| break; 5157| | 5158| 2.06k| case 164: /* primary_expression: primary_expression '&' primary_expression */ ------------------ | Branch (5158:3): [True: 2.06k, False: 632k] ------------------ 5159| 2.06k|#line 2954 "libyara/grammar.y" 5160| 2.06k| { 5161| 2.06k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 2.06k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.06k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 30, False: 2.03k] | | | | ------------------ | | | | 146| 2.06k| { \ | | | | 147| 30| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 30] | | | | ------------------ | | | | 148| 30| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 30] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 15| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 15|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 15, False: 15] | | | | ------------------ | | | | 154| 15| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 15| strlcpy( \ | | | | | | 307| 15| compiler->last_error_extra_info, \ | | | | | | 308| 15| info, \ | | | | | | 309| 15| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 15| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 15| break; \ | | | | 157| 7| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 7|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 7, False: 23] | | | | ------------------ | | | | 158| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 7| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 7| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 22] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 30| } \ | | | | 166| 30| cleanup; \ | | | | 167| 30| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 30|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 30| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 30|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 30| YYERROR; \ | | | | ------------------ | | | | | | 1313| 30|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 30| } | | ------------------ ------------------ 5162| 2.03k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 2.03k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.03k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 13, False: 2.02k] | | | | ------------------ | | | | 146| 2.03k| { \ | | | | 147| 13| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 13] | | | | ------------------ | | | | 148| 13| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 13] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 13] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 9| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 9|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 9, False: 4] | | | | ------------------ | | | | 158| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 9| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 9| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 9] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 13| } \ | | | | 166| 13| cleanup; \ | | | | 167| 13| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 13|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 13| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 13|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 13| YYERROR; \ | | | | ------------------ | | | | | | 1313| 13|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 13| } | | ------------------ ------------------ 5163| | 5164| 2.02k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_AND, NULL)); ------------------ | | 135| 2.02k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 4.04k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.02k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.02k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 2.02k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5165| | 5166| 2.02k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.02k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5167| 2.02k| (yyval.expression).value.integer = OPERATION(&, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 2.02k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 4.04k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 2.02k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 632, False: 1.39k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.39k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.39k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 929, False: 462] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.56k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5168| 2.02k| } 5169| 0|#line 5170 "libyara/grammar.c" 5170| 0| break; 5171| | 5172| 1.75k| case 165: /* primary_expression: primary_expression '|' primary_expression */ ------------------ | Branch (5172:3): [True: 1.75k, False: 632k] ------------------ 5173| 1.75k|#line 2964 "libyara/grammar.y" 5174| 1.75k| { 5175| 1.75k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 175| 1.75k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.75k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 15, False: 1.73k] | | | | ------------------ | | | | 146| 1.75k| { \ | | | | 147| 15| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 15] | | | | ------------------ | | | | 148| 15| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 15] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 15] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 4| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 4|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 4, False: 11] | | | | ------------------ | | | | 158| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 4| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 4| break; \ | | | | 161| 11| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 11|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 11, False: 4] | | | | ------------------ | | | | 162| 11| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 11| strlcpy( \ | | | | | | 307| 11| compiler->last_error_extra_info, \ | | | | | | 308| 11| info, \ | | | | | | 309| 11| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 11| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 11| break; \ | | | | 165| 15| } \ | | | | 166| 15| cleanup; \ | | | | 167| 15| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 15|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 15| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 15|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 15| YYERROR; \ | | | | ------------------ | | | | | | 1313| 15|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 15| } | | ------------------ ------------------ 5176| 1.73k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 175| 1.73k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.73k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 40, False: 1.69k] | | | | ------------------ | | | | 146| 1.73k| { \ | | | | 147| 40| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 14, False: 26] | | | | ------------------ | | | | 148| 40| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 40] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 36] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 13| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 13|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 13, False: 27] | | | | ------------------ | | | | 158| 13| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 13| strlcpy( \ | | | | | | 307| 13| compiler->last_error_extra_info, \ | | | | | | 308| 13| info, \ | | | | | | 309| 13| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 13| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 13| break; \ | | | | 161| 9| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 9|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 9, False: 31] | | | | ------------------ | | | | 162| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 9| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 9| break; \ | | | | 165| 40| } \ | | | | 166| 40| cleanup; \ | | | | 167| 40| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 40|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 40| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 40|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 40| YYERROR; \ | | | | ------------------ | | | | | | 1313| 40|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 40| } | | ------------------ ------------------ 5177| | 5178| 1.69k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_OR, NULL)); ------------------ | | 135| 1.69k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 3.39k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1.69k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.69k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1.69k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5179| | 5180| 1.69k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.69k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5181| 1.69k| (yyval.expression).value.integer = OPERATION(|, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.69k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 3.39k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.69k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 1.05k, False: 647] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 647|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 647|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 187, False: 460] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.23k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5182| 1.69k| } 5183| 0|#line 5184 "libyara/grammar.c" 5184| 0| break; 5185| | 5186| 8.95k| case 166: /* primary_expression: '~' primary_expression */ ------------------ | Branch (5186:3): [True: 8.95k, False: 625k] ------------------ 5187| 8.95k|#line 2974 "libyara/grammar.y" 5188| 8.95k| { 5189| 8.95k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "~"); ------------------ | | 175| 8.95k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 8.95k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 34, False: 8.92k] | | | | ------------------ | | | | 146| 8.95k| { \ | | | | 147| 34| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 15, False: 19] | | | | ------------------ | | | | 148| 34| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 34] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 34] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 12| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 12|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 12, False: 22] | | | | ------------------ | | | | 158| 12| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 12| strlcpy( \ | | | | | | 307| 12| compiler->last_error_extra_info, \ | | | | | | 308| 12| info, \ | | | | | | 309| 12| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 12| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 12| break; \ | | | | 161| 7| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 7|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 7, False: 27] | | | | ------------------ | | | | 162| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 7| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 7| break; \ | | | | 165| 34| } \ | | | | 166| 34| cleanup; \ | | | | 167| 34| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 34|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 34| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 34|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 34| YYERROR; \ | | | | ------------------ | | | | | | 1313| 34|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 34| } | | ------------------ ------------------ 5190| | 5191| 8.92k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_NOT, NULL)); ------------------ | | 135| 8.92k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 17.8k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 8.92k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 8.92k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 8.92k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5192| | 5193| 8.92k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 8.92k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5194| 8.92k| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 8.92k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (5194:44): [True: 14, False: 8.91k] ------------------ 5195| 8.91k| YR_UNDEFINED : ~((yyvsp[0].expression).value.integer); ------------------ | | 38| 14|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 5196| 8.92k| } 5197| 0|#line 5198 "libyara/grammar.c" 5198| 0| break; 5199| | 5200| 2.20k| case 167: /* primary_expression: primary_expression "<<" primary_expression */ ------------------ | Branch (5200:3): [True: 2.20k, False: 632k] ------------------ 5201| 2.20k|#line 2984 "libyara/grammar.y" 5202| 2.20k| { 5203| 2.20k| int result; 5204| | 5205| 2.20k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 175| 2.20k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.20k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 9, False: 2.19k] | | | | ------------------ | | | | 146| 2.20k| { \ | | | | 147| 9| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 9] | | | | ------------------ | | | | 148| 9| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 9] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 9] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 9| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 9|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 9, False: 0] | | | | ------------------ | | | | 158| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 9| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 9| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 9] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 9| } \ | | | | 166| 9| cleanup; \ | | | | 167| 9| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 9|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 9| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 9|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 9| YYERROR; \ | | | | ------------------ | | | | | | 1313| 9|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 9| } | | ------------------ ------------------ 5206| 2.19k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 175| 2.19k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.19k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 17, False: 2.17k] | | | | ------------------ | | | | 146| 2.19k| { \ | | | | 147| 17| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 9, False: 8] | | | | ------------------ | | | | 148| 17| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 17] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 4| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 4|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 4, False: 13] | | | | ------------------ | | | | 154| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 4| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 4| break; \ | | | | 157| 0| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 0|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 0, False: 17] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 0| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 0| break; \ | | | | 161| 4| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 4, False: 13] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 4| strlcpy( \ | | | | | | 307| 4| compiler->last_error_extra_info, \ | | | | | | 308| 4| info, \ | | | | | | 309| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| break; \ | | | | 165| 17| } \ | | | | 166| 17| cleanup; \ | | | | 167| 17| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 17|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 17| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 17|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 17| YYERROR; \ | | | | ------------------ | | | | | | 1313| 17|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 17| } | | ------------------ ------------------ 5207| | 5208| 2.17k| result = yr_parser_emit(yyscanner, OP_SHL, NULL); ------------------ | | 56| 2.17k|#define OP_SHL 8 ------------------ 5209| | 5210| 2.17k| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 4.35k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.17k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5210:13): [True: 1.06k, False: 1.11k] | Branch (5210:67): [True: 0, False: 1.06k] ------------------ 5211| 0| result = ERROR_INVALID_OPERAND; ------------------ | | 101| 0|#define ERROR_INVALID_OPERAND 54 ------------------ 5212| 2.17k| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 4.35k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.17k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5212:18): [True: 1.06k, False: 1.11k] | Branch (5212:72): [True: 469, False: 599] ------------------ 5213| 469| (yyval.expression).value.integer = 0; 5214| 1.71k| else 5215| 1.71k| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.71k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 3.42k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.71k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 830, False: 880] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 880|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 880|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 298, False: 582] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.12k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5216| | 5217| 2.17k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.17k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5218| | 5219| 2.17k| fail_if_error(result); ------------------ | | 135| 2.17k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 4.35k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.17k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.17k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 2.17k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5220| 2.17k| } 5221| 0|#line 5222 "libyara/grammar.c" 5222| 0| break; 5223| | 5224| 2.50k| case 168: /* primary_expression: primary_expression ">>" primary_expression */ ------------------ | Branch (5224:3): [True: 2.50k, False: 631k] ------------------ 5225| 2.50k|#line 3004 "libyara/grammar.y" 5226| 2.50k| { 5227| 2.50k| int result; 5228| | 5229| 2.50k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 175| 2.50k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.50k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 28, False: 2.48k] | | | | ------------------ | | | | 146| 2.50k| { \ | | | | 147| 28| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 12, False: 16] | | | | ------------------ | | | | 148| 28| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 28] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 8| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 8|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 8, False: 20] | | | | ------------------ | | | | 154| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 8| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 8| break; \ | | | | 157| 8| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 8|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 8, False: 20] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 8| strlcpy( \ | | | | | | 307| 8| compiler->last_error_extra_info, \ | | | | | | 308| 8| info, \ | | | | | | 309| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 8| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 8| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 28] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 28| } \ | | | | 166| 28| cleanup; \ | | | | 167| 28| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 28|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 28| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 28|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 28| YYERROR; \ | | | | ------------------ | | | | | | 1313| 28|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 28| } | | ------------------ ------------------ 5230| 2.48k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 175| 2.48k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.48k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 31, False: 2.45k] | | | | ------------------ | | | | 146| 2.48k| { \ | | | | 147| 31| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 31] | | | | ------------------ | | | | 148| 31| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 31] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 0| strlcpy( \ | | | | | | 307| 0| compiler->last_error_extra_info, \ | | | | | | 308| 0| info, \ | | | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 0| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 0| break; \ | | | | 153| 15| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 15|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 15, False: 16] | | | | ------------------ | | | | 154| 15| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 15| strlcpy( \ | | | | | | 307| 15| compiler->last_error_extra_info, \ | | | | | | 308| 15| info, \ | | | | | | 309| 15| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 15| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 15| break; \ | | | | 157| 9| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 9|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 9, False: 22] | | | | ------------------ | | | | 158| 9| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 9| strlcpy( \ | | | | | | 307| 9| compiler->last_error_extra_info, \ | | | | | | 308| 9| info, \ | | | | | | 309| 9| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 9| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 9| break; \ | | | | 161| 7| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 7|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 7, False: 24] | | | | ------------------ | | | | 162| 7| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 306| 7| strlcpy( \ | | | | | | 307| 7| compiler->last_error_extra_info, \ | | | | | | 308| 7| info, \ | | | | | | 309| 7| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 7| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 7| break; \ | | | | 165| 31| } \ | | | | 166| 31| cleanup; \ | | | | 167| 31| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 31|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 31| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 31|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 31| YYERROR; \ | | | | ------------------ | | | | | | 1313| 31|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 31| } | | ------------------ ------------------ 5231| | 5232| 2.45k| result = yr_parser_emit(yyscanner, OP_SHR, NULL); ------------------ | | 57| 2.45k|#define OP_SHR 9 ------------------ 5233| | 5234| 2.45k| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 4.90k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.45k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5234:13): [True: 599, False: 1.85k] | Branch (5234:67): [True: 0, False: 599] ------------------ 5235| 0| result = ERROR_INVALID_OPERAND; ------------------ | | 101| 0|#define ERROR_INVALID_OPERAND 54 ------------------ 5236| 2.45k| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 4.90k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 2.45k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5236:18): [True: 599, False: 1.85k] | Branch (5236:72): [True: 136, False: 463] ------------------ 5237| 136| (yyval.expression).value.integer = 0; 5238| 2.31k| else 5239| 2.31k| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 2.31k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 4.62k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 2.31k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 1.13k, False: 1.17k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.17k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.17k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 719, False: 460] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.85k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5240| | 5241| 2.45k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.45k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5242| | 5243| 2.45k| fail_if_error(result); ------------------ | | 135| 2.45k| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 4.90k|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 2.45k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.45k] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 2.45k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1312| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1313| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5244| 2.45k| } 5245| 0|#line 5246 "libyara/grammar.c" 5246| 0| break; 5247| | 5248| 1.52k| case 169: /* primary_expression: regexp */ ------------------ | Branch (5248:3): [True: 1.52k, False: 632k] ------------------ 5249| 1.52k|#line 3024 "libyara/grammar.y" 5250| 1.52k| { 5251| 1.52k| (yyval.expression) = (yyvsp[0].expression); 5252| 1.52k| } 5253| 1.52k|#line 5254 "libyara/grammar.c" 5254| 1.52k| break; 5255| | 5256| | 5257| 0|#line 5258 "libyara/grammar.c" 5258| | 5259| 3.38k| default: break; ------------------ | Branch (5259:7): [True: 3.38k, False: 630k] ------------------ 5260| 634k| } 5261| | /* User semantic actions sometimes alter yychar, and that requires 5262| | that yytoken be updated with the new translation. We take the 5263| | approach of translating immediately before every use of yytoken. 5264| | One alternative is translating here after every semantic action, 5265| | but that translation would be missed if the semantic action invokes 5266| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5267| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5268| | incorrect destructor might then be invoked immediately. In the 5269| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5270| | to an incorrect destructor call or verbose syntax error message 5271| | before the lookahead is translated. */ 5272| 624k| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 5273| | 5274| 624k| YYPOPSTACK (yylen); ------------------ | | 1931| 624k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5275| 624k| yylen = 0; 5276| | 5277| 624k| *++yyvsp = yyval; 5278| | 5279| | /* Now 'shift' the result of the reduction. Determine what state 5280| | that goes to, based on the state we popped back to and the rule 5281| | number reduced by. */ 5282| 624k| { 5283| 624k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 884| 624k|#define YYNTOKENS 84 ------------------ 5284| 624k| const int yyi = yypgoto[yylhs] + *yyssp; 5285| 624k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 881| 890k|#define YYLAST 480 ------------------ | Branch (5285:16): [True: 265k, False: 359k] | Branch (5285:28): [True: 265k, False: 28] | Branch (5285:45): [True: 157k, False: 107k] ------------------ 5286| 624k| ? yytable[yyi] 5287| 624k| : yydefgoto[yylhs]); 5288| 624k| } 5289| | 5290| 624k| goto yynewstate; 5291| | 5292| | 5293| |/*--------------------------------------. 5294| || yyerrlab -- here on detecting error. | 5295| |`--------------------------------------*/ 5296| 166k|yyerrlab: 5297| | /* Make sure we have latest lookahead translation. See comments at 5298| | user semantic actions for why this is necessary. */ 5299| 166k| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 51| 166k|#define yychar yara_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 312| 166k|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 899| 333k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 166k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 166k, False: 0] | | | Branch (899:18): [True: 166k, False: 0] | | ------------------ | | 900| 333k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 166k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 333k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (5299:13): [True: 0, False: 166k] ------------------ 5300| | /* If not already recovering from an error, report this error. */ 5301| 166k| if (!yyerrstatus) ------------------ | Branch (5301:7): [True: 5.83k, False: 160k] ------------------ 5302| 5.83k| { 5303| 5.83k| ++yynerrs; ------------------ | | 53| 5.83k|#define yynerrs yara_yynerrs ------------------ 5304| 5.83k| { 5305| 5.83k| yypcontext_t yyctx 5306| 5.83k| = {yyssp, yytoken}; 5307| 5.83k| char const *yymsgp = YY_("syntax error"); ------------------ | | 683| 5.83k|# define YY_(Msgid) Msgid ------------------ 5308| 5.83k| int yysyntax_error_status; 5309| 5.83k| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5310| 5.83k| if (yysyntax_error_status == 0) ------------------ | Branch (5310:13): [True: 5.83k, False: 0] ------------------ 5311| 5.83k| yymsgp = yymsg; 5312| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (5312:18): [True: 0, False: 0] ------------------ 5313| 0| { 5314| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5314:17): [True: 0, False: 0] ------------------ 5315| 0| YYSTACK_FREE (yymsg); ------------------ | | 791| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5316| 0| yymsg = YY_CAST (char *, ------------------ | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 5317| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 5318| 0| if (yymsg) ------------------ | Branch (5318:17): [True: 0, False: 0] ------------------ 5319| 0| { 5320| 0| yysyntax_error_status 5321| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5322| 0| yymsgp = yymsg; 5323| 0| } 5324| 0| else 5325| 0| { 5326| 0| yymsg = yymsgbuf; 5327| 0| yymsg_alloc = sizeof yymsgbuf; 5328| 0| yysyntax_error_status = YYENOMEM; 5329| 0| } 5330| 0| } 5331| 5.83k| yyerror (yyscanner, compiler, yymsgp); ------------------ | | 48| 5.83k|#define yyerror yara_yyerror ------------------ 5332| 5.83k| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (5332:13): [True: 0, False: 5.83k] ------------------ 5333| 0| YYNOMEM; ------------------ | | 1314| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 5334| 5.83k| } 5335| 5.83k| } 5336| | 5337| 166k| if (yyerrstatus == 3) ------------------ | Branch (5337:7): [True: 157k, False: 9.18k] ------------------ 5338| 157k| { 5339| | /* If just tried and failed to reuse lookahead token after an 5340| | error, discard it. */ 5341| | 5342| 157k| if (yychar <= _END_OF_FILE_) ------------------ | | 51| 157k|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 157k|#define _END_OF_FILE_ 0 ------------------ | Branch (5342:11): [True: 1.59k, False: 155k] ------------------ 5343| 1.59k| { 5344| | /* Return failure if at end of input. */ 5345| 1.59k| if (yychar == _END_OF_FILE_) ------------------ | | 51| 1.59k|#define yychar yara_yychar ------------------ if (yychar == _END_OF_FILE_) ------------------ | | 313| 1.59k|#define _END_OF_FILE_ 0 ------------------ | Branch (5345:15): [True: 1.59k, False: 0] ------------------ 5346| 1.59k| YYABORT; ------------------ | | 1312| 1.59k|#define YYABORT goto yyabortlab ------------------ 5347| 1.59k| } 5348| 155k| else 5349| 155k| { 5350| 155k| yydestruct ("Error: discarding", 5351| 155k| yytoken, &yylval, yyscanner, compiler); 5352| 155k| yychar = YYEMPTY; ------------------ | | 51| 155k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 155k|#define YYEMPTY -2 ------------------ 5353| 155k| } 5354| 157k| } 5355| | 5356| | /* Else will try to reuse lookahead token after shifting the error 5357| | token. */ 5358| 165k| goto yyerrlab1; 5359| | 5360| | 5361| |/*---------------------------------------------------. 5362| || yyerrorlab -- error raised explicitly by YYERROR. | 5363| |`---------------------------------------------------*/ 5364| 165k|yyerrorlab: 5365| | /* Pacify compilers when the user code never invokes YYERROR and the 5366| | label yyerrorlab therefore never appears in user code. */ 5367| 9.34k| if (0) ------------------ | Branch (5367:7): [Folded - Ignored] ------------------ 5368| 0| YYERROR; ------------------ | | 1313| 0|#define YYERROR goto yyerrorlab ------------------ 5369| 9.34k| ++yynerrs; ------------------ | | 53| 9.34k|#define yynerrs yara_yynerrs ------------------ 5370| | 5371| | /* Do not reclaim the symbols of the rule whose action triggered 5372| | this YYERROR. */ 5373| 9.34k| YYPOPSTACK (yylen); ------------------ | | 1931| 9.34k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5374| 9.34k| yylen = 0; 5375| 9.34k| YY_STACK_PRINT (yyss, yyssp); 5376| 9.34k| yystate = *yyssp; 5377| 9.34k| goto yyerrlab1; 5378| | 5379| | 5380| |/*-------------------------------------------------------------. 5381| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5382| |`-------------------------------------------------------------*/ 5383| 174k|yyerrlab1: 5384| 174k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5385| | 5386| | /* Pop stack until we find a state that shifts the error token. */ 5387| 174k| for (;;) 5388| 648k| { 5389| 648k| yyn = yypact[yystate]; 5390| 648k| if (!yypact_value_is_default (yyn)) ------------------ | | 1020| 648k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 648k|#define YYPACT_NINF (-170) | | ------------------ ------------------ | Branch (5390:11): [True: 625k, False: 22.2k] ------------------ 5391| 625k| { 5392| 625k| yyn += YYSYMBOL_YYerror; 5393| 625k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 881| 1.24M|#define YYLAST 480 ------------------ | Branch (5393:15): [True: 614k, False: 11.8k] | Branch (5393:27): [True: 614k, False: 0] | Branch (5393:44): [True: 174k, False: 439k] ------------------ 5394| 174k| { 5395| 174k| yyn = yytable[yyn]; 5396| 174k| if (0 < yyn) ------------------ | Branch (5396:19): [True: 174k, False: 0] ------------------ 5397| 174k| break; 5398| 174k| } 5399| 625k| } 5400| | 5401| | /* Pop the current state because it cannot handle the error token. */ 5402| 473k| if (yyssp == yyss) ------------------ | Branch (5402:11): [True: 0, False: 473k] ------------------ 5403| 0| YYABORT; ------------------ | | 1312| 0|#define YYABORT goto yyabortlab ------------------ 5404| | 5405| | 5406| 473k| yydestruct ("Error: popping", 5407| 473k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, compiler); ------------------ | | 966| 473k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 473k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5408| 473k| YYPOPSTACK (1); ------------------ | | 1931| 473k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5409| 473k| yystate = *yyssp; 5410| 473k| YY_STACK_PRINT (yyss, yyssp); 5411| 473k| } 5412| | 5413| 174k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5414| 174k| *++yyvsp = yylval; 5415| 174k| YY_IGNORE_MAYBE_UNINITIALIZED_END 5416| | 5417| | 5418| | /* Shift the error token. */ 5419| 174k| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 5420| | 5421| 174k| yystate = yyn; 5422| 174k| goto yynewstate; 5423| | 5424| | 5425| |/*-------------------------------------. 5426| || yyacceptlab -- YYACCEPT comes here. | 5427| |`-------------------------------------*/ 5428| 133|yyacceptlab: 5429| 133| yyresult = 0; 5430| 133| goto yyreturnlab; 5431| | 5432| | 5433| |/*-----------------------------------. 5434| || yyabortlab -- YYABORT comes here. | 5435| |`-----------------------------------*/ 5436| 1.59k|yyabortlab: 5437| 1.59k| yyresult = 1; 5438| 1.59k| goto yyreturnlab; 5439| | 5440| | 5441| |/*-----------------------------------------------------------. 5442| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 5443| |`-----------------------------------------------------------*/ 5444| 1|yyexhaustedlab: 5445| 1| yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 48| 1|#define yyerror yara_yyerror ------------------ yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 683| 1|# define YY_(Msgid) Msgid ------------------ 5446| 1| yyresult = 2; 5447| 1| goto yyreturnlab; 5448| | 5449| | 5450| |/*----------------------------------------------------------. 5451| || yyreturnlab -- parsing is finished, clean up and return. | 5452| |`----------------------------------------------------------*/ 5453| 1.72k|yyreturnlab: 5454| 1.72k| if (yychar != YYEMPTY) ------------------ | | 51| 1.72k|#define yychar yara_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 312| 1.72k|#define YYEMPTY -2 ------------------ | Branch (5454:7): [True: 1.59k, False: 134] ------------------ 5455| 1.59k| { 5456| | /* Make sure we have latest lookahead translation. See comments at 5457| | user semantic actions for why this is necessary. */ 5458| 1.59k| yytoken = YYTRANSLATE (yychar); ------------------ | | 899| 1.59k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 1.59k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 1.59k, False: 0] | | | Branch (899:18): [True: 1.59k, False: 0] | | ------------------ | | 900| 1.59k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 1.59k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 1.59k| : YYSYMBOL_YYUNDEF) ------------------ 5459| 1.59k| yydestruct ("Cleanup: discarding lookahead", 5460| 1.59k| yytoken, &yylval, yyscanner, compiler); 5461| 1.59k| } 5462| | /* Do not reclaim the symbols of the rule whose action triggered 5463| | this YYABORT or YYACCEPT. */ 5464| 1.72k| YYPOPSTACK (yylen); ------------------ | | 1931| 1.72k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5465| 1.72k| YY_STACK_PRINT (yyss, yyssp); 5466| 16.7k| while (yyssp != yyss) ------------------ | Branch (5466:10): [True: 15.0k, False: 1.72k] ------------------ 5467| 15.0k| { 5468| 15.0k| yydestruct ("Cleanup: popping", 5469| 15.0k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, compiler); ------------------ | | 966| 15.0k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 15.0k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5470| 15.0k| YYPOPSTACK (1); ------------------ | | 1931| 15.0k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5471| 15.0k| } 5472| 1.72k|#ifndef yyoverflow 5473| 1.72k| if (yyss != yyssa) ------------------ | Branch (5473:7): [True: 45, False: 1.67k] ------------------ 5474| 45| YYSTACK_FREE (yyss); ------------------ | | 791| 45|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 45|#define YYFREE yr_free | | ------------------ ------------------ 5475| 1.72k|#endif 5476| 1.72k| if (yymsg != yymsgbuf) ------------------ | Branch (5476:7): [True: 0, False: 1.72k] ------------------ 5477| 0| YYSTACK_FREE (yymsg); ------------------ | | 791| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5478| 1.72k| return yyresult; 5479| 174k|} grammar.c:yysyntax_error: 1680| 5.83k|{ 1681| 5.83k| enum { YYARGS_MAX = 5 }; 1682| | /* Internationalized format string. */ 1683| 5.83k| const char *yyformat = YY_NULLPTR; ------------------ | | 222| 5.83k|# define YY_NULLPTR ((void*)0) ------------------ 1684| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1685| | one per "expected"). */ 1686| 5.83k| yysymbol_kind_t yyarg[YYARGS_MAX]; 1687| | /* Cumulated lengths of YYARG. */ 1688| 5.83k| YYPTRDIFF_T yysize = 0; ------------------ | | 633| 5.83k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1689| | 1690| | /* Actual size of YYARG. */ 1691| 5.83k| int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); 1692| 5.83k| if (yycount == YYENOMEM) ------------------ | Branch (1692:7): [True: 0, False: 5.83k] ------------------ 1693| 0| return YYENOMEM; 1694| | 1695| 5.83k| switch (yycount) 1696| 5.83k| { 1697| 0|#define YYCASE_(N, S) \ 1698| 0| case N: \ 1699| 0| yyformat = S; \ 1700| 0| break 1701| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1701:5): [True: 0, False: 5.83k] ------------------ 1702| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1698| 0| case N: \ | | ------------------ | | | Branch (1698:7): [True: 0, False: 5.83k] | | ------------------ | | 1699| 0| yyformat = S; \ | | 1700| 0| break ------------------ 1703| 1.08k| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1698| 1.08k| case N: \ | | ------------------ | | | Branch (1698:7): [True: 1.08k, False: 4.74k] | | ------------------ | | 1699| 1.08k| yyformat = S; \ | | 1700| 1.08k| break ------------------ 1704| 4.16k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1698| 4.16k| case N: \ | | ------------------ | | | Branch (1698:7): [True: 4.16k, False: 1.66k] | | ------------------ | | 1699| 4.16k| yyformat = S; \ | | 1700| 4.16k| break ------------------ 1705| 242| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1698| 242| case N: \ | | ------------------ | | | Branch (1698:7): [True: 242, False: 5.58k] | | ------------------ | | 1699| 242| yyformat = S; \ | | 1700| 242| break ------------------ 1706| 333| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1698| 333| case N: \ | | ------------------ | | | Branch (1698:7): [True: 333, False: 5.49k] | | ------------------ | | 1699| 333| yyformat = S; \ | | 1700| 333| break ------------------ 1707| 5.83k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1698| 0| case N: \ | | ------------------ | | | Branch (1698:7): [True: 0, False: 5.83k] | | ------------------ | | 1699| 0| yyformat = S; \ | | 1700| 0| break ------------------ 1708| 5.83k|#undef YYCASE_ 1709| 5.83k| } 1710| | 1711| | /* Compute error message size. Don't count the "%s"s, but reserve 1712| | room for the terminator. */ 1713| 5.83k| yysize = yystrlen (yyformat) - 2 * yycount + 1; ------------------ | | 1539| 5.83k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 210| 5.83k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1714| 5.83k| { 1715| 5.83k| int yyi; 1716| 17.3k| for (yyi = 0; yyi < yycount; ++yyi) ------------------ | Branch (1716:19): [True: 11.4k, False: 5.83k] ------------------ 1717| 11.4k| { 1718| 11.4k| YYPTRDIFF_T yysize1 ------------------ | | 633| 11.4k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1719| 11.4k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); ------------------ | | 222| 11.4k|# define YY_NULLPTR ((void*)0) ------------------ 1720| 11.4k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 793| 11.4k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 661| 11.4k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 210| 22.9k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (210:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1720:13): [True: 11.4k, False: 0] | Branch (1720:34): [True: 11.4k, False: 0] ------------------ 1721| 11.4k| yysize = yysize1; 1722| 0| else 1723| 0| return YYENOMEM; 1724| 11.4k| } 1725| 5.83k| } 1726| | 1727| 5.83k| if (*yymsg_alloc < yysize) ------------------ | Branch (1727:7): [True: 0, False: 5.83k] ------------------ 1728| 0| { 1729| 0| *yymsg_alloc = 2 * yysize; 1730| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1730:14): [True: 0, False: 0] ------------------ 1731| 0| && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) ------------------ | | 793| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 661| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (210:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1731:17): [True: 0, False: 0] ------------------ 1732| 0| *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; ------------------ | | 793| 0|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 661| 0| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (210:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1733| 0| return -1; 1734| 0| } 1735| | 1736| | /* Avoid sprintf, as that infringes on the user's name space. 1737| | Don't have undefined behavior even if the translation 1738| | produced a string with the wrong number of "%s"s. */ 1739| 5.83k| { 1740| 5.83k| char *yyp = *yymsg; 1741| 5.83k| int yyi = 0; 1742| 223k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1742:12): [True: 217k, False: 5.83k] ------------------ 1743| 217k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1743:11): [True: 11.4k, False: 206k] | Branch (1743:26): [True: 11.4k, False: 0] | Branch (1743:48): [True: 11.4k, False: 0] ------------------ 1744| 11.4k| { 1745| 11.4k| yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); 1746| 11.4k| yyformat += 2; 1747| 11.4k| } 1748| 206k| else 1749| 206k| { 1750| 206k| ++yyp; 1751| 206k| ++yyformat; 1752| 206k| } 1753| 5.83k| } 1754| 5.83k| return 0; 1755| 5.83k|} grammar.c:yy_syntax_error_arguments: 1627| 5.83k|{ 1628| | /* Actual size of YYARG. */ 1629| 5.83k| int yycount = 0; 1630| | /* There are many possibilities here to consider: 1631| | - If this state is a consistent state with a default action, then 1632| | the only way this function was invoked is if the default action 1633| | is an error action. In that case, don't check for expected 1634| | tokens because there are none. 1635| | - The only way there can be no lookahead present (in yychar) is if 1636| | this state is a consistent state with a default action. Thus, 1637| | detecting the absence of a lookahead is sufficient to determine 1638| | that there is no unexpected or expected token to report. In that 1639| | case, just report a simple "syntax error". 1640| | - Don't assume there isn't a lookahead just because this state is a 1641| | consistent state with a default action. There might have been a 1642| | previous inconsistent state, consistent state with a non-default 1643| | action, or user semantic action that manipulated yychar. 1644| | - Of course, the expected token list depends on states to have 1645| | correct lookahead information, and it depends on the parser not 1646| | to perform extra reductions after fetching a lookahead from the 1647| | scanner and before detecting a syntax error. Thus, state merging 1648| | (from LALR or IELR) and default reductions corrupt the expected 1649| | token list. However, the list is correct for canonical LR with 1650| | one exception: it will still contain any token that will not be 1651| | accepted due to an error action in a later state. 1652| | */ 1653| 5.83k| if (yyctx->yytoken != YYSYMBOL_YYEMPTY) ------------------ | Branch (1653:7): [True: 5.83k, False: 0] ------------------ 1654| 5.83k| { 1655| 5.83k| int yyn; 1656| 5.83k| if (yyarg) ------------------ | Branch (1656:11): [True: 5.83k, False: 0] ------------------ 1657| 5.83k| yyarg[yycount] = yyctx->yytoken; 1658| 5.83k| ++yycount; 1659| 5.83k| yyn = yypcontext_expected_tokens (yyctx, 1660| 5.83k| yyarg ? yyarg + 1 : yyarg, yyargn - 1); ------------------ | Branch (1660:41): [True: 5.83k, False: 0] ------------------ 1661| 5.83k| if (yyn == YYENOMEM) ------------------ | Branch (1661:11): [True: 0, False: 5.83k] ------------------ 1662| 0| return YYENOMEM; 1663| 5.83k| else 1664| 5.83k| yycount += yyn; 1665| 5.83k| } 1666| 5.83k| return yycount; 1667| 5.83k|} grammar.c:yypcontext_expected_tokens: 1503| 5.83k|{ 1504| | /* Actual size of YYARG. */ 1505| 5.83k| int yycount = 0; 1506| 5.83k| int yyn = yypact[+*yyctx->yyssp]; 1507| 5.83k| if (!yypact_value_is_default (yyn)) ------------------ | | 1020| 5.83k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 5.83k|#define YYPACT_NINF (-170) | | ------------------ ------------------ | Branch (1507:7): [True: 5.83k, False: 0] ------------------ 1508| 5.83k| { 1509| | /* Start YYX at -YYN if negative to avoid negative indexes in 1510| | YYCHECK. In other words, skip the first -YYN actions for 1511| | this state because they are default actions. */ 1512| 5.83k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1512:22): [True: 241, False: 5.59k] ------------------ 1513| | /* Stay within bounds of both yycheck and yytname. */ 1514| 5.83k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 881| 5.83k|#define YYLAST 480 ------------------ 1515| 5.83k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 884| 5.83k|#define YYNTOKENS 84 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 884| 5.83k|#define YYNTOKENS 84 ------------------ | Branch (1515:20): [True: 0, False: 5.83k] ------------------ 1516| 5.83k| int yyx; 1517| 410k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1517:28): [True: 405k, False: 4.74k] ------------------ 1518| 405k| if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror ------------------ | Branch (1518:13): [True: 12.0k, False: 393k] | Branch (1518:42): [True: 11.0k, False: 938] ------------------ 1519| 405k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 1025| 0| 0 ------------------ | Branch (1519:16): [Folded - Ignored] ------------------ 1520| 11.0k| { 1521| 11.0k| if (!yyarg) ------------------ | Branch (1521:17): [True: 0, False: 11.0k] ------------------ 1522| 0| ++yycount; 1523| 11.0k| else if (yycount == yyargn) ------------------ | Branch (1523:22): [True: 1.08k, False: 10.0k] ------------------ 1524| 1.08k| return 0; 1525| 10.0k| else 1526| 10.0k| yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); ------------------ | | 210| 10.0k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1527| 11.0k| } 1528| 5.83k| } 1529| 4.74k| if (yyarg && yycount == 0 && 0 < yyargn) ------------------ | Branch (1529:7): [True: 4.74k, False: 0] | Branch (1529:16): [True: 0, False: 4.74k] | Branch (1529:32): [True: 0, False: 0] ------------------ 1530| 0| yyarg[0] = YYSYMBOL_YYEMPTY; 1531| 4.74k| return yycount; 1532| 5.83k|} grammar.c:yytnamerr: 1583| 22.9k|{ 1584| 22.9k| if (*yystr == '"') ------------------ | Branch (1584:7): [True: 18.4k, False: 4.50k] ------------------ 1585| 18.4k| { 1586| 18.4k| YYPTRDIFF_T yyn = 0; ------------------ | | 633| 18.4k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1587| 18.4k| char const *yyp = yystr; 1588| 18.4k| for (;;) 1589| 195k| switch (*++yyp) 1590| 195k| { 1591| 0| case '\'': ------------------ | Branch (1591:11): [True: 0, False: 195k] ------------------ 1592| 0| case ',': ------------------ | Branch (1592:11): [True: 0, False: 195k] ------------------ 1593| 0| goto do_not_strip_quotes; 1594| | 1595| 0| case '\\': ------------------ | Branch (1595:11): [True: 0, False: 195k] ------------------ 1596| 0| if (*++yyp != '\\') ------------------ | Branch (1596:17): [True: 0, False: 0] ------------------ 1597| 0| goto do_not_strip_quotes; 1598| 0| else 1599| 0| goto append; 1600| | 1601| 0| append: 1602| 177k| default: ------------------ | Branch (1602:11): [True: 177k, False: 18.4k] ------------------ 1603| 177k| if (yyres) ------------------ | Branch (1603:17): [True: 88.7k, False: 88.7k] ------------------ 1604| 88.7k| yyres[yyn] = *yyp; 1605| 177k| yyn++; 1606| 177k| break; 1607| | 1608| 18.4k| case '"': ------------------ | Branch (1608:11): [True: 18.4k, False: 177k] ------------------ 1609| 18.4k| if (yyres) ------------------ | Branch (1609:17): [True: 9.22k, False: 9.22k] ------------------ 1610| 9.22k| yyres[yyn] = '\0'; 1611| 18.4k| return yyn; 1612| 195k| } 1613| 0| do_not_strip_quotes: ; 1614| 0| } 1615| | 1616| 4.50k| if (yyres) ------------------ | Branch (1616:7): [True: 2.25k, False: 2.25k] ------------------ 1617| 2.25k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1555| 2.25k|# define yystpcpy stpcpy ------------------ 1618| 2.25k| else 1619| 2.25k| return yystrlen (yystr); ------------------ | | 1539| 2.25k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 210| 2.25k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1620| 4.50k|} grammar.c:yydestruct: 1765| 646k|{ 1766| 646k| YY_USE (yyvaluep); ------------------ | | 706| 646k|# define YY_USE(E) ((void) (E)) ------------------ 1767| 646k| YY_USE (yyscanner); ------------------ | | 706| 646k|# define YY_USE(E) ((void) (E)) ------------------ 1768| 646k| YY_USE (compiler); ------------------ | | 706| 646k|# define YY_USE(E) ((void) (E)) ------------------ 1769| 646k| if (!yymsg) ------------------ | Branch (1769:7): [True: 0, False: 646k] ------------------ 1770| 0| yymsg = "Deleting"; 1771| 646k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1772| | 1773| 646k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1774| 646k| switch (yykind) 1775| 646k| { 1776| 43.2k| case YYSYMBOL__IDENTIFIER_: /* "identifier" */ ------------------ | Branch (1776:5): [True: 43.2k, False: 603k] ------------------ 1777| 43.2k|#line 313 "libyara/grammar.y" 1778| 43.2k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1779| 43.2k|#line 1780 "libyara/grammar.c" 1780| 43.2k| break; 1781| | 1782| 6.32k| case YYSYMBOL__STRING_IDENTIFIER_: /* "string identifier" */ ------------------ | Branch (1782:5): [True: 6.32k, False: 639k] ------------------ 1783| 6.32k|#line 317 "libyara/grammar.y" 1784| 6.32k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1785| 6.32k|#line 1786 "libyara/grammar.c" 1786| 6.32k| break; 1787| | 1788| 1.16k| case YYSYMBOL__STRING_COUNT_: /* "string count" */ ------------------ | Branch (1788:5): [True: 1.16k, False: 645k] ------------------ 1789| 1.16k|#line 314 "libyara/grammar.y" 1790| 1.16k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1791| 1.16k|#line 1792 "libyara/grammar.c" 1792| 1.16k| break; 1793| | 1794| 1.17k| case YYSYMBOL__STRING_OFFSET_: /* "string offset" */ ------------------ | Branch (1794:5): [True: 1.17k, False: 645k] ------------------ 1795| 1.17k|#line 315 "libyara/grammar.y" 1796| 1.17k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1797| 1.17k|#line 1798 "libyara/grammar.c" 1798| 1.17k| break; 1799| | 1800| 1.75k| case YYSYMBOL__STRING_LENGTH_: /* "string length" */ ------------------ | Branch (1800:5): [True: 1.75k, False: 644k] ------------------ 1801| 1.75k|#line 316 "libyara/grammar.y" 1802| 1.75k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1803| 1.75k|#line 1804 "libyara/grammar.c" 1804| 1.75k| break; 1805| | 1806| 209| case YYSYMBOL__STRING_IDENTIFIER_WITH_WILDCARD_: /* "string identifier with wildcard" */ ------------------ | Branch (1806:5): [True: 209, False: 646k] ------------------ 1807| 209|#line 318 "libyara/grammar.y" 1808| 209| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1809| 209|#line 1810 "libyara/grammar.c" 1810| 209| break; 1811| | 1812| 3.45k| case YYSYMBOL__TEXT_STRING_: /* "text string" */ ------------------ | Branch (1812:5): [True: 3.45k, False: 642k] ------------------ 1813| 3.45k|#line 319 "libyara/grammar.y" 1814| 3.45k| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1815| 3.45k|#line 1816 "libyara/grammar.c" 1816| 3.45k| break; 1817| | 1818| 457| case YYSYMBOL__HEX_STRING_: /* "hex string" */ ------------------ | Branch (1818:5): [True: 457, False: 645k] ------------------ 1819| 457|#line 320 "libyara/grammar.y" 1820| 457| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1821| 457|#line 1822 "libyara/grammar.c" 1822| 457| break; 1823| | 1824| 3.62k| case YYSYMBOL__REGEXP_: /* "regular expression" */ ------------------ | Branch (1824:5): [True: 3.62k, False: 642k] ------------------ 1825| 3.62k|#line 321 "libyara/grammar.y" 1826| 3.62k| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1827| 3.62k|#line 1828 "libyara/grammar.c" 1828| 3.62k| break; 1829| | 1830| 42| case YYSYMBOL_string_modifiers: /* string_modifiers */ ------------------ | Branch (1830:5): [True: 42, False: 646k] ------------------ 1831| 42|#line 334 "libyara/grammar.y" 1832| 42| { 1833| 42| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1833:7): [True: 10, False: 32] ------------------ 1834| 10| { 1835| 10| yr_free(((*yyvaluep).modifier).alphabet); 1836| 10| ((*yyvaluep).modifier).alphabet = NULL; 1837| 10| } 1838| 42|} 1839| 42|#line 1840 "libyara/grammar.c" 1840| 42| break; 1841| | 1842| 0| case YYSYMBOL_string_modifier: /* string_modifier */ ------------------ | Branch (1842:5): [True: 0, False: 646k] ------------------ 1843| 0|#line 326 "libyara/grammar.y" 1844| 0| { 1845| 0| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1845:7): [True: 0, False: 0] ------------------ 1846| 0| { 1847| 0| yr_free(((*yyvaluep).modifier).alphabet); 1848| 0| ((*yyvaluep).modifier).alphabet = NULL; 1849| 0| } 1850| 0|} 1851| 0|#line 1852 "libyara/grammar.c" 1852| 0| break; 1853| | 1854| 114| case YYSYMBOL_arguments: /* arguments */ ------------------ | Branch (1854:5): [True: 114, False: 646k] ------------------ 1855| 114|#line 323 "libyara/grammar.y" 1856| 114| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1857| 114|#line 1858 "libyara/grammar.c" 1858| 114| break; 1859| | 1860| 2.15k| case YYSYMBOL_arguments_list: /* arguments_list */ ------------------ | Branch (1860:5): [True: 2.15k, False: 644k] ------------------ 1861| 2.15k|#line 324 "libyara/grammar.y" 1862| 2.15k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1863| 2.15k|#line 1864 "libyara/grammar.c" 1864| 2.15k| break; 1865| | 1866| 582k| default: ------------------ | Branch (1866:7): [True: 582k, False: 63.6k] ------------------ 1867| 582k| break; 1868| 646k| } 1869| 646k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1870| 646k|} yr_hash: 94| 217k|{ 95| 217k| const uint8_t* b = (uint8_t*) buffer; 96| | 97| 217k| uint32_t result = seed; 98| 217k| size_t i; 99| | 100| 217k| if (len == 0) ------------------ | Branch (100:7): [True: 0, False: 217k] ------------------ 101| 0| return result; 102| | 103| 1.90M| for (i = len - 1; i > 0; i--) ------------------ | Branch (103:21): [True: 1.69M, False: 217k] ------------------ 104| 1.69M| { 105| 1.69M| result ^= ROTATE_INT32(byte_to_int32[*b], i); ------------------ | | 46| 1.69M|#define ROTATE_INT32(x, shift) rotl32(x, shift % 32) ------------------ 106| 1.69M| b++; 107| 1.69M| } 108| | 109| 217k| result ^= byte_to_int32[*b]; 110| 217k| return result; 111| 217k|} yr_hash_table_create: 178| 8.62k|{ 179| 8.62k| YR_HASH_TABLE* new_table; 180| 8.62k| int i; 181| | 182| 8.62k| new_table = (YR_HASH_TABLE*) yr_malloc( 183| 8.62k| sizeof(YR_HASH_TABLE) + size * sizeof(YR_HASH_TABLE_ENTRY*)); 184| | 185| 8.62k| if (new_table == NULL) ------------------ | Branch (185:7): [True: 0, False: 8.62k] ------------------ 186| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 187| | 188| 8.62k| new_table->size = size; 189| | 190| 46.5M| for (i = 0; i < size; i++) new_table->buckets[i] = NULL; ------------------ | Branch (190:15): [True: 46.5M, False: 8.62k] ------------------ 191| | 192| 8.62k| *table = new_table; 193| | 194| 8.62k| return ERROR_SUCCESS; ------------------ | | 40| 8.62k|#define ERROR_SUCCESS 0 ------------------ 195| 8.62k|} yr_hash_table_clean: 200| 18.5k|{ 201| 18.5k| YR_HASH_TABLE_ENTRY* entry; 202| 18.5k| YR_HASH_TABLE_ENTRY* next_entry; 203| | 204| 18.5k| int i; 205| | 206| 18.5k| if (table == NULL) ------------------ | Branch (206:7): [True: 0, False: 18.5k] ------------------ 207| 0| return; 208| | 209| 145M| for (i = 0; i < table->size; i++) ------------------ | Branch (209:15): [True: 145M, False: 18.5k] ------------------ 210| 145M| { 211| 145M| entry = table->buckets[i]; 212| | 213| 145M| while (entry != NULL) ------------------ | Branch (213:12): [True: 28.8k, False: 145M] ------------------ 214| 28.8k| { 215| 28.8k| next_entry = entry->next; 216| | 217| 28.8k| if (free_value != NULL) ------------------ | Branch (217:11): [True: 360, False: 28.5k] ------------------ 218| 360| free_value(entry->value); 219| | 220| 28.8k| if (entry->ns != NULL) ------------------ | Branch (220:11): [True: 11.4k, False: 17.4k] ------------------ 221| 11.4k| yr_free(entry->ns); 222| | 223| 28.8k| yr_free(entry->key); 224| 28.8k| yr_free(entry); 225| | 226| 28.8k| entry = next_entry; 227| 28.8k| } 228| | 229| 145M| table->buckets[i] = NULL; 230| 145M| } 231| 18.5k|} yr_hash_table_destroy: 236| 8.62k|{ 237| 8.62k| yr_hash_table_clean(table, free_value); 238| 8.62k| yr_free(table); 239| 8.62k|} yr_hash_table_iterate: 246| 10.0k|{ 247| 10.0k| int result; 248| 10.0k| YR_HASH_TABLE_ENTRY* entry; 249| | 250| 10.0k| if (table == NULL) ------------------ | Branch (250:7): [True: 0, False: 10.0k] ------------------ 251| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 252| | 253| 10.0M| for (int i = 0; i < table->size; i++) ------------------ | Branch (253:19): [True: 10.0M, False: 9.88k] ------------------ 254| 10.0M| { 255| 10.0M| entry = table->buckets[i]; 256| 10.0M| while (entry != NULL) ------------------ | Branch (256:12): [True: 1.27k, False: 10.0M] ------------------ 257| 1.27k| { 258| 1.27k| if ((entry->ns == NULL && ns == NULL) ------------------ | Branch (258:12): [True: 0, False: 1.27k] | Branch (258:33): [True: 0, False: 0] ------------------ 259| 1.27k| || (entry->ns != NULL && ns != NULL && !strcmp(entry->ns, ns))) ------------------ | Branch (259:15): [True: 1.27k, False: 0] | Branch (259:36): [True: 1.27k, False: 0] | Branch (259:50): [True: 1.27k, False: 0] ------------------ 260| 1.27k| { 261| 1.27k| result = iterate_func( 262| 1.27k| entry->key, entry->key_length, entry->value, data); 263| | 264| 1.27k| if (result != ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (264:13): [True: 180, False: 1.09k] ------------------ 265| 180| return result; 266| 1.27k| } 267| 1.09k| entry = entry->next; 268| 1.09k| } 269| 10.0M| } 270| 9.88k| return ERROR_SUCCESS; ------------------ | | 40| 9.88k|#define ERROR_SUCCESS 0 ------------------ 271| 10.0k|} yr_hash_table_lookup_raw_key: 278| 134k|{ 279| 134k| return _yr_hash_table_lookup(table, key, key_length, ns, false); 280| 134k|} yr_hash_table_add_raw_key: 297| 28.8k|{ 298| 28.8k| YR_HASH_TABLE_ENTRY* entry; 299| 28.8k| uint32_t bucket_index; 300| | 301| 28.8k| entry = (YR_HASH_TABLE_ENTRY*) yr_malloc(sizeof(YR_HASH_TABLE_ENTRY)); 302| | 303| 28.8k| if (entry == NULL) ------------------ | Branch (303:7): [True: 0, False: 28.8k] ------------------ 304| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 305| | 306| 28.8k| entry->key = yr_malloc(key_length); 307| | 308| 28.8k| if (entry->key == NULL) ------------------ | Branch (308:7): [True: 0, False: 28.8k] ------------------ 309| 0| { 310| 0| yr_free(entry); 311| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 312| 0| } 313| | 314| 28.8k| if (ns != NULL) ------------------ | Branch (314:7): [True: 11.4k, False: 17.4k] ------------------ 315| 11.4k| { 316| 11.4k| entry->ns = yr_strdup(ns); 317| | 318| 11.4k| if (entry->ns == NULL) ------------------ | Branch (318:9): [True: 0, False: 11.4k] ------------------ 319| 0| { 320| 0| yr_free(entry->key); 321| 0| yr_free(entry); 322| | 323| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 324| 0| } 325| 11.4k| } 326| 17.4k| else 327| 17.4k| { 328| 17.4k| entry->ns = NULL; 329| 17.4k| } 330| | 331| 28.8k| entry->key_length = key_length; 332| 28.8k| entry->value = value; 333| | 334| 28.8k| memcpy(entry->key, key, key_length); 335| | 336| 28.8k| bucket_index = yr_hash(0, key, key_length); 337| | 338| 28.8k| if (ns != NULL) ------------------ | Branch (338:7): [True: 11.4k, False: 17.4k] ------------------ 339| 11.4k| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 340| | 341| 28.8k| bucket_index = bucket_index % table->size; 342| | 343| 28.8k| entry->next = table->buckets[bucket_index]; 344| 28.8k| table->buckets[bucket_index] = entry; 345| | 346| 28.8k| return ERROR_SUCCESS; ------------------ | | 40| 28.8k|#define ERROR_SUCCESS 0 ------------------ 347| 28.8k|} yr_hash_table_lookup: 353| 26.8k|{ 354| 26.8k| return yr_hash_table_lookup_raw_key(table, (void*) key, strlen(key), ns); 355| 26.8k|} yr_hash_table_add: 370| 360|{ 371| 360| return yr_hash_table_add_raw_key(table, (void*) key, strlen(key), ns, value); 372| 360|} yr_hash_table_add_uint32: 379| 12.1k|{ 380| 12.1k| return yr_hash_table_add_uint32_raw_key( 381| 12.1k| table, (void*) key, strlen(key), ns, value); 382| 12.1k|} yr_hash_table_lookup_uint32: 388| 52.1k|{ 389| 52.1k| return yr_hash_table_lookup_uint32_raw_key( 390| 52.1k| table, (void*) key, strlen(key), ns); 391| 52.1k|} yr_hash_table_add_uint32_raw_key: 399| 28.5k|{ 400| | // Don't allow values equal to UINT32_MAX or UINT32_MAX - 1. 401| 28.5k| if (value >= UINT32_MAX - 1) ------------------ | Branch (401:7): [True: 0, False: 28.5k] ------------------ 402| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 403| | 404| | // Add +1 to the value in order to avoid putting a NULL pointer in the 405| | // hash table once the integer is casted to a pointer. This is undone 406| | // by yr_hash_table_lookup_uint32. 407| 28.5k| return yr_hash_table_add_raw_key( 408| 28.5k| table, key, key_length, ns, (void*) (size_t) (value + 1)); 409| 28.5k|} yr_hash_table_lookup_uint32_raw_key: 416| 107k|{ 417| 107k| void* ptr = yr_hash_table_lookup_raw_key(table, key, key_length, ns); 418| | 419| 107k| if (ptr == NULL) ------------------ | Branch (419:7): [True: 44.9k, False: 62.5k] ------------------ 420| 44.9k| return UINT32_MAX; 421| | 422| | // Remove one from the pointe in order to get the original value. 423| | // See comment in yr_hash_table_add_uint32_raw_key. 424| 62.5k| return ((uint32_t) (size_t) (uint8_t*) ptr) - 1; 425| 107k|} hash.c:rotl32: 41| 1.69M|{ 42| 1.69M| assert(shift < 32); 43| 1.69M| return (x << shift) | (x >> (-shift & 31)); 44| 1.69M|} hash.c:_yr_hash_table_lookup: 124| 134k|{ 125| 134k| YR_HASH_TABLE_ENTRY* entry; 126| 134k| YR_HASH_TABLE_ENTRY* prev_entry; 127| | 128| 134k| void* result; 129| | 130| 134k| uint32_t bucket_index = yr_hash(0, key, key_length); 131| | 132| 134k| if (ns != NULL) ------------------ | Branch (132:7): [True: 43.0k, False: 91.2k] ------------------ 133| 43.0k| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 134| | 135| 134k| bucket_index = bucket_index % table->size; 136| 134k| prev_entry = NULL; 137| 134k| entry = table->buckets[bucket_index]; 138| | 139| 135k| while (entry != NULL) ------------------ | Branch (139:10): [True: 65.8k, False: 69.9k] ------------------ 140| 65.8k| { 141| 65.8k| int key_match = 142| 65.8k| ((entry->key_length == key_length) && ------------------ | Branch (142:10): [True: 65.1k, False: 718] ------------------ 143| 65.8k| (memcmp(entry->key, key, key_length) == 0)); ------------------ | Branch (143:10): [True: 64.3k, False: 784] ------------------ 144| | 145| 65.8k| int ns_match = 146| 65.8k| ((entry->ns == ns) || ------------------ | Branch (146:10): [True: 39.4k, False: 26.3k] ------------------ 147| 65.8k| (entry->ns != NULL && ns != NULL && strcmp(entry->ns, ns) == 0)); ------------------ | Branch (147:11): [True: 26.3k, False: 0] | Branch (147:32): [True: 25.7k, False: 666] | Branch (147:46): [True: 25.7k, False: 0] ------------------ 148| | 149| 65.8k| if (key_match && ns_match) ------------------ | Branch (149:9): [True: 64.3k, False: 1.50k] | Branch (149:22): [True: 64.3k, False: 0] ------------------ 150| 64.3k| { 151| 64.3k| result = entry->value; 152| | 153| 64.3k| if (remove) ------------------ | Branch (153:11): [True: 0, False: 64.3k] ------------------ 154| 0| { 155| 0| if (prev_entry == NULL) ------------------ | Branch (155:13): [True: 0, False: 0] ------------------ 156| 0| table->buckets[bucket_index] = entry->next; 157| 0| else 158| 0| prev_entry->next = entry->next; 159| | 160| 0| if (entry->ns != NULL) ------------------ | Branch (160:13): [True: 0, False: 0] ------------------ 161| 0| yr_free(entry->ns); 162| | 163| 0| yr_free(entry->key); 164| 0| yr_free(entry); 165| 0| } 166| | 167| 64.3k| return result; 168| 64.3k| } 169| | 170| 1.50k| prev_entry = entry; 171| 1.50k| entry = entry->next; 172| 1.50k| } 173| | 174| 69.9k| return NULL; 175| 134k|} hex_yyparse: 1000| 1.27k|{ 1001| |/* Lookahead token kind. */ 1002| 1.27k|int yychar; 1003| | 1004| | 1005| |/* The semantic value of the lookahead symbol. */ 1006| |/* Default value used for initialization, for pacifying older GCCs 1007| | or non-GCC compilers. */ 1008| 1.27k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 403| 1.27k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1009| 1.27k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 403| 1.27k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1010| | 1011| | /* Number of syntax errors so far. */ 1012| 1.27k| int yynerrs = 0; 1013| | 1014| 1.27k| yy_state_fast_t yystate = 0; 1015| | /* Number of tokens to shift before error messages enabled. */ 1016| 1.27k| int yyerrstatus = 0; 1017| | 1018| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1019| | to reallocate them elsewhere. */ 1020| | 1021| | /* Their size. */ 1022| 1.27k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 310| 1.27k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 904| 1.27k|# define YYINITDEPTH 200 ------------------ 1023| | 1024| | /* The state stack: array, bottom, top. */ 1025| 1.27k| yy_state_t yyssa[YYINITDEPTH]; 1026| 1.27k| yy_state_t *yyss = yyssa; 1027| 1.27k| yy_state_t *yyssp = yyss; 1028| | 1029| | /* The semantic value stack: array, bottom, top. */ 1030| 1.27k| YYSTYPE yyvsa[YYINITDEPTH]; 1031| 1.27k| YYSTYPE *yyvs = yyvsa; 1032| 1.27k| YYSTYPE *yyvsp = yyvs; 1033| | 1034| 1.27k| int yyn; 1035| | /* The return value of yyparse. */ 1036| 1.27k| int yyresult; 1037| | /* Lookahead symbol kind. */ 1038| 1.27k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1039| | /* The variables used to return semantic value and location from the 1040| | action routines. */ 1041| 1.27k| YYSTYPE yyval; 1042| | 1043| | 1044| | 1045| 1.27k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1046| | 1047| | /* The number of symbols on the RHS of the reduced rule. 1048| | Keep to zero when no symbol should be popped. */ 1049| 1.27k| int yylen = 0; 1050| | 1051| 1.27k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 895| 1.27k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1052| | 1053| 1.27k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 50| 1.27k|#define yychar hex_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 66| 1.27k|#define YYEMPTY -2 ------------------ 1054| | 1055| 1.27k| goto yysetstate; 1056| | 1057| | 1058| |/*------------------------------------------------------------. 1059| || yynewstate -- push a new state, which is found in yystate. | 1060| |`------------------------------------------------------------*/ 1061| 350k|yynewstate: 1062| | /* In all cases, when you get here, the value and location stacks 1063| | have just been pushed. So pushing a state here evens the stacks. */ 1064| 350k| yyssp++; 1065| | 1066| | 1067| |/*--------------------------------------------------------------------. 1068| || yysetstate -- set current state (the top of the stack) to yystate. | 1069| |`--------------------------------------------------------------------*/ 1070| 351k|yysetstate: 1071| 351k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 895| 351k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1072| 351k| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 426| 351k|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (426:31): [Folded - Ignored] | | | Branch (426:37): [True: 0, False: 0] | | | Branch (426:37): [True: 0, False: 0] | | ------------------ ------------------ 1073| 351k| YY_IGNORE_USELESS_CAST_BEGIN 1074| 351k| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 121| 351k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1075| 351k| YY_IGNORE_USELESS_CAST_END 1076| 351k| YY_STACK_PRINT (yyss, yyssp); 1077| | 1078| 351k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1078:7): [True: 338, False: 351k] ------------------ 1079| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1080| | YYNOMEM; 1081| |#else 1082| 338| { 1083| | /* Get the current used size of the three stacks, in elements. */ 1084| 338| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 310| 338|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1085| | 1086| |# if defined yyoverflow 1087| | { 1088| | /* Give user a chance to reallocate the stack. Use copies of 1089| | these so that the &'s don't force the real ones into 1090| | memory. */ 1091| | yy_state_t *yyss1 = yyss; 1092| | YYSTYPE *yyvs1 = yyvs; 1093| | 1094| | /* Each stack pointer address is followed by the size of the 1095| | data in use in that stack, in bytes. This used to be a 1096| | conditional around just the two extra args, but that might 1097| | be undefined if yyoverflow is a macro. */ 1098| | yyoverflow (YY_("memory exhausted"), 1099| | &yyss1, yysize * YYSIZEOF (*yyssp), 1100| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1101| | &yystacksize); 1102| | yyss = yyss1; 1103| | yyvs = yyvs1; 1104| | } 1105| |# else /* defined YYSTACK_RELOCATE */ 1106| | /* Extend the stack our own way. */ 1107| 338| if (YYMAXDEPTH <= yystacksize) ------------------ | | 915| 338|# define YYMAXDEPTH 10000 ------------------ | Branch (1107:11): [True: 6, False: 332] ------------------ 1108| 6| YYNOMEM; ------------------ | | 746| 6|#define YYNOMEM goto yyexhaustedlab ------------------ 1109| 332| yystacksize *= 2; 1110| 332| if (YYMAXDEPTH < yystacksize) ------------------ | | 915| 332|# define YYMAXDEPTH 10000 ------------------ | Branch (1110:11): [True: 18, False: 314] ------------------ 1111| 18| yystacksize = YYMAXDEPTH; ------------------ | | 915| 18|# define YYMAXDEPTH 10000 ------------------ 1112| | 1113| 332| { 1114| 332| yy_state_t *yyss1 = yyss; 1115| 332| union yyalloc *yyptr = 1116| 332| YY_CAST (union yyalloc *, ------------------ | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1117| 332| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1118| 332| if (! yyptr) ------------------ | Branch (1118:13): [True: 0, False: 332] ------------------ 1119| 0| YYNOMEM; ------------------ | | 746| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1120| 332| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 523| 332| do \ | | 524| 332| { \ | | 525| 332| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 310| 332|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 526| 332| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 541| 332| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 527| 332| Stack = &yyptr->Stack_alloc; \ | | 528| 332| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 507| 332|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 529| 332| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 530| 332| } \ | | 531| 332| while (0) | | ------------------ | | | Branch (531:12): [Folded - Ignored] | | ------------------ ------------------ 1121| 332| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 523| 332| do \ | | 524| 332| { \ | | 525| 332| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 310| 332|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 526| 332| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 541| 332| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 527| 332| Stack = &yyptr->Stack_alloc; \ | | 528| 332| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 507| 332|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 529| 332| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 343| 332|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 332|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 530| 332| } \ | | 531| 332| while (0) | | ------------------ | | | Branch (531:12): [Folded - Ignored] | | ------------------ ------------------ 1122| 332|# undef YYSTACK_RELOCATE 1123| 332| if (yyss1 != yyssa) ------------------ | Branch (1123:13): [True: 219, False: 113] ------------------ 1124| 219| YYSTACK_FREE (yyss1); ------------------ | | 468| 219|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 95| 219|#define YYFREE yr_free | | ------------------ ------------------ 1125| 332| } 1126| 0|# endif 1127| | 1128| 0| yyssp = yyss + yysize - 1; 1129| 332| yyvsp = yyvs + yysize - 1; 1130| | 1131| 332| YY_IGNORE_USELESS_CAST_BEGIN 1132| 332| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 895| 332|# define YYDPRINTF(Args) ((void) 0) ------------------ 1133| 332| YY_CAST (long, yystacksize))); 1134| 332| YY_IGNORE_USELESS_CAST_END 1135| | 1136| 332| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1136:11): [True: 0, False: 332] ------------------ 1137| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1138| 332| } 1139| 351k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1140| | 1141| | 1142| 351k| if (yystate == YYFINAL) ------------------ | | 556| 351k|#define YYFINAL 11 ------------------ | Branch (1142:7): [True: 1.02k, False: 350k] ------------------ 1143| 1.02k| YYACCEPT; ------------------ | | 743| 1.02k|#define YYACCEPT goto yyacceptlab ------------------ 1144| | 1145| 350k| goto yybackup; 1146| | 1147| | 1148| |/*-----------. 1149| || yybackup. | 1150| |`-----------*/ 1151| 350k|yybackup: 1152| | /* Do appropriate processing given the current state. Read a 1153| | lookahead token if we need one and don't already have one. */ 1154| | 1155| | /* First try to decide what to do without reference to lookahead token. */ 1156| 350k| yyn = yypact[yystate]; 1157| 350k| if (yypact_value_is_default (yyn)) ------------------ | | 652| 350k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 649| 350k|#define YYPACT_NINF (-13) | | ------------------ | | | Branch (652:3): [True: 178k, False: 172k] | | ------------------ ------------------ 1158| 178k| goto yydefault; 1159| | 1160| | /* Not known => get a lookahead token if don't already have one. */ 1161| | 1162| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1163| 172k| if (yychar == YYEMPTY) ------------------ | | 50| 172k|#define yychar hex_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 66| 172k|#define YYEMPTY -2 ------------------ | Branch (1163:7): [True: 160k, False: 11.5k] ------------------ 1164| 160k| { 1165| 160k| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 895| 160k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1166| 160k| yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 50| 160k|#define yychar hex_yychar ------------------ yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 47| 160k|#define yylex hex_yylex ------------------ 1167| 160k| } 1168| | 1169| 172k| if (yychar <= YYEOF) ------------------ | | 50| 172k|#define yychar hex_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 67| 172k|#define YYEOF 0 ------------------ | Branch (1169:7): [True: 1.19k, False: 170k] ------------------ 1170| 1.19k| { 1171| 1.19k| yychar = YYEOF; ------------------ | | 50| 1.19k|#define yychar hex_yychar ------------------ yychar = YYEOF; ------------------ | | 67| 1.19k|#define YYEOF 0 ------------------ 1172| 1.19k| yytoken = YYSYMBOL_YYEOF; 1173| 1.19k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 895| 1.19k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1174| 1.19k| } 1175| 170k| else if (yychar == YYerror) ------------------ | | 50| 170k|#define yychar hex_yychar ------------------ else if (yychar == YYerror) ------------------ | | 68| 170k|#define YYerror 256 ------------------ | Branch (1175:12): [True: 0, False: 170k] ------------------ 1176| 0| { 1177| | /* The scanner already issued an error message, process directly 1178| | to error recovery. But do not keep the error token as 1179| | lookahead, it is too special and may lead us to an endless 1180| | loop in error recovery. */ 1181| 0| yychar = YYUNDEF; ------------------ | | 50| 0|#define yychar hex_yychar ------------------ yychar = YYUNDEF; ------------------ | | 69| 0|#define YYUNDEF 257 ------------------ 1182| 0| yytoken = YYSYMBOL_YYerror; 1183| 0| goto yyerrlab1; 1184| 0| } 1185| 170k| else 1186| 170k| { 1187| 170k| yytoken = YYTRANSLATE (yychar); ------------------ | | 576| 170k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 170k|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 170k, False: 0] | | | Branch (576:18): [True: 170k, False: 0] | | ------------------ | | 577| 170k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 170k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 170k| : YYSYMBOL_YYUNDEF) ------------------ 1188| 170k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1189| 170k| } 1190| | 1191| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1192| | detect an error, take that action. */ 1193| 172k| yyn += yytoken; 1194| 172k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 558| 171k|#define YYLAST 35 ------------------ | Branch (1194:7): [True: 709, False: 171k] | Branch (1194:18): [True: 0, False: 171k] | Branch (1194:34): [True: 8.43k, False: 163k] ------------------ 1195| 9.14k| goto yydefault; 1196| 163k| yyn = yytable[yyn]; 1197| 163k| if (yyn <= 0) ------------------ | Branch (1197:7): [True: 2.61k, False: 160k] ------------------ 1198| 2.61k| { 1199| 2.61k| if (yytable_value_is_error (yyn)) ------------------ | | 657| 2.61k| 0 | | ------------------ | | | Branch (657:3): [Folded - Ignored] | | ------------------ ------------------ 1200| 0| goto yyerrlab; 1201| 2.61k| yyn = -yyn; 1202| 2.61k| goto yyreduce; 1203| 2.61k| } 1204| | 1205| | /* Count tokens shifted since error; after three, turn off error 1206| | status. */ 1207| 160k| if (yyerrstatus) ------------------ | Branch (1207:7): [True: 0, False: 160k] ------------------ 1208| 0| yyerrstatus--; 1209| | 1210| | /* Shift the lookahead token. */ 1211| 160k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1212| 160k| yystate = yyn; 1213| 160k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1214| 160k| *++yyvsp = yylval; 1215| 160k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1216| | 1217| | /* Discard the shifted token. */ 1218| 160k| yychar = YYEMPTY; ------------------ | | 50| 160k|#define yychar hex_yychar ------------------ yychar = YYEMPTY; ------------------ | | 66| 160k|#define YYEMPTY -2 ------------------ 1219| 160k| goto yynewstate; 1220| | 1221| | 1222| |/*-----------------------------------------------------------. 1223| || yydefault -- do the default action for the current state. | 1224| |`-----------------------------------------------------------*/ 1225| 187k|yydefault: 1226| 187k| yyn = yydefact[yystate]; 1227| 187k| if (yyn == 0) ------------------ | Branch (1227:7): [True: 205, False: 187k] ------------------ 1228| 205| goto yyerrlab; 1229| 187k| goto yyreduce; 1230| | 1231| | 1232| |/*-----------------------------. 1233| || yyreduce -- do a reduction. | 1234| |`-----------------------------*/ 1235| 189k|yyreduce: 1236| | /* yyn is the number of a rule to reduce with. */ 1237| 189k| yylen = yyr2[yyn]; 1238| | 1239| | /* If YYLEN is nonzero, implement the default value of the action: 1240| | '$$ = $1'. 1241| | 1242| | Otherwise, the following line sets YYVAL to garbage. 1243| | This behavior is undocumented and Bison 1244| | users should not rely upon it. Assigning to YYVAL 1245| | unconditionally makes the parser a bit smaller, and it avoids a 1246| | GCC warning that YYVAL may be used uninitialized. */ 1247| 189k| yyval = yyvsp[1-yylen]; 1248| | 1249| | 1250| 189k| YY_REDUCE_PRINT (yyn); 1251| 189k| switch (yyn) 1252| 189k| { 1253| 1.02k| case 2: /* hex_string: '{' tokens '}' */ ------------------ | Branch (1253:3): [True: 1.02k, False: 188k] ------------------ 1254| 1.02k|#line 108 "hex_grammar.y" 1255| 1.02k| { 1256| 1.02k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 1.02k|#define yyget_extra hex_yyget_extra ------------------ 1257| 1.02k| re_ast->root_node = (yyvsp[-1].re_node); 1258| 1.02k| } 1259| 1.02k|#line 1260 "hex_grammar.c" 1260| 1.02k| break; 1261| | 1262| 1.42k| case 3: /* tokens: token */ ------------------ | Branch (1262:3): [True: 1.42k, False: 188k] ------------------ 1263| 1.42k|#line 117 "hex_grammar.y" 1264| 1.42k| { 1265| 1.42k| (yyval.re_node) = (yyvsp[0].re_node); 1266| 1.42k| } 1267| 1.42k|#line 1268 "hex_grammar.c" 1268| 1.42k| break; 1269| | 1270| 573| case 4: /* tokens: token token */ ------------------ | Branch (1270:3): [True: 573, False: 189k] ------------------ 1271| 573|#line 121 "hex_grammar.y" 1272| 573| { 1273| 573| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 573|#define RE_NODE_CONCAT 4 ------------------ 1274| | 1275| 573| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 108| 573| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 573] | | ------------------ | | 109| 573| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1276| 573| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 573| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 573] | | ------------------ | | 109| 573| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1277| | 1278| 573| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 573| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 573] | | ------------------ | | 102| 573| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1279| | 1280| 573| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1281| 573| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1282| 573| } 1283| 0|#line 1284 "hex_grammar.c" 1284| 0| break; 1285| | 1286| 2.04k| case 5: /* tokens: token token_sequence token */ ------------------ | Branch (1286:3): [True: 2.04k, False: 187k] ------------------ 1287| 2.04k|#line 133 "hex_grammar.y" 1288| 2.04k| { 1289| 2.04k| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1290| 2.04k| yr_re_node_prepend_child((yyvsp[-1].re_node), (yyvsp[-2].re_node)); 1291| | 1292| 2.04k| (yyval.re_node) = (yyvsp[-1].re_node); 1293| 2.04k| } 1294| 2.04k|#line 1295 "hex_grammar.c" 1295| 2.04k| break; 1296| | 1297| 2.21k| case 6: /* token_sequence: token_or_range */ ------------------ | Branch (1297:3): [True: 2.21k, False: 187k] ------------------ 1298| 2.21k|#line 144 "hex_grammar.y" 1299| 2.21k| { 1300| 2.21k| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 2.21k|#define RE_NODE_CONCAT 4 ------------------ 1301| | 1302| 2.21k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 2.21k| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 2.21k] | | ------------------ | | 109| 2.21k| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1303| 2.21k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 2.21k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 2.21k] | | ------------------ | | 102| 2.21k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1304| | 1305| 2.21k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1306| 2.21k| } 1307| 0|#line 1308 "hex_grammar.c" 1308| 0| break; 1309| | 1310| 13.1k| case 7: /* token_sequence: token_sequence token_or_range */ ------------------ | Branch (1310:3): [True: 13.1k, False: 176k] ------------------ 1311| 13.1k|#line 153 "hex_grammar.y" 1312| 13.1k| { 1313| 13.1k| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1314| 13.1k| (yyval.re_node) = (yyvsp[-1].re_node); 1315| 13.1k| } 1316| 13.1k|#line 1317 "hex_grammar.c" 1317| 13.1k| break; 1318| | 1319| 7.50k| case 8: /* token_or_range: token */ ------------------ | Branch (1319:3): [True: 7.50k, False: 182k] ------------------ 1320| 7.50k|#line 162 "hex_grammar.y" 1321| 7.50k| { 1322| 7.50k| (yyval.re_node) = (yyvsp[0].re_node); 1323| 7.50k| } 1324| 7.50k|#line 1325 "hex_grammar.c" 1325| 7.50k| break; 1326| | 1327| 7.84k| case 9: /* token_or_range: range */ ------------------ | Branch (1327:3): [True: 7.84k, False: 182k] ------------------ 1328| 7.84k|#line 166 "hex_grammar.y" 1329| 7.84k| { 1330| 7.84k| (yyval.re_node) = (yyvsp[0].re_node); 1331| 7.84k| (yyval.re_node)->greedy = false; 1332| 7.84k| } 1333| 7.84k|#line 1334 "hex_grammar.c" 1334| 7.84k| break; 1335| | 1336| 13.9k| case 10: /* token: byte */ ------------------ | Branch (1336:3): [True: 13.9k, False: 175k] ------------------ 1337| 13.9k|#line 175 "hex_grammar.y" 1338| 13.9k| { 1339| 13.9k| (yyval.re_node) = (yyvsp[0].re_node); 1340| 13.9k| } 1341| 13.9k|#line 1342 "hex_grammar.c" 1342| 13.9k| break; 1343| | 1344| 114k| case 11: /* $@1: %empty */ ------------------ | Branch (1344:3): [True: 114k, False: 75.1k] ------------------ 1345| 114k|#line 179 "hex_grammar.y" 1346| 114k| { 1347| 114k| lex_env->inside_or++; 1348| 114k| } 1349| 114k|#line 1350 "hex_grammar.c" 1350| 114k| break; 1351| | 1352| 585| case 12: /* token: '(' $@1 alternatives ')' */ ------------------ | Branch (1352:3): [True: 585, False: 189k] ------------------ 1353| 585|#line 183 "hex_grammar.y" 1354| 585| { 1355| 585| (yyval.re_node) = (yyvsp[-1].re_node); 1356| 585| lex_env->inside_or--; 1357| 585| } 1358| 585|#line 1359 "hex_grammar.c" 1359| 585| break; 1360| | 1361| 5.86k| case 13: /* range: '[' _NUMBER_ ']' */ ------------------ | Branch (1361:3): [True: 5.86k, False: 183k] ------------------ 1362| 5.86k|#line 192 "hex_grammar.y" 1363| 5.86k| { 1364| 5.86k| if ((yyvsp[-1].integer) <= 0) ------------------ | Branch (1364:13): [True: 3, False: 5.86k] ------------------ 1365| 3| { 1366| 3| yyerror(yyscanner, lex_env, "invalid jump length"); ------------------ | | 48| 3|#define yyerror hex_yyerror ------------------ 1367| 3| YYABORT; ------------------ | | 744| 3|#define YYABORT goto yyabortlab ------------------ 1368| 3| } 1369| | 1370| 5.86k| if (lex_env->inside_or && (yyvsp[-1].integer) > YR_STRING_CHAINING_THRESHOLD) ------------------ | | 142| 364|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1370:13): [True: 364, False: 5.49k] | Branch (1370:35): [True: 0, False: 364] ------------------ 1371| 0| { 1372| 0| yyerror(yyscanner, lex_env, "jumps over " ------------------ | | 48| 0|#define yyerror hex_yyerror ------------------ 1373| 0| STR(YR_STRING_CHAINING_THRESHOLD) 1374| 0| " not allowed inside alternation (|)"); 1375| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1376| 0| } 1377| | 1378| | // A jump of one is equivalent to ?? 1379| 5.86k| if ((yyvsp[-1].integer) == 1) ------------------ | Branch (1379:13): [True: 453, False: 5.40k] ------------------ 1380| 453| { 1381| 453| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_LITERAL); ------------------ | | 42| 453|#define RE_NODE_MASKED_LITERAL 2 ------------------ 1382| | 1383| 453| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 453| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 453] | | ------------------ | | 102| 453| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1384| | 1385| 453| (yyval.re_node)->value = 0x00; 1386| 453| (yyval.re_node)->mask = 0x00; 1387| 453| } 1388| 5.40k| else 1389| 5.40k| { 1390| 5.40k| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 5.40k|#define RE_NODE_RANGE_ANY 21 ------------------ 1391| | 1392| 5.40k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 5.40k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 5.40k] | | ------------------ | | 102| 5.40k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1393| | 1394| 5.40k| (yyval.re_node)->start = (int) (yyvsp[-1].integer); 1395| 5.40k| (yyval.re_node)->end = (int) (yyvsp[-1].integer); 1396| 5.40k| } 1397| 5.86k| } 1398| 5.86k|#line 1399 "hex_grammar.c" 1399| 5.86k| break; 1400| | 1401| 5.86k| case 14: /* range: '[' _NUMBER_ '-' _NUMBER_ ']' */ ------------------ | Branch (1401:3): [True: 660, False: 189k] ------------------ 1402| 660|#line 228 "hex_grammar.y" 1403| 660| { 1404| 660| if (lex_env->inside_or && ------------------ | Branch (1404:13): [True: 448, False: 212] ------------------ 1405| 660| ((yyvsp[-3].integer) > YR_STRING_CHAINING_THRESHOLD || ------------------ | | 142| 896|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1405:14): [True: 0, False: 448] ------------------ 1406| 448| (yyvsp[-1].integer) > YR_STRING_CHAINING_THRESHOLD) ) ------------------ | | 142| 448|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1406:14): [True: 5, False: 443] ------------------ 1407| 5| { 1408| 5| yyerror(yyscanner, lex_env, "jumps over " ------------------ | | 48| 5|#define yyerror hex_yyerror ------------------ 1409| 5| STR(YR_STRING_CHAINING_THRESHOLD) 1410| 5| " not allowed inside alternation (|)"); 1411| | 1412| 5| YYABORT; ------------------ | | 744| 5|#define YYABORT goto yyabortlab ------------------ 1413| 5| } 1414| | 1415| 655| if ((yyvsp[-3].integer) < 0 || (yyvsp[-1].integer) < 0) ------------------ | Branch (1415:13): [True: 4, False: 651] | Branch (1415:40): [True: 0, False: 651] ------------------ 1416| 4| { 1417| 4| yyerror(yyscanner, lex_env, "invalid negative jump length"); ------------------ | | 48| 4|#define yyerror hex_yyerror ------------------ 1418| 4| YYABORT; ------------------ | | 744| 4|#define YYABORT goto yyabortlab ------------------ 1419| 4| } 1420| | 1421| 651| if ((yyvsp[-3].integer) > (yyvsp[-1].integer)) ------------------ | Branch (1421:13): [True: 0, False: 651] ------------------ 1422| 0| { 1423| 0| yyerror(yyscanner, lex_env, "invalid jump range"); ------------------ | | 48| 0|#define yyerror hex_yyerror ------------------ 1424| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1425| 0| } 1426| | 1427| 651| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 651|#define RE_NODE_RANGE_ANY 21 ------------------ 1428| | 1429| 651| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 651| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 651] | | ------------------ | | 102| 651| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1430| | 1431| 651| (yyval.re_node)->start = (int) (yyvsp[-3].integer); 1432| 651| (yyval.re_node)->end = (int) (yyvsp[-1].integer); 1433| 651| } 1434| 0|#line 1435 "hex_grammar.c" 1435| 0| break; 1436| | 1437| 373| case 15: /* range: '[' _NUMBER_ '-' ']' */ ------------------ | Branch (1437:3): [True: 373, False: 189k] ------------------ 1438| 373|#line 260 "hex_grammar.y" 1439| 373| { 1440| 373| if (lex_env->inside_or) ------------------ | Branch (1440:13): [True: 5, False: 368] ------------------ 1441| 5| { 1442| 5| yyerror(yyscanner, lex_env, ------------------ | | 48| 5|#define yyerror hex_yyerror ------------------ 1443| 5| "unbounded jumps not allowed inside alternation (|)"); 1444| 5| YYABORT; ------------------ | | 744| 5|#define YYABORT goto yyabortlab ------------------ 1445| 5| } 1446| | 1447| 368| if ((yyvsp[-2].integer) < 0) ------------------ | Branch (1447:13): [True: 4, False: 364] ------------------ 1448| 4| { 1449| 4| yyerror(yyscanner, lex_env, "invalid negative jump length"); ------------------ | | 48| 4|#define yyerror hex_yyerror ------------------ 1450| 4| YYABORT; ------------------ | | 744| 4|#define YYABORT goto yyabortlab ------------------ 1451| 4| } 1452| | 1453| 364| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 364|#define RE_NODE_RANGE_ANY 21 ------------------ 1454| | 1455| 364| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 364| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 364] | | ------------------ | | 102| 364| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1456| | 1457| 364| (yyval.re_node)->start = (int) (yyvsp[-2].integer); 1458| 364| (yyval.re_node)->end = INT_MAX; 1459| 364| } 1460| 0|#line 1461 "hex_grammar.c" 1461| 0| break; 1462| | 1463| 978| case 16: /* range: '[' '-' ']' */ ------------------ | Branch (1463:3): [True: 978, False: 188k] ------------------ 1464| 978|#line 282 "hex_grammar.y" 1465| 978| { 1466| 978| if (lex_env->inside_or) ------------------ | Branch (1466:13): [True: 11, False: 967] ------------------ 1467| 11| { 1468| 11| yyerror(yyscanner, lex_env, ------------------ | | 48| 11|#define yyerror hex_yyerror ------------------ 1469| 11| "unbounded jumps not allowed inside alternation (|)"); 1470| 11| YYABORT; ------------------ | | 744| 11|#define YYABORT goto yyabortlab ------------------ 1471| 11| } 1472| | 1473| 967| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 967|#define RE_NODE_RANGE_ANY 21 ------------------ 1474| | 1475| 967| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 967| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 967] | | ------------------ | | 102| 967| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1476| | 1477| 967| (yyval.re_node)->start = 0; 1478| 967| (yyval.re_node)->end = INT_MAX; 1479| 967| } 1480| 0|#line 1481 "hex_grammar.c" 1481| 0| break; 1482| | 1483| 836| case 17: /* alternatives: tokens */ ------------------ | Branch (1483:3): [True: 836, False: 189k] ------------------ 1484| 836|#line 302 "hex_grammar.y" 1485| 836| { 1486| 836| (yyval.re_node) = (yyvsp[0].re_node); 1487| 836| } 1488| 836|#line 1489 "hex_grammar.c" 1489| 836| break; 1490| | 1491| 2.13k| case 18: /* alternatives: alternatives '|' tokens */ ------------------ | Branch (1491:3): [True: 2.13k, False: 187k] ------------------ 1492| 2.13k|#line 306 "hex_grammar.y" 1493| 2.13k| { 1494| 2.13k| mark_as_not_fast_regexp(); ------------------ | | 98| 2.13k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 2.13k|#define yyget_extra hex_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 2.13k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1495| | 1496| 2.13k| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 2.13k|#define RE_NODE_ALT 5 ------------------ 1497| | 1498| 2.13k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 108| 2.13k| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 2.13k] | | ------------------ | | 109| 2.13k| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1499| 2.13k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 2.13k| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 2.13k] | | ------------------ | | 109| 2.13k| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1500| | 1501| 2.13k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 2.13k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 2.13k] | | ------------------ | | 102| 2.13k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1502| | 1503| 2.13k| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1504| 2.13k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1505| 2.13k| } 1506| 0|#line 1507 "hex_grammar.c" 1507| 0| break; 1508| | 1509| 6.27k| case 19: /* byte: _BYTE_ */ ------------------ | Branch (1509:3): [True: 6.27k, False: 183k] ------------------ 1510| 6.27k|#line 323 "hex_grammar.y" 1511| 6.27k| { 1512| 6.27k| (yyval.re_node) = yr_re_node_create(RE_NODE_LITERAL); ------------------ | | 41| 6.27k|#define RE_NODE_LITERAL 1 ------------------ 1513| | 1514| 6.27k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 6.27k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 6.27k] | | ------------------ | | 102| 6.27k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1515| | 1516| 6.27k| (yyval.re_node)->value = (int) (yyvsp[0].integer); 1517| 6.27k| (yyval.re_node)->mask = 0xFF; 1518| 6.27k| } 1519| 0|#line 1520 "hex_grammar.c" 1520| 0| break; 1521| | 1522| 343| case 20: /* byte: _NOT_BYTE_ */ ------------------ | Branch (1522:3): [True: 343, False: 189k] ------------------ 1523| 343|#line 332 "hex_grammar.y" 1524| 343| { 1525| 343| (yyval.re_node) = yr_re_node_create(RE_NODE_NOT_LITERAL); ------------------ | | 62| 343|#define RE_NODE_NOT_LITERAL 22 ------------------ 1526| | 1527| 343| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 343| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 343] | | ------------------ | | 102| 343| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1528| | 1529| 343| (yyval.re_node)->value = (int) (yyvsp[0].integer); 1530| 343| (yyval.re_node)->mask = 0xFF; 1531| 343| } 1532| 0|#line 1533 "hex_grammar.c" 1533| 0| break; 1534| | 1535| 6.44k| case 21: /* byte: _MASKED_BYTE_ */ ------------------ | Branch (1535:3): [True: 6.44k, False: 183k] ------------------ 1536| 6.44k|#line 341 "hex_grammar.y" 1537| 6.44k| { 1538| 6.44k| uint8_t mask = (uint8_t) ((yyvsp[0].integer) >> 8); 1539| | 1540| 6.44k| if (mask == 0x00) ------------------ | Branch (1540:13): [True: 551, False: 5.89k] ------------------ 1541| 551| { 1542| 551| (yyval.re_node) = yr_re_node_create(RE_NODE_ANY); ------------------ | | 43| 551|#define RE_NODE_ANY 3 ------------------ 1543| | 1544| 551| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 551| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 551] | | ------------------ | | 102| 551| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1545| | 1546| 551| (yyval.re_node)->value = 0x00; 1547| 551| (yyval.re_node)->mask = 0x00; 1548| 551| } 1549| 5.89k| else 1550| 5.89k| { 1551| 5.89k| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_LITERAL); ------------------ | | 42| 5.89k|#define RE_NODE_MASKED_LITERAL 2 ------------------ 1552| | 1553| 5.89k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 5.89k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 5.89k] | | ------------------ | | 102| 5.89k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1554| | 1555| 5.89k| (yyval.re_node)->value = (yyvsp[0].integer) & 0xFF; 1556| 5.89k| (yyval.re_node)->mask = mask; 1557| 5.89k| } 1558| 6.44k| } 1559| 6.44k|#line 1560 "hex_grammar.c" 1560| 6.44k| break; 1561| | 1562| 6.44k| case 22: /* byte: _MASKED_NOT_BYTE_ */ ------------------ | Branch (1562:3): [True: 881, False: 188k] ------------------ 1563| 881|#line 364 "hex_grammar.y" 1564| 881| { 1565| 881| uint8_t mask = (uint8_t) ((yyvsp[0].integer) >> 8); 1566| | 1567| 881| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_NOT_LITERAL); ------------------ | | 63| 881|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ 1568| | 1569| 881| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 881| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 881] | | ------------------ | | 102| 881| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1570| | 1571| 881| (yyval.re_node)->value = (yyvsp[0].integer) & 0xFF; 1572| 881| (yyval.re_node)->mask = mask; 1573| 881| } 1574| 0|#line 1575 "hex_grammar.c" 1575| 0| break; 1576| | 1577| | 1578| 0|#line 1579 "hex_grammar.c" 1579| | 1580| 0| default: break; ------------------ | Branch (1580:7): [True: 0, False: 189k] ------------------ 1581| 189k| } 1582| | /* User semantic actions sometimes alter yychar, and that requires 1583| | that yytoken be updated with the new translation. We take the 1584| | approach of translating immediately before every use of yytoken. 1585| | One alternative is translating here after every semantic action, 1586| | but that translation would be missed if the semantic action invokes 1587| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1588| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1589| | incorrect destructor might then be invoked immediately. In the 1590| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 1591| | to an incorrect destructor call or verbose syntax error message 1592| | before the lookahead is translated. */ 1593| 189k| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1594| | 1595| 189k| YYPOPSTACK (yylen); ------------------ | | 1045| 189k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1596| 189k| yylen = 0; 1597| | 1598| 189k| *++yyvsp = yyval; 1599| | 1600| | /* Now 'shift' the result of the reduction. Determine what state 1601| | that goes to, based on the state we popped back to and the rule 1602| | number reduced by. */ 1603| 189k| { 1604| 189k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 561| 189k|#define YYNTOKENS 16 ------------------ 1605| 189k| const int yyi = yypgoto[yylhs] + *yyssp; 1606| 189k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 558| 239k|#define YYLAST 35 ------------------ | Branch (1606:16): [True: 50.0k, False: 139k] | Branch (1606:28): [True: 47.9k, False: 2.14k] | Branch (1606:45): [True: 26.2k, False: 21.6k] ------------------ 1607| 189k| ? yytable[yyi] 1608| 189k| : yydefgoto[yylhs]); 1609| 189k| } 1610| | 1611| 189k| goto yynewstate; 1612| | 1613| | 1614| |/*--------------------------------------. 1615| || yyerrlab -- here on detecting error. | 1616| |`--------------------------------------*/ 1617| 205|yyerrlab: 1618| | /* Make sure we have latest lookahead translation. See comments at 1619| | user semantic actions for why this is necessary. */ 1620| 205| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 50| 205|#define yychar hex_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 66| 205|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 576| 410| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 205|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 205, False: 0] | | | Branch (576:18): [True: 205, False: 0] | | ------------------ | | 577| 410| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 205|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 410| : YYSYMBOL_YYUNDEF) ------------------ | Branch (1620:13): [True: 0, False: 205] ------------------ 1621| | /* If not already recovering from an error, report this error. */ 1622| 205| if (!yyerrstatus) ------------------ | Branch (1622:7): [True: 205, False: 0] ------------------ 1623| 205| { 1624| 205| ++yynerrs; ------------------ | | 52| 205|#define yynerrs hex_yynerrs ------------------ 1625| 205| yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 48| 205|#define yyerror hex_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 360| 205|# define YY_(Msgid) Msgid ------------------ 1626| 205| } 1627| | 1628| 205| if (yyerrstatus == 3) ------------------ | Branch (1628:7): [True: 0, False: 205] ------------------ 1629| 0| { 1630| | /* If just tried and failed to reuse lookahead token after an 1631| | error, discard it. */ 1632| | 1633| 0| if (yychar <= YYEOF) ------------------ | | 50| 0|#define yychar hex_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 67| 0|#define YYEOF 0 ------------------ | Branch (1633:11): [True: 0, False: 0] ------------------ 1634| 0| { 1635| | /* Return failure if at end of input. */ 1636| 0| if (yychar == YYEOF) ------------------ | | 50| 0|#define yychar hex_yychar ------------------ if (yychar == YYEOF) ------------------ | | 67| 0|#define YYEOF 0 ------------------ | Branch (1636:15): [True: 0, False: 0] ------------------ 1637| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1638| 0| } 1639| 0| else 1640| 0| { 1641| 0| yydestruct ("Error: discarding", 1642| 0| yytoken, &yylval, yyscanner, lex_env); 1643| 0| yychar = YYEMPTY; ------------------ | | 50| 0|#define yychar hex_yychar ------------------ yychar = YYEMPTY; ------------------ | | 66| 0|#define YYEMPTY -2 ------------------ 1644| 0| } 1645| 0| } 1646| | 1647| | /* Else will try to reuse lookahead token after shifting the error 1648| | token. */ 1649| 205| goto yyerrlab1; 1650| | 1651| | 1652| |/*---------------------------------------------------. 1653| || yyerrorlab -- error raised explicitly by YYERROR. | 1654| |`---------------------------------------------------*/ 1655| 205|yyerrorlab: 1656| | /* Pacify compilers when the user code never invokes YYERROR and the 1657| | label yyerrorlab therefore never appears in user code. */ 1658| 0| if (0) ------------------ | Branch (1658:7): [Folded - Ignored] ------------------ 1659| 0| YYERROR; ------------------ | | 745| 0|#define YYERROR goto yyerrorlab ------------------ 1660| 0| ++yynerrs; ------------------ | | 52| 0|#define yynerrs hex_yynerrs ------------------ 1661| | 1662| | /* Do not reclaim the symbols of the rule whose action triggered 1663| | this YYERROR. */ 1664| 0| YYPOPSTACK (yylen); ------------------ | | 1045| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1665| 0| yylen = 0; 1666| 0| YY_STACK_PRINT (yyss, yyssp); 1667| 0| yystate = *yyssp; 1668| 0| goto yyerrlab1; 1669| | 1670| | 1671| |/*-------------------------------------------------------------. 1672| || yyerrlab1 -- common code for both syntax error and YYERROR. | 1673| |`-------------------------------------------------------------*/ 1674| 205|yyerrlab1: 1675| 205| yyerrstatus = 3; /* Each real token shifted decrements this. */ 1676| | 1677| | /* Pop stack until we find a state that shifts the error token. */ 1678| 205| for (;;) 1679| 161k| { 1680| 161k| yyn = yypact[yystate]; 1681| 161k| if (!yypact_value_is_default (yyn)) ------------------ | | 652| 161k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 649| 161k|#define YYPACT_NINF (-13) | | ------------------ ------------------ | Branch (1681:11): [True: 81.6k, False: 80.2k] ------------------ 1682| 81.6k| { 1683| 81.6k| yyn += YYSYMBOL_YYerror; 1684| 81.6k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 558| 162k|#define YYLAST 35 ------------------ | Branch (1684:15): [True: 81.2k, False: 476] | Branch (1684:27): [True: 81.2k, False: 0] | Branch (1684:44): [True: 0, False: 81.2k] ------------------ 1685| 0| { 1686| 0| yyn = yytable[yyn]; 1687| 0| if (0 < yyn) ------------------ | Branch (1687:19): [True: 0, False: 0] ------------------ 1688| 0| break; 1689| 0| } 1690| 81.6k| } 1691| | 1692| | /* Pop the current state because it cannot handle the error token. */ 1693| 161k| if (yyssp == yyss) ------------------ | Branch (1693:11): [True: 205, False: 161k] ------------------ 1694| 205| YYABORT; ------------------ | | 744| 205|#define YYABORT goto yyabortlab ------------------ 1695| | 1696| | 1697| 161k| yydestruct ("Error: popping", 1698| 161k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, lex_env); ------------------ | | 624| 161k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 121| 161k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1699| 161k| YYPOPSTACK (1); ------------------ | | 1045| 161k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1700| 161k| yystate = *yyssp; 1701| 161k| YY_STACK_PRINT (yyss, yyssp); 1702| 161k| } 1703| | 1704| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1705| 0| *++yyvsp = yylval; 1706| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 1707| | 1708| | 1709| | /* Shift the error token. */ 1710| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1711| | 1712| 0| yystate = yyn; 1713| 0| goto yynewstate; 1714| | 1715| | 1716| |/*-------------------------------------. 1717| || yyacceptlab -- YYACCEPT comes here. | 1718| |`-------------------------------------*/ 1719| 1.02k|yyacceptlab: 1720| 1.02k| yyresult = 0; 1721| 1.02k| goto yyreturnlab; 1722| | 1723| | 1724| |/*-----------------------------------. 1725| || yyabortlab -- YYABORT comes here. | 1726| |`-----------------------------------*/ 1727| 237|yyabortlab: 1728| 237| yyresult = 1; 1729| 237| goto yyreturnlab; 1730| | 1731| | 1732| |/*-----------------------------------------------------------. 1733| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1734| |`-----------------------------------------------------------*/ 1735| 6|yyexhaustedlab: 1736| 6| yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 48| 6|#define yyerror hex_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 360| 6|# define YY_(Msgid) Msgid ------------------ 1737| 6| yyresult = 2; 1738| 6| goto yyreturnlab; 1739| | 1740| | 1741| |/*----------------------------------------------------------. 1742| || yyreturnlab -- parsing is finished, clean up and return. | 1743| |`----------------------------------------------------------*/ 1744| 1.27k|yyreturnlab: 1745| 1.27k| if (yychar != YYEMPTY) ------------------ | | 50| 1.27k|#define yychar hex_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 66| 1.27k|#define YYEMPTY -2 ------------------ | Branch (1745:7): [True: 205, False: 1.06k] ------------------ 1746| 205| { 1747| | /* Make sure we have latest lookahead translation. See comments at 1748| | user semantic actions for why this is necessary. */ 1749| 205| yytoken = YYTRANSLATE (yychar); ------------------ | | 576| 205| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 205|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 205, False: 0] | | | Branch (576:18): [True: 205, False: 0] | | ------------------ | | 577| 205| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 205|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 205| : YYSYMBOL_YYUNDEF) ------------------ 1750| 205| yydestruct ("Cleanup: discarding lookahead", 1751| 205| yytoken, &yylval, yyscanner, lex_env); 1752| 205| } 1753| | /* Do not reclaim the symbols of the rule whose action triggered 1754| | this YYABORT or YYACCEPT. */ 1755| 1.27k| YYPOPSTACK (yylen); ------------------ | | 1045| 1.27k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1756| 1.27k| YY_STACK_PRINT (yyss, yyssp); 1757| 71.3k| while (yyssp != yyss) ------------------ | Branch (1757:10): [True: 70.0k, False: 1.27k] ------------------ 1758| 70.0k| { 1759| 70.0k| yydestruct ("Cleanup: popping", 1760| 70.0k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, lex_env); ------------------ | | 624| 70.0k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 121| 70.0k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1761| 70.0k| YYPOPSTACK (1); ------------------ | | 1045| 70.0k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1762| 70.0k| } 1763| 1.27k|#ifndef yyoverflow 1764| 1.27k| if (yyss != yyssa) ------------------ | Branch (1764:7): [True: 113, False: 1.15k] ------------------ 1765| 113| YYSTACK_FREE (yyss); ------------------ | | 468| 113|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 95| 113|#define YYFREE yr_free | | ------------------ ------------------ 1766| 1.27k|#endif 1767| | 1768| 1.27k| return yyresult; 1769| 205|} hex_grammar.c:yydestruct: 930| 232k|{ 931| 232k| YY_USE (yyvaluep); ------------------ | | 383| 232k|# define YY_USE(E) ((void) (E)) ------------------ 932| 232k| YY_USE (yyscanner); ------------------ | | 383| 232k|# define YY_USE(E) ((void) (E)) ------------------ 933| 232k| YY_USE (lex_env); ------------------ | | 383| 232k|# define YY_USE(E) ((void) (E)) ------------------ 934| 232k| if (!yymsg) ------------------ | Branch (934:7): [True: 0, False: 232k] ------------------ 935| 0| yymsg = "Deleting"; 936| 232k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 937| | 938| 232k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 939| 232k| switch (yykind) 940| 232k| { 941| 41| case YYSYMBOL_tokens: /* tokens */ ------------------ | Branch (941:5): [True: 41, False: 231k] ------------------ 942| 41|#line 96 "hex_grammar.y" 943| 41| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 944| 41|#line 945 "hex_grammar.c" 945| 41| break; 946| | 947| 171| case YYSYMBOL_token_sequence: /* token_sequence */ ------------------ | Branch (947:5): [True: 171, False: 231k] ------------------ 948| 171|#line 97 "hex_grammar.y" 949| 171| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 950| 171|#line 951 "hex_grammar.c" 951| 171| break; 952| | 953| 0| case YYSYMBOL_token_or_range: /* token_or_range */ ------------------ | Branch (953:5): [True: 0, False: 232k] ------------------ 954| 0|#line 98 "hex_grammar.y" 955| 0| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 956| 0|#line 957 "hex_grammar.c" 957| 0| break; 958| | 959| 372| case YYSYMBOL_token: /* token */ ------------------ | Branch (959:5): [True: 372, False: 231k] ------------------ 960| 372|#line 99 "hex_grammar.y" 961| 372| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 962| 372|#line 963 "hex_grammar.c" 963| 372| break; 964| | 965| 0| case YYSYMBOL_range: /* range */ ------------------ | Branch (965:5): [True: 0, False: 232k] ------------------ 966| 0|#line 102 "hex_grammar.y" 967| 0| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 968| 0|#line 969 "hex_grammar.c" 969| 0| break; 970| | 971| 251| case YYSYMBOL_alternatives: /* alternatives */ ------------------ | Branch (971:5): [True: 251, False: 231k] ------------------ 972| 251|#line 101 "hex_grammar.y" 973| 251| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 974| 251|#line 975 "hex_grammar.c" 975| 251| break; 976| | 977| 0| case YYSYMBOL_byte: /* byte */ ------------------ | Branch (977:5): [True: 0, False: 232k] ------------------ 978| 0|#line 100 "hex_grammar.y" 979| 0| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 980| 0|#line 981 "hex_grammar.c" 981| 0| break; 982| | 983| 231k| default: ------------------ | Branch (983:7): [True: 231k, False: 835] ------------------ 984| 231k| break; 985| 232k| } 986| 232k| YY_IGNORE_MAYBE_UNINITIALIZED_END 987| 232k|} hex_yylex: 1006| 160k|{ 1007| 160k| yy_state_type yy_current_state; 1008| 160k| char *yy_cp, *yy_bp; 1009| 160k| int yy_act; 1010| 160k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1011| | 1012| 160k| yylval = yylval_param; ------------------ | | 825| 160k| # define yylval yyg->yylval_r ------------------ 1013| | 1014| 160k| if ( !yyg->yy_init ) ------------------ | Branch (1014:7): [True: 1.27k, False: 159k] ------------------ 1015| 1.27k| { 1016| 1.27k| yyg->yy_init = 1; 1017| | 1018| |#ifdef YY_USER_INIT 1019| | YY_USER_INIT; 1020| |#endif 1021| | 1022| 1.27k| if ( ! yyg->yy_start ) ------------------ | Branch (1022:8): [True: 1.27k, False: 0] ------------------ 1023| 1.27k| yyg->yy_start = 1; /* first start state */ 1024| | 1025| 1.27k| if ( ! yyin ) ------------------ | | 344| 1.27k|#define yyin yyg->yyin_r ------------------ | Branch (1025:8): [True: 1.27k, False: 0] ------------------ 1026| 1.27k| yyin = stdin; ------------------ | | 344| 1.27k|#define yyin yyg->yyin_r ------------------ 1027| | 1028| 1.27k| if ( ! yyout ) ------------------ | | 345| 1.27k|#define yyout yyg->yyout_r ------------------ | Branch (1028:8): [True: 1.27k, False: 0] ------------------ 1029| 1.27k| yyout = stdout; ------------------ | | 345| 1.27k|#define yyout yyg->yyout_r ------------------ 1030| | 1031| 1.27k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ | Branch (1031:8): [True: 0, False: 1.27k] ------------------ 1032| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack hex_yyensure_buffer_stack ------------------ 1033| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1034| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer hex_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 379| 0|#define YY_BUF_SIZE 16384 ------------------ 1035| 0| } 1036| | 1037| 1.27k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.27k|#define yy_load_buffer_state hex_yy_load_buffer_state ------------------ 1038| 1.27k| } 1039| | 1040| 160k| { 1041| 160k|#line 95 "libyara/hex_lexer.l" 1042| | 1043| | 1044| | 1045| 160k|#line 1045 "libyara/hex_lexer.c" 1046| | 1047| 255k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1047:23): [Folded - Ignored] ------------------ 1048| 255k| { 1049| 255k| yy_cp = yyg->yy_c_buf_p; 1050| | 1051| | /* Support of yytext. */ 1052| 255k| *yy_cp = yyg->yy_hold_char; 1053| | 1054| | /* yy_bp points to the position in yy_ch_buf of the start of 1055| | * the current run. 1056| | */ 1057| 255k| yy_bp = yy_cp; 1058| | 1059| 255k| yy_current_state = yyg->yy_start; 1060| 255k|yy_match: 1061| 255k| do 1062| 553k| { 1063| 553k| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 553k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1064| 553k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1064:9): [True: 297k, False: 256k] ------------------ 1065| 297k| { 1066| 297k| yyg->yy_last_accepting_state = yy_current_state; 1067| 297k| yyg->yy_last_accepting_cpos = yy_cp; 1068| 297k| } 1069| 926k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1069:12): [True: 373k, False: 553k] ------------------ 1070| 373k| { 1071| 373k| yy_current_state = (int) yy_def[yy_current_state]; 1072| 373k| if ( yy_current_state >= 40 ) ------------------ | Branch (1072:10): [True: 117k, False: 255k] ------------------ 1073| 117k| yy_c = yy_meta[yy_c]; 1074| 373k| } 1075| 553k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1076| 553k| ++yy_cp; 1077| 553k| } 1078| 553k| while ( yy_current_state != 39 ); ------------------ | Branch (1078:11): [True: 298k, False: 255k] ------------------ 1079| 255k| yy_cp = yyg->yy_last_accepting_cpos; 1080| 255k| yy_current_state = yyg->yy_last_accepting_state; 1081| | 1082| 256k|yy_find_action: 1083| 256k| yy_act = yy_accept[yy_current_state]; 1084| | 1085| 256k| YY_DO_BEFORE_ACTION; ------------------ | | 578| 256k| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 256k|#define yytext_ptr yytext_r | | ------------------ | | 579| 256k| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 256k|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 256k| yyg->yy_hold_char = *yy_cp; \ | | 581| 256k| *yy_cp = '\0'; \ | | 582| 256k| yyg->yy_c_buf_p = yy_cp; ------------------ 1086| | 1087| 256k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 513k|#define YY_END_OF_BUFFER 24 ------------------ | Branch (1087:8): [True: 254k, False: 2.16k] | Branch (1087:38): [True: 94.2k, False: 160k] ------------------ 1088| 94.2k| { 1089| 94.2k| int yyl; 1090| 188k| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 188k|#define yyleng yyg->yyleng_r ------------------ | Branch (1090:19): [True: 94.2k, False: 94.2k] ------------------ 1091| 94.2k| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 94.2k|#define yytext yyg->yytext_r ------------------ | Branch (1091:10): [True: 26.2k, False: 67.9k] ------------------ 1092| | 1093| 26.2k| do{ yylineno++; ------------------ | | 349| 26.2k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 26.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1094| 26.2k| yycolumn=0; ------------------ | | 350| 26.2k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 26.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1095| 26.2k| }while(0) ------------------ | Branch (1095:12): [Folded - Ignored] ------------------ 1096| 94.2k|; 1097| 94.2k| } 1098| | 1099| 257k|do_action: /* This label is used only to access EOF actions. */ 1100| | 1101| 257k| switch ( yy_act ) 1102| 257k| { /* beginning of action switch */ 1103| 0| case 0: /* must back up */ ------------------ | Branch (1103:4): [True: 0, False: 257k] ------------------ 1104| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1105| 0| *yy_cp = yyg->yy_hold_char; 1106| 0| yy_cp = yyg->yy_last_accepting_cpos; 1107| 0| yy_current_state = yyg->yy_last_accepting_state; 1108| 0| goto yy_find_action; 1109| | 1110| 6.27k|case 1: ------------------ | Branch (1110:1): [True: 6.27k, False: 251k] ------------------ 1111| 6.27k|YY_RULE_SETUP 1112| 6.27k|#line 98 "libyara/hex_lexer.l" 1113| 6.27k|{ 1114| | 1115| 6.27k| yylval->integer = xtoi(yytext); ------------------ | | 825| 6.27k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext); ------------------ | | 348| 6.27k|#define yytext yyg->yytext_r ------------------ 1116| 6.27k| return _BYTE_; ------------------ | | 70| 6.27k|#define _BYTE_ 258 ------------------ 1117| 0|} 1118| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1119| 4.03k|case 2: ------------------ | Branch (1119:1): [True: 4.03k, False: 253k] ------------------ 1120| 4.03k|YY_RULE_SETUP 1121| 4.03k|#line 104 "libyara/hex_lexer.l" 1122| 4.03k|{ 1123| | 1124| 4.03k| yytext[1] = '0'; // replace ? by 0 ------------------ | | 348| 4.03k|#define yytext yyg->yytext_r ------------------ 1125| 4.03k| yylval->integer = xtoi(yytext) | 0xF000 ; ------------------ | | 825| 4.03k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext) | 0xF000 ; ------------------ | | 348| 4.03k|#define yytext yyg->yytext_r ------------------ 1126| 4.03k| return _MASKED_BYTE_; ------------------ | | 71| 4.03k|#define _MASKED_BYTE_ 259 ------------------ 1127| 0|} 1128| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1129| 343|case 3: ------------------ | Branch (1129:1): [True: 343, False: 257k] ------------------ 1130| 343|YY_RULE_SETUP 1131| 343|#line 111 "libyara/hex_lexer.l" 1132| 343|{ 1133| | 1134| 343| yylval->integer = xtoi(&(yytext[1])); ------------------ | | 825| 343| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])); ------------------ | | 348| 343|#define yytext yyg->yytext_r ------------------ 1135| 343| return _NOT_BYTE_; ------------------ | | 72| 343|#define _NOT_BYTE_ 260 ------------------ 1136| 0|} 1137| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1138| 1.86k|case 4: ------------------ | Branch (1138:1): [True: 1.86k, False: 255k] ------------------ 1139| 1.86k|YY_RULE_SETUP 1140| 1.86k|#line 117 "libyara/hex_lexer.l" 1141| 1.86k|{ 1142| | 1143| 1.86k| yytext[0] = '0'; // replace ? by 0 ------------------ | | 348| 1.86k|#define yytext yyg->yytext_r ------------------ 1144| 1.86k| yylval->integer = xtoi(yytext) | 0x0F00 ; ------------------ | | 825| 1.86k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext) | 0x0F00 ; ------------------ | | 348| 1.86k|#define yytext yyg->yytext_r ------------------ 1145| 1.86k| return _MASKED_BYTE_; ------------------ | | 71| 1.86k|#define _MASKED_BYTE_ 259 ------------------ 1146| 0|} 1147| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1148| 551|case 5: ------------------ | Branch (1148:1): [True: 551, False: 257k] ------------------ 1149| 551|YY_RULE_SETUP 1150| 551|#line 124 "libyara/hex_lexer.l" 1151| 551|{ 1152| | 1153| 551| yylval->integer = 0x0000; ------------------ | | 825| 551| # define yylval yyg->yylval_r ------------------ 1154| 551| return _MASKED_BYTE_; ------------------ | | 71| 551|#define _MASKED_BYTE_ 259 ------------------ 1155| 0|} 1156| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1157| 588|case 6: ------------------ | Branch (1157:1): [True: 588, False: 257k] ------------------ 1158| 588|YY_RULE_SETUP 1159| 588|#line 130 "libyara/hex_lexer.l" 1160| 588|{ 1161| | 1162| 588| yytext[2] = '0'; // replace ? by 0 ------------------ | | 348| 588|#define yytext yyg->yytext_r ------------------ 1163| 588| yylval->integer = xtoi(&(yytext[1])) | 0xF000 ; ------------------ | | 825| 588| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])) | 0xF000 ; ------------------ | | 348| 588|#define yytext yyg->yytext_r ------------------ 1164| 588| return _MASKED_NOT_BYTE_; ------------------ | | 73| 588|#define _MASKED_NOT_BYTE_ 261 ------------------ 1165| 0|} 1166| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1167| 293|case 7: ------------------ | Branch (1167:1): [True: 293, False: 257k] ------------------ 1168| 293|YY_RULE_SETUP 1169| 293|#line 137 "libyara/hex_lexer.l" 1170| 293|{ 1171| | 1172| 293| yytext[1] = '0'; // replace ? by 0 ------------------ | | 348| 293|#define yytext yyg->yytext_r ------------------ 1173| 293| yylval->integer = xtoi(&(yytext[1])) | 0x0F00 ; ------------------ | | 825| 293| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])) | 0x0F00 ; ------------------ | | 348| 293|#define yytext yyg->yytext_r ------------------ 1174| 293| return _MASKED_NOT_BYTE_; ------------------ | | 73| 293|#define _MASKED_NOT_BYTE_ 261 ------------------ 1175| 0|} 1176| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1177| 52|case 8: ------------------ | Branch (1177:1): [True: 52, False: 257k] ------------------ 1178| 52|YY_RULE_SETUP 1179| 52|#line 144 "libyara/hex_lexer.l" 1180| 52|{ 1181| | 1182| 52| yyerror(yyscanner, lex_env, "uneven number of digits in hex string"); ------------------ | | 48| 52|#define yyerror hex_yyerror ------------------ 1183| 52| yyterminate(); ------------------ | | 960| 52|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 52|#define YY_NULL 0 | | ------------------ ------------------ 1184| 0|} 1185| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1186| 4|case 9: ------------------ | Branch (1186:1): [True: 4, False: 257k] ------------------ 1187| 4|YY_RULE_SETUP 1188| 4|#line 150 "libyara/hex_lexer.l" 1189| 4|{ 1190| | 1191| 4| yyerror(yyscanner, lex_env, "invalid not operator (~) in hex string"); ------------------ | | 48| 4|#define yyerror hex_yyerror ------------------ 1192| 4| yyterminate(); ------------------ | | 960| 4|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 4|#define YY_NULL 0 | | ------------------ ------------------ 1193| 0|} 1194| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1195| 7.91k|case 10: ------------------ | Branch (1195:1): [True: 7.91k, False: 249k] ------------------ 1196| 7.91k|YY_RULE_SETUP 1197| 7.91k|#line 157 "libyara/hex_lexer.l" 1198| 7.91k|{ 1199| | 1200| 7.91k| BEGIN(range); ------------------ | | 357| 7.91k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(range); ------------------ | | 771| 7.91k|#define range 2 ------------------ 1201| 7.91k| return yytext[0]; ------------------ | | 348| 7.91k|#define yytext yyg->yytext_r ------------------ 1202| 0|} 1203| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1204| 141|case 11: ------------------ | Branch (1204:1): [True: 141, False: 257k] ------------------ 1205| 141|YY_RULE_SETUP 1206| 141|#line 163 "libyara/hex_lexer.l" 1207| 141|{ 1208| | 1209| 141| BEGIN(comment); ------------------ | | 357| 141|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(comment); ------------------ | | 770| 141|#define comment 1 ------------------ 1210| 141|} 1211| 141| YY_BREAK ------------------ | | 997| 141|#define YY_BREAK /*LINTED*/break; ------------------ 1212| 141|case 12: ------------------ | Branch (1212:1): [True: 141, False: 257k] ------------------ 1213| 141|YY_RULE_SETUP 1214| 141|#line 168 "libyara/hex_lexer.l" 1215| 141|{ 1216| | 1217| 141| BEGIN(INITIAL); ------------------ | | 357| 141|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 769| 141|#define INITIAL 0 ------------------ 1218| 141|} 1219| 141| YY_BREAK ------------------ | | 997| 141|#define YY_BREAK /*LINTED*/break; ------------------ 1220| 92.5k|case 13: ------------------ | Branch (1220:1): [True: 92.5k, False: 165k] ------------------ 1221| |/* rule 13 can match eol */ 1222| 92.5k|YY_RULE_SETUP 1223| 92.5k|#line 173 "libyara/hex_lexer.l" 1224| |// skip comments 1225| 92.5k| YY_BREAK ------------------ | | 997| 92.5k|#define YY_BREAK /*LINTED*/break; ------------------ 1226| 434|case 14: ------------------ | Branch (1226:1): [True: 434, False: 257k] ------------------ 1227| 434|YY_RULE_SETUP 1228| 434|#line 175 "libyara/hex_lexer.l" 1229| |// skip single-line comments 1230| 434| YY_BREAK ------------------ | | 997| 434|#define YY_BREAK /*LINTED*/break; ------------------ 1231| 2.01k|case 15: ------------------ | Branch (1231:1): [True: 2.01k, False: 255k] ------------------ 1232| 2.01k|YY_RULE_SETUP 1233| 2.01k|#line 177 "libyara/hex_lexer.l" 1234| 2.01k|{ 1235| | 1236| 2.01k| return yytext[0]; ------------------ | | 348| 2.01k|#define yytext yyg->yytext_r ------------------ 1237| 0|} 1238| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1239| 7.58k|case 16: ------------------ | Branch (1239:1): [True: 7.58k, False: 250k] ------------------ 1240| 7.58k|YY_RULE_SETUP 1241| 7.58k|#line 182 "libyara/hex_lexer.l" 1242| 7.58k|{ 1243| | 1244| 7.58k| yylval->integer = atoi(yytext); ------------------ | | 825| 7.58k| # define yylval yyg->yylval_r ------------------ yylval->integer = atoi(yytext); ------------------ | | 348| 7.58k|#define yytext yyg->yytext_r ------------------ 1245| 7.58k| return _NUMBER_; ------------------ | | 74| 7.58k|#define _NUMBER_ 262 ------------------ 1246| 0|} 1247| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1248| 7.87k|case 17: ------------------ | Branch (1248:1): [True: 7.87k, False: 249k] ------------------ 1249| 7.87k|YY_RULE_SETUP 1250| 7.87k|#line 188 "libyara/hex_lexer.l" 1251| 7.87k|{ 1252| | 1253| 7.87k| BEGIN(INITIAL); ------------------ | | 357| 7.87k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 769| 7.87k|#define INITIAL 0 ------------------ 1254| 7.87k| return yytext[0]; ------------------ | | 348| 7.87k|#define yytext yyg->yytext_r ------------------ 1255| 0|} 1256| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1257| 480|case 18: ------------------ | Branch (1257:1): [True: 480, False: 257k] ------------------ 1258| |/* rule 18 can match eol */ 1259| 480|YY_RULE_SETUP 1260| 480|#line 194 "libyara/hex_lexer.l" 1261| |// skip whitespaces 1262| 480| YY_BREAK ------------------ | | 997| 480|#define YY_BREAK /*LINTED*/break; ------------------ 1263| 38|case 19: ------------------ | Branch (1263:1): [True: 38, False: 257k] ------------------ 1264| 38|YY_RULE_SETUP 1265| 38|#line 196 "libyara/hex_lexer.l" 1266| 38|{ 1267| | 1268| 38| yyerror(yyscanner, lex_env, "invalid character in hex string jump"); ------------------ | | 48| 38|#define yyerror hex_yyerror ------------------ 1269| 38| yyterminate(); ------------------ | | 960| 38|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 38|#define YY_NULL 0 | | ------------------ ------------------ 1270| 0|} 1271| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1272| 1.13k|case 20: ------------------ | Branch (1272:1): [True: 1.13k, False: 256k] ------------------ 1273| |/* rule 20 can match eol */ 1274| 1.13k|YY_RULE_SETUP 1275| 1.13k|#line 202 "libyara/hex_lexer.l" 1276| |// skip whitespaces 1277| 1.13k| YY_BREAK ------------------ | | 997| 1.13k|#define YY_BREAK /*LINTED*/break; ------------------ 1278| 120k|case 21: ------------------ | Branch (1278:1): [True: 120k, False: 137k] ------------------ 1279| 120k|YY_RULE_SETUP 1280| 120k|#line 204 "libyara/hex_lexer.l" 1281| 120k|{ // pass valid characters to the parser 1282| | 1283| 120k| return yytext[0]; ------------------ | | 348| 120k|#define yytext yyg->yytext_r ------------------ 1284| 0|} 1285| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1286| 16|case 22: ------------------ | Branch (1286:1): [True: 16, False: 257k] ------------------ 1287| 16|YY_RULE_SETUP 1288| 16|#line 209 "libyara/hex_lexer.l" 1289| 16|{ // reject all other characters 1290| | 1291| 16| yyerror(yyscanner, lex_env, "invalid character in hex string"); ------------------ | | 48| 16|#define yyerror hex_yyerror ------------------ 1292| 16| yyterminate(); ------------------ | | 960| 16|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 16|#define YY_NULL 0 | | ------------------ ------------------ 1293| 0|} 1294| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1295| 0|case 23: ------------------ | Branch (1295:1): [True: 0, False: 257k] ------------------ 1296| 0|YY_RULE_SETUP 1297| 0|#line 215 "libyara/hex_lexer.l" 1298| 0|ECHO; 1299| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 0|#line 1300 "libyara/hex_lexer.c" 1301| 1.02k|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 1.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.02k|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1301:1): [True: 1.02k, False: 256k] ------------------ 1302| 1.02k|case YY_STATE_EOF(comment): ------------------ | | 365| 1.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.02k|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1302:1): [True: 0, False: 257k] ------------------ 1303| 1.02k|case YY_STATE_EOF(range): ------------------ | | 365| 1.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.02k|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1303:1): [True: 0, False: 257k] ------------------ 1304| 1.02k| yyterminate(); ------------------ | | 960| 1.02k|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1.02k|#define YY_NULL 0 | | ------------------ ------------------ 1305| | 1306| 2.16k| case YY_END_OF_BUFFER: ------------------ | | 584| 2.16k|#define YY_END_OF_BUFFER 24 ------------------ | Branch (1306:2): [True: 2.16k, False: 255k] ------------------ 1307| 2.16k| { 1308| | /* Amount of text matched not including the EOB char. */ 1309| 2.16k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 2.16k|#define yytext_ptr yytext_r ------------------ 1310| | 1311| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1312| 2.16k| *yy_cp = yyg->yy_hold_char; 1313| 2.16k| YY_RESTORE_YY_MORE_OFFSET 1314| | 1315| 2.16k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 486| 2.16k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1315:8): [True: 1.14k, False: 1.02k] ------------------ 1316| 1.14k| { 1317| | /* We're scanning a new file or input source. It's 1318| | * possible that this happened because the user 1319| | * just pointed yyin at a new source and called 1320| | * yylex(). If so, then we have to assure 1321| | * consistency between YY_CURRENT_BUFFER and our 1322| | * globals. Here is the right place to do so, because 1323| | * this is the first action (other than possibly a 1324| | * back-up) that will match for the new input source. 1325| | */ 1326| 1.14k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 1.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1327| 1.14k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 1.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 1.14k|#define yyin yyg->yyin_r ------------------ 1328| 1.14k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 1.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 487| 1.14k|#define YY_BUFFER_NORMAL 1 ------------------ 1329| 1.14k| } 1330| | 1331| | /* Note that here we test for yy_c_buf_p "<=" to the position 1332| | * of the first EOB in the buffer, since yy_c_buf_p will 1333| | * already have been incremented past the NUL character 1334| | * (since all states make transitions on EOB to the 1335| | * end-of-buffer state). Contrast this with the test 1336| | * in input(). 1337| | */ 1338| 2.16k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1338:8): [True: 0, False: 2.16k] ------------------ 1339| 0| { /* This was really a NUL. */ 1340| 0| yy_state_type yy_next_state; 1341| | 1342| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1343| | 1344| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1345| | 1346| | /* Okay, we're now positioned to make the NUL 1347| | * transition. We couldn't have 1348| | * yy_get_previous_state() go ahead and do it 1349| | * for us because it doesn't know how to deal 1350| | * with the possibility of jamming (and we don't 1351| | * want to build jamming into it because then it 1352| | * will run more slowly). 1353| | */ 1354| | 1355| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1356| | 1357| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 0|#define YY_MORE_ADJ 0 ------------------ 1358| | 1359| 0| if ( yy_next_state ) ------------------ | Branch (1359:9): [True: 0, False: 0] ------------------ 1360| 0| { 1361| | /* Consume the NUL. */ 1362| 0| yy_cp = ++yyg->yy_c_buf_p; 1363| 0| yy_current_state = yy_next_state; 1364| 0| goto yy_match; 1365| 0| } 1366| | 1367| 0| else 1368| 0| { 1369| 0| yy_cp = yyg->yy_last_accepting_cpos; 1370| 0| yy_current_state = yyg->yy_last_accepting_state; 1371| 0| goto yy_find_action; 1372| 0| } 1373| 0| } 1374| | 1375| 2.16k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1375:17): [True: 0, False: 2.16k] ------------------ 1376| 2.16k| { 1377| 1.02k| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 1.02k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1377:4): [True: 1.02k, False: 1.14k] ------------------ 1378| 1.02k| { 1379| 1.02k| yyg->yy_did_buffer_switch_on_eof = 0; 1380| | 1381| 1.02k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 1.02k|#define yywrap hex_yywrap | | ------------------ | | | | 561| 1.02k|#define hex_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:31): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1382| 1.02k| { 1383| | /* Note: because we've taken care in 1384| | * yy_get_next_buffer() to have set up 1385| | * yytext, we can now set up 1386| | * yy_c_buf_p so that if some total 1387| | * hoser (like flex itself) wants to 1388| | * call the scanner after we return the 1389| | * YY_NULL, it'll still work - another 1390| | * YY_NULL will get returned. 1391| | */ 1392| 1.02k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.02k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 1.02k|#define YY_MORE_ADJ 0 ------------------ 1393| | 1394| 1.02k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 1.02k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.02k|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ 1395| 1.02k| goto do_action; 1396| 1.02k| } 1397| | 1398| 0| else 1399| 0| { 1400| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1400:11): [True: 0, False: 0] ------------------ 1401| 0| YY_NEW_FILE; ------------------ | | 367| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart hex_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1402| 0| } 1403| 0| break; 1404| 1.02k| } 1405| | 1406| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1406:4): [True: 0, False: 2.16k] ------------------ 1407| 0| yyg->yy_c_buf_p = 1408| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1409| | 1410| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1411| | 1412| 0| yy_cp = yyg->yy_c_buf_p; 1413| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 0|#define YY_MORE_ADJ 0 ------------------ 1414| 0| goto yy_match; 1415| | 1416| 1.14k| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 1.14k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1416:4): [True: 1.14k, False: 1.02k] ------------------ 1417| 1.14k| yyg->yy_c_buf_p = 1418| 1.14k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 1.14k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1419| | 1420| 1.14k| yy_current_state = yy_get_previous_state( yyscanner ); 1421| | 1422| 1.14k| yy_cp = yyg->yy_c_buf_p; 1423| 1.14k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.14k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 1.14k|#define YY_MORE_ADJ 0 ------------------ 1424| 1.14k| goto yy_find_action; 1425| 2.16k| } 1426| 0| break; 1427| 2.16k| } 1428| | 1429| 0| default: ------------------ | Branch (1429:2): [True: 0, False: 257k] ------------------ 1430| 0| YY_FATAL_ERROR( ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1431| 257k| "fatal flex scanner internal error--no action found" ); 1432| 257k| } /* end of action switch */ 1433| 257k| } /* end of scanning one token */ 1434| 160k| } /* end of user's declarations */ 1435| 160k|} /* end of yylex */ hex_yy_switch_to_buffer: 1751| 1.27k|{ 1752| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1753| | 1754| | /* TODO. We should be able to replace this entire function body 1755| | * with 1756| | * yypop_buffer_state(); 1757| | * yypush_buffer_state(new_buffer); 1758| | */ 1759| 1.27k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 1.27k|#define yyensure_buffer_stack hex_yyensure_buffer_stack ------------------ 1760| 1.27k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ | Branch (1760:7): [True: 0, False: 1.27k] ------------------ 1761| 0| return; 1762| | 1763| 1.27k| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1.27k] | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ 1764| 0| { 1765| | /* Flush out information for old buffer. */ 1766| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 1767| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1768| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1769| 0| } 1770| | 1771| 1.27k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 1.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1772| 1.27k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.27k|#define yy_load_buffer_state hex_yy_load_buffer_state ------------------ 1773| | 1774| | /* We don't actually know whether we did this switch during 1775| | * EOF (yywrap()) processing, but the only time this flag 1776| | * is looked at is after yywrap() is called, so it's safe 1777| | * to go ahead and always set it. 1778| | */ 1779| 1.27k| yyg->yy_did_buffer_switch_on_eof = 1; 1780| 1.27k|} hex_yy_delete_buffer: 1826| 1.27k|{ 1827| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1828| | 1829| 1.27k| if ( ! b ) ------------------ | Branch (1829:7): [True: 0, False: 1.27k] ------------------ 1830| 0| return; 1831| | 1832| 1.27k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ | Branch (1832:7): [True: 1.27k, False: 0] ------------------ 1833| 1.27k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 1.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1834| | 1835| 1.27k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1835:7): [True: 1.27k, False: 0] ------------------ 1836| 1.27k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree hex_yyfree ------------------ 1837| | 1838| 1.27k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree hex_yyfree ------------------ 1839| 1.27k|} hex_yypop_buffer_state: 1936| 1.27k|{ 1937| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1938| 1.27k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ | Branch (1938:6): [True: 1.27k, False: 0] ------------------ 1939| 1.27k| return; 1940| | 1941| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 0|#define yy_delete_buffer hex_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 1942| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1943| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (1943:6): [True: 0, False: 0] ------------------ 1944| 0| --yyg->yy_buffer_stack_top; 1945| | 1946| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 0] | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 1947| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state hex_yy_load_buffer_state ------------------ 1948| 0| yyg->yy_did_buffer_switch_on_eof = 1; 1949| 0| } 1950| 0|} hex_yy_scan_buffer: 2006| 1.27k|{ 2007| 1.27k| YY_BUFFER_STATE b; 2008| | 2009| 1.27k| if ( size < 2 || ------------------ | Branch (2009:7): [True: 0, False: 1.27k] ------------------ 2010| 1.27k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 2.54k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2010:7): [True: 0, False: 1.27k] ------------------ 2011| 1.27k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 1.27k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2011:7): [True: 0, False: 1.27k] ------------------ 2012| | /* They forgot to leave room for the EOB's. */ 2013| 0| return NULL; 2014| | 2015| 1.27k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 1.27k|#define yyalloc hex_yyalloc ------------------ 2016| 1.27k| if ( ! b ) ------------------ | Branch (2016:7): [True: 0, False: 1.27k] ------------------ 2017| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 2018| | 2019| 1.27k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2020| 1.27k| b->yy_buf_pos = b->yy_ch_buf = base; 2021| 1.27k| b->yy_is_our_buffer = 0; 2022| 1.27k| b->yy_input_file = NULL; 2023| 1.27k| b->yy_n_chars = b->yy_buf_size; 2024| 1.27k| b->yy_is_interactive = 0; 2025| 1.27k| b->yy_at_bol = 1; 2026| 1.27k| b->yy_fill_buffer = 0; 2027| 1.27k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 1.27k|#define YY_BUFFER_NEW 0 ------------------ 2028| | 2029| 1.27k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 1.27k|#define yy_switch_to_buffer hex_yy_switch_to_buffer ------------------ 2030| | 2031| 1.27k| return b; 2032| 1.27k|} hex_yy_scan_string: 2043| 1.27k|{ 2044| | 2045| 1.27k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 1.27k|#define yy_scan_bytes hex_yy_scan_bytes ------------------ 2046| 1.27k|} hex_yy_scan_bytes: 2056| 1.27k|{ 2057| 1.27k| YY_BUFFER_STATE b; 2058| 1.27k| char *buf; 2059| 1.27k| yy_size_t n; 2060| 1.27k| int i; 2061| | 2062| | /* Get memory for full buffer, including space for trailing EOB's. */ 2063| 1.27k| n = (yy_size_t) (_yybytes_len + 2); 2064| 1.27k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 1.27k|#define yyalloc hex_yyalloc ------------------ 2065| 1.27k| if ( ! buf ) ------------------ | Branch (2065:7): [True: 0, False: 1.27k] ------------------ 2066| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 2067| | 2068| 303k| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2068:15): [True: 301k, False: 1.27k] ------------------ 2069| 301k| buf[i] = yybytes[i]; 2070| | 2071| 1.27k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 1.27k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2072| | 2073| 1.27k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 1.27k|#define yy_scan_buffer hex_yy_scan_buffer ------------------ 2074| 1.27k| if ( ! b ) ------------------ | Branch (2074:7): [True: 0, False: 1.27k] ------------------ 2075| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 2076| | 2077| | /* It's okay to grow etc. this buffer, and we should throw it 2078| | * away when we're done. 2079| | */ 2080| 1.27k| b->yy_is_our_buffer = 1; 2081| | 2082| 1.27k| return b; 2083| 1.27k|} hex_yyget_extra: 2120| 3.16k|{ 2121| 3.16k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2122| 3.16k| return yyextra; ------------------ | | 346| 3.16k|#define yyextra yyg->yyextra_r ------------------ 2123| 3.16k|} hex_yyset_extra: 2193| 1.27k|{ 2194| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2195| 1.27k| yyextra = user_defined ; ------------------ | | 346| 1.27k|#define yyextra yyg->yyextra_r ------------------ 2196| 1.27k|} hex_yylex_init: 2279| 1.27k|{ 2280| 1.27k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2280:9): [True: 0, False: 1.27k] ------------------ 2281| 0| errno = EINVAL; 2282| 0| return 1; 2283| 0| } 2284| | 2285| 1.27k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 1.27k|#define yyalloc hex_yyalloc ------------------ 2286| | 2287| 1.27k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2287:9): [True: 0, False: 1.27k] ------------------ 2288| 0| errno = ENOMEM; 2289| 0| return 1; 2290| 0| } 2291| | 2292| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2293| 1.27k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2294| | 2295| 1.27k| return yy_init_globals ( *ptr_yy_globals ); 2296| 1.27k|} hex_yylex_destroy: 2367| 1.27k|{ 2368| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2369| | 2370| | /* Pop the buffer stack, destroying each element. */ 2371| 2.54k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 2.54k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 1.27k, False: 1.27k] | | | Branch (509:29): [True: 2.54k, False: 0] | | ------------------ | | 510| 2.54k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 2.54k| : NULL) ------------------ 2372| 1.27k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 1.27k|#define yy_delete_buffer hex_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 1.27k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.27k, False: 0] | | ------------------ | | 510| 1.27k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.27k| : NULL) ------------------ 2373| 1.27k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 1.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2374| 1.27k| yypop_buffer_state(yyscanner); ------------------ | | 80| 1.27k|#define yypop_buffer_state hex_yypop_buffer_state ------------------ 2375| 1.27k| } 2376| | 2377| | /* Destroy the stack itself. */ 2378| 1.27k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 1.27k|#define yyfree hex_yyfree ------------------ 2379| 1.27k| yyg->yy_buffer_stack = NULL; 2380| | 2381| | /* Destroy the start condition stack. */ 2382| 1.27k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree hex_yyfree ------------------ 2383| 1.27k| yyg->yy_start_stack = NULL; 2384| | 2385| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2386| | * yylex() is called, initialization will occur. */ 2387| 1.27k| yy_init_globals( yyscanner); 2388| | 2389| | /* Destroy the main struct (reentrant only). */ 2390| 1.27k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree hex_yyfree ------------------ 2391| 1.27k| yyscanner = NULL; 2392| 1.27k| return 0; 2393| 1.27k|} hex_yyalloc: 2423| 5.08k|{ 2424| 5.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2425| 5.08k| (void)yyg; 2426| 5.08k| return malloc(size); 2427| 5.08k|} hex_yyfree: 2445| 6.35k|{ 2446| 6.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2447| 6.35k| (void)yyg; 2448| 6.35k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2449| 6.35k|} hex_yyerror: 2477| 353|{ 2478| | // if lex_env->last_error was set to some error code before 2479| | // don't overwrite it, we are interested in the first error, not in 2480| | // subsequent errors like "syntax error, unexpected $end" caused by 2481| | // early parser termination. 2482| | 2483| 353| if (lex_env->last_error == ERROR_SUCCESS) ------------------ | | 40| 353|#define ERROR_SUCCESS 0 ------------------ | Branch (2483:7): [True: 243, False: 110] ------------------ 2484| 243| { 2485| 243| lex_env->last_error = ERROR_INVALID_HEX_STRING; ------------------ | | 55| 243|#define ERROR_INVALID_HEX_STRING 10 ------------------ 2486| | 2487| 243| strlcpy( 2488| 243| lex_env->last_error_message, 2489| 243| error_message, 2490| 243| sizeof(lex_env->last_error_message)); 2491| 243| } 2492| 353|} yr_parse_hex_string: 2499| 1.27k|{ 2500| 1.27k| yyscan_t yyscanner; 2501| 1.27k| jmp_buf recovery_trampoline; 2502| 1.27k| HEX_LEX_ENVIRONMENT lex_env; 2503| | 2504| 1.27k| lex_env.last_error = ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 2505| 1.27k| lex_env.inside_or = 0; 2506| | 2507| 1.27k| yr_thread_storage_set_value( 2508| 1.27k| &yr_yyfatal_trampoline_tls, 2509| 1.27k| &recovery_trampoline); 2510| | 2511| 1.27k| if (setjmp(recovery_trampoline) != 0) ------------------ | Branch (2511:7): [True: 0, False: 1.27k] ------------------ 2512| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 2513| | 2514| 1.27k| FAIL_ON_ERROR(yr_re_ast_create(re_ast)); ------------------ | | 134| 1.27k| { \ | | 135| 1.27k| int __error = (x); \ | | 136| 1.27k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.27k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.27k] | | ------------------ | | 137| 1.27k| return __error; \ | | 138| 1.27k| } ------------------ 2515| | 2516| | // The RE_FLAGS_FAST_REGEXP flag indicates a regular expression can be 2517| | // matched by faster algorithm. These regular expressions come from hex 2518| | // strings that do not contain alternatives, like in: 2519| | // 2520| | // { ( 01 02 | 03 04) 05 06 }. 2521| | // 2522| | // This flag is unset later during parsing if alternatives are used. 2523| | 2524| 1.27k| (*re_ast)->flags |= RE_FLAGS_FAST_REGEXP; ------------------ | | 94| 1.27k|#define RE_FLAGS_FAST_REGEXP 0x02 ------------------ 2525| | 2526| | // Set RE_FLAGS_DOT_ALL because in hex strings the "dot" (?? in this case) 2527| | // must match all characters including new-line. 2528| | 2529| 1.27k| (*re_ast)->flags |= RE_FLAGS_DOT_ALL; ------------------ | | 100| 1.27k|#define RE_FLAGS_DOT_ALL 0x80 ------------------ 2530| | 2531| 1.27k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 1.27k|#define yylex_init hex_yylex_init ------------------ | Branch (2531:7): [True: 0, False: 1.27k] ------------------ 2532| 0| { 2533| 0| yr_re_ast_destroy(*re_ast); 2534| 0| *re_ast = NULL; 2535| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 2536| 0| } 2537| | 2538| 1.27k| yyset_extra(*re_ast, yyscanner); ------------------ | | 140| 1.27k|#define yyset_extra hex_yyset_extra ------------------ 2539| 1.27k| yy_scan_string(hex_string, yyscanner); ------------------ | | 38| 1.27k|#define yy_scan_string hex_yy_scan_string ------------------ 2540| 1.27k| yyparse(yyscanner, &lex_env); ------------------ | | 46| 1.27k|#define yyparse hex_yyparse ------------------ 2541| 1.27k| yylex_destroy(yyscanner); ------------------ | | 116| 1.27k|#define yylex_destroy hex_yylex_destroy ------------------ 2542| | 2543| 1.27k| if (lex_env.last_error != ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (2543:7): [True: 243, False: 1.02k] ------------------ 2544| 243| { 2545| 243| strlcpy(error->message, lex_env.last_error_message, sizeof(error->message)); 2546| 243| return lex_env.last_error; 2547| 243| } 2548| | 2549| 1.02k| return ERROR_SUCCESS; ------------------ | | 40| 1.02k|#define ERROR_SUCCESS 0 ------------------ 2550| 1.27k|} hex_lexer.c:yy_get_next_buffer: 1445| 2.16k|{ 1446| 2.16k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1447| 2.16k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1448| 2.16k| char *source = yyg->yytext_ptr; ------------------ | | 567| 2.16k|#define yytext_ptr yytext_r ------------------ 1449| 2.16k| int number_to_move, i; 1450| 2.16k| int ret_val; 1451| | 1452| 2.16k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1452:7): [True: 0, False: 2.16k] ------------------ 1453| 0| YY_FATAL_ERROR( ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1454| 2.16k| "fatal flex scanner internal error--end of buffer missed" ); 1455| | 1456| 2.16k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 2.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1456:7): [True: 2.16k, False: 0] ------------------ 1457| 2.16k| { /* Don't try to fill the buffer, so this is an EOF. */ 1458| 2.16k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 2.16k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 691| 2.16k|#define YY_MORE_ADJ 0 ------------------ | Branch (1458:8): [True: 1.02k, False: 1.14k] ------------------ 1459| 1.02k| { 1460| | /* We matched a single character, the EOB, so 1461| | * treat this as a final EOF. 1462| | */ 1463| 1.02k| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 1.02k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1464| 1.02k| } 1465| | 1466| 1.14k| else 1467| 1.14k| { 1468| | /* We matched some text prior to the EOB, first 1469| | * process it. 1470| | */ 1471| 1.14k| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 1.14k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1472| 1.14k| } 1473| 2.16k| } 1474| | 1475| | /* Try to read more data. */ 1476| | 1477| | /* First move last chars to start of buffer. */ 1478| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1479| | 1480| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1480:15): [True: 0, False: 0] ------------------ 1481| 0| *(dest++) = *(source++); 1482| | 1483| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1483:7): [True: 0, False: 0] ------------------ 1484| | /* don't do the read, it's not guaranteed to return an EOF, 1485| | * just force an EOF 1486| | */ 1487| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1488| | 1489| 0| else 1490| 0| { 1491| 0| int num_to_read = 1492| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1493| | 1494| 0| while ( num_to_read <= 0 ) ------------------ | Branch (1494:11): [True: 0, False: 0] ------------------ 1495| 0| { /* Not enough room in the buffer - grow it. */ 1496| | 1497| | /* just a shorter name for the current buffer */ 1498| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1499| | 1500| 0| int yy_c_buf_p_offset = 1501| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1502| | 1503| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (1503:9): [True: 0, False: 0] ------------------ 1504| 0| { 1505| 0| int new_size = b->yy_buf_size * 2; 1506| | 1507| 0| if ( new_size <= 0 ) ------------------ | Branch (1507:10): [True: 0, False: 0] ------------------ 1508| 0| b->yy_buf_size += b->yy_buf_size / 8; 1509| 0| else 1510| 0| b->yy_buf_size *= 2; 1511| | 1512| 0| b->yy_ch_buf = (char *) 1513| | /* Include room in for 2 EOB chars. */ 1514| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 230| 0|#define yyrealloc hex_yyrealloc ------------------ 1515| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1516| 0| } 1517| 0| else 1518| | /* Can't grow it, we don't own it. */ 1519| 0| b->yy_ch_buf = NULL; 1520| | 1521| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (1521:9): [True: 0, False: 0] ------------------ 1522| 0| YY_FATAL_ERROR( ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1523| 0| "fatal error - scanner input buffer overflow" ); 1524| | 1525| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1526| | 1527| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1528| 0| number_to_move - 1; 1529| | 1530| 0| } 1531| | 1532| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 907| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1532:8): [True: 0, False: 0] ------------------ 1533| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 907| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 1534| | 1535| | /* Read in more data. */ 1536| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 924| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (924:7): [True: 0, False: 0] | | ------------------ | | 925| 0| { \ | | 926| 0| int c = '*'; \ | | 927| 0| int n; \ | | 928| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (928:16): [True: 0, False: 0] | | ------------------ | | 929| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (929:9): [True: 0, False: 0] | | | Branch (929:38): [True: 0, False: 0] | | ------------------ | | 930| 0| buf[n] = (char) c; \ | | 931| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (931:8): [True: 0, False: 0] | | ------------------ | | 932| 0| buf[n++] = (char) c; \ | | 933| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (933:8): [True: 0, False: 0] | | | Branch (933:20): [True: 0, False: 0] | | ------------------ | | 934| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) | | ------------------ | | 935| 0| result = n; \ | | 936| 0| } \ | | 937| 0| else \ | | 938| 0| { \ | | 939| 0| errno=0; \ | | 940| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (940:11): [True: 0, False: 0] | | | Branch (940:78): [True: 0, False: 0] | | ------------------ | | 941| 0| { \ | | 942| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (942:8): [True: 0, False: 0] | | ------------------ | | 943| 0| { \ | | 944| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) | | ------------------ | | 945| 0| break; \ | | 946| 0| } \ | | 947| 0| errno=0; \ | | 948| 0| clearerr(yyin); \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | 949| 0| } \ | | 950| 0| }\ ------------------ 1537| 0| yyg->yy_n_chars, num_to_read ); 1538| | 1539| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1540| 0| } 1541| | 1542| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1542:7): [True: 0, False: 0] ------------------ 1543| 0| { 1544| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 691| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1544:8): [True: 0, False: 0] ------------------ 1545| 0| { 1546| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 398| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1547| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart hex_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ 1548| 0| } 1549| | 1550| 0| else 1551| 0| { 1552| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 399| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1553| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1554| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1555| 0| } 1556| 0| } 1557| | 1558| 0| else 1559| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1560| | 1561| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1561:6): [True: 0, False: 0] ------------------ 1562| | /* Extend the array by 50%, plus the number we really need. */ 1563| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1564| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 230| 0|#define yyrealloc hex_yyrealloc ------------------ 1565| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1566| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1566:8): [True: 0, False: 0] ------------------ 1567| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1568| | /* "- 2" to take care of EOB's */ 1569| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1570| 0| } 1571| | 1572| 0| yyg->yy_n_chars += number_to_move; 1573| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1574| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1575| | 1576| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1577| | 1578| 0| return ret_val; 1579| 2.16k|} hex_lexer.c:yy_get_previous_state: 1584| 1.14k|{ 1585| 1.14k| yy_state_type yy_current_state; 1586| 1.14k| char *yy_cp; 1587| 1.14k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1588| | 1589| 1.14k| yy_current_state = yyg->yy_start; 1590| | 1591| 2.28k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 1.14k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 691| 1.14k|#define YY_MORE_ADJ 0 ------------------ | Branch (1591:47): [True: 1.14k, False: 1.14k] ------------------ 1592| 1.14k| { 1593| 1.14k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 1.14k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1593:19): [True: 1.14k, False: 0] ------------------ 1594| 1.14k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1594:8): [True: 0, False: 1.14k] ------------------ 1595| 0| { 1596| 0| yyg->yy_last_accepting_state = yy_current_state; 1597| 0| yyg->yy_last_accepting_cpos = yy_cp; 1598| 0| } 1599| 1.16k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1599:11): [True: 24, False: 1.14k] ------------------ 1600| 24| { 1601| 24| yy_current_state = (int) yy_def[yy_current_state]; 1602| 24| if ( yy_current_state >= 40 ) ------------------ | Branch (1602:9): [True: 24, False: 0] ------------------ 1603| 24| yy_c = yy_meta[yy_c]; 1604| 24| } 1605| 1.14k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1606| 1.14k| } 1607| | 1608| 1.14k| return yy_current_state; 1609| 1.14k|} hex_lexer.c:hex_yy_load_buffer_state: 1783| 2.54k|{ 1784| 2.54k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1785| 2.54k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 2.54k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1786| 2.54k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 2.54k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 2.54k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1787| 2.54k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 2.54k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 2.54k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1788| 2.54k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1789| 2.54k|} hex_lexer.c:hex_yyensure_buffer_stack: 1956| 1.27k|{ 1957| 1.27k| yy_size_t num_to_alloc; 1958| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1959| | 1960| 1.27k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (1960:6): [True: 1.27k, False: 0] ------------------ 1961| | 1962| | /* First allocation is just for 2 elements, since we don't know if this 1963| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 1964| | * immediate realloc on the next call. 1965| | */ 1966| 1.27k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 1967| 1.27k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 1.27k|#define yyalloc hex_yyalloc ------------------ 1968| 1.27k| (num_to_alloc * sizeof(struct yy_buffer_state*) 1969| 1.27k| , yyscanner); 1970| 1.27k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (1970:8): [True: 0, False: 1.27k] ------------------ 1971| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1972| | 1973| 1.27k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1974| | 1975| 1.27k| yyg->yy_buffer_stack_max = num_to_alloc; 1976| 1.27k| yyg->yy_buffer_stack_top = 0; 1977| 1.27k| return; 1978| 1.27k| } 1979| | 1980| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (1980:6): [True: 0, False: 0] ------------------ 1981| | 1982| | /* Increase the buffer to prepare for a possible push. */ 1983| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 1984| | 1985| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 1986| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 230| 0|#define yyrealloc hex_yyrealloc ------------------ 1987| 0| (yyg->yy_buffer_stack, 1988| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 1989| 0| , yyscanner); 1990| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (1990:8): [True: 0, False: 0] ------------------ 1991| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 86| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1992| | 1993| | /* zero only the new slots.*/ 1994| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 1995| 0| yyg->yy_buffer_stack_max = num_to_alloc; 1996| 0| } 1997| 0|} hex_lexer.c:yy_init_globals: 2333| 2.54k|{ 2334| 2.54k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2335| | /* Initialization is the same as for the non-reentrant scanner. 2336| | * This function is called from yylex_destroy(), so don't allocate here. 2337| | */ 2338| | 2339| 2.54k| yyg->yy_buffer_stack = NULL; 2340| 2.54k| yyg->yy_buffer_stack_top = 0; 2341| 2.54k| yyg->yy_buffer_stack_max = 0; 2342| 2.54k| yyg->yy_c_buf_p = NULL; 2343| 2.54k| yyg->yy_init = 0; 2344| 2.54k| yyg->yy_start = 0; 2345| | 2346| 2.54k| yyg->yy_start_stack_ptr = 0; 2347| 2.54k| yyg->yy_start_stack_depth = 0; 2348| 2.54k| yyg->yy_start_stack = NULL; 2349| | 2350| |/* Defined in main.c */ 2351| |#ifdef YY_STDINIT 2352| | yyin = stdin; 2353| | yyout = stdout; 2354| |#else 2355| 2.54k| yyin = NULL; ------------------ | | 344| 2.54k|#define yyin yyg->yyin_r ------------------ 2356| 2.54k| yyout = NULL; ------------------ | | 345| 2.54k|#define yyout yyg->yyout_r ------------------ 2357| 2.54k|#endif 2358| | 2359| | /* For future reference: Set errno on error, since we are called by 2360| | * yylex_init() 2361| | */ 2362| 2.54k| return 0; 2363| 2.54k|} yara_yylex: 1278| 571k|{ 1279| 571k| yy_state_type yy_current_state; 1280| 571k| char *yy_cp, *yy_bp; 1281| 571k| int yy_act; 1282| 571k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1283| | 1284| 571k| yylval = yylval_param; ------------------ | | 1097| 571k| # define yylval yyg->yylval_r ------------------ 1285| | 1286| 571k| if ( !yyg->yy_init ) ------------------ | Branch (1286:7): [True: 1.72k, False: 569k] ------------------ 1287| 1.72k| { 1288| 1.72k| yyg->yy_init = 1; 1289| | 1290| |#ifdef YY_USER_INIT 1291| | YY_USER_INIT; 1292| |#endif 1293| | 1294| 1.72k| if ( ! yyg->yy_start ) ------------------ | Branch (1294:8): [True: 1.72k, False: 0] ------------------ 1295| 1.72k| yyg->yy_start = 1; /* first start state */ 1296| | 1297| 1.72k| if ( ! yyin ) ------------------ | | 344| 1.72k|#define yyin yyg->yyin_r ------------------ | Branch (1297:8): [True: 1.72k, False: 0] ------------------ 1298| 1.72k| yyin = stdin; ------------------ | | 344| 1.72k|#define yyin yyg->yyin_r ------------------ 1299| | 1300| 1.72k| if ( ! yyout ) ------------------ | | 345| 1.72k|#define yyout yyg->yyout_r ------------------ | Branch (1300:8): [True: 1.72k, False: 0] ------------------ 1301| 1.72k| yyout = stdout; ------------------ | | 345| 1.72k|#define yyout yyg->yyout_r ------------------ 1302| | 1303| 1.72k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ | Branch (1303:8): [True: 0, False: 1.72k] ------------------ 1304| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack yara_yyensure_buffer_stack ------------------ 1305| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1306| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer yara_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 379| 0|#define YY_BUF_SIZE 16384 ------------------ 1307| 0| } 1308| | 1309| 1.72k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.72k|#define yy_load_buffer_state yara_yy_load_buffer_state ------------------ 1310| 1.72k| } 1311| | 1312| 571k| { 1313| 571k|#line 163 "libyara/lexer.l" 1314| | 1315| | 1316| 571k|#line 1316 "libyara/lexer.c" 1317| | 1318| 764k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1318:23): [Folded - Ignored] ------------------ 1319| 764k| { 1320| 764k| yy_cp = yyg->yy_c_buf_p; 1321| | 1322| | /* Support of yytext. */ 1323| 764k| *yy_cp = yyg->yy_hold_char; 1324| | 1325| | /* yy_bp points to the position in yy_ch_buf of the start of 1326| | * the current run. 1327| | */ 1328| 764k| yy_bp = yy_cp; 1329| | 1330| 764k| yy_current_state = yyg->yy_start; 1331| 764k|yy_match: 1332| 764k| do 1333| 4.24M| { 1334| 4.24M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 4.24M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1335| 4.24M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1335:9): [True: 3.14M, False: 1.09M] ------------------ 1336| 3.14M| { 1337| 3.14M| yyg->yy_last_accepting_state = yy_current_state; 1338| 3.14M| yyg->yy_last_accepting_cpos = yy_cp; 1339| 3.14M| } 1340| 7.78M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1340:12): [True: 3.54M, False: 4.24M] ------------------ 1341| 3.54M| { 1342| 3.54M| yy_current_state = (int) yy_def[yy_current_state]; 1343| 3.54M| if ( yy_current_state >= 295 ) ------------------ | Branch (1343:10): [True: 2.74M, False: 803k] ------------------ 1344| 2.74M| yy_c = yy_meta[yy_c]; 1345| 3.54M| } 1346| 4.24M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1347| 4.24M| ++yy_cp; 1348| 4.24M| } 1349| 4.24M| while ( yy_current_state != 294 ); ------------------ | Branch (1349:11): [True: 3.47M, False: 764k] ------------------ 1350| 764k| yy_cp = yyg->yy_last_accepting_cpos; 1351| 764k| yy_current_state = yyg->yy_last_accepting_state; 1352| | 1353| 766k|yy_find_action: 1354| 766k| yy_act = yy_accept[yy_current_state]; 1355| | 1356| 766k| YY_DO_BEFORE_ACTION; ------------------ | | 578| 766k| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 766k|#define yytext_ptr yytext_r | | ------------------ | | 579| 766k| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 766k|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 766k| yyg->yy_hold_char = *yy_cp; \ | | 581| 766k| *yy_cp = '\0'; \ | | 582| 766k| yyg->yy_c_buf_p = yy_cp; ------------------ 1357| | 1358| 766k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 1.53M|#define YY_END_OF_BUFFER 87 ------------------ | Branch (1358:8): [True: 763k, False: 2.84k] | Branch (1358:38): [True: 79.4k, False: 683k] ------------------ 1359| 79.4k| { 1360| 79.4k| int yyl; 1361| 483k| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 483k|#define yyleng yyg->yyleng_r ------------------ | Branch (1361:19): [True: 403k, False: 79.4k] ------------------ 1362| 403k| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 403k|#define yytext yyg->yytext_r ------------------ | Branch (1362:10): [True: 35.0k, False: 368k] ------------------ 1363| | 1364| 35.0k| do{ yylineno++; ------------------ | | 349| 35.0k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 35.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1365| 35.0k| yycolumn=0; ------------------ | | 350| 35.0k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 35.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1366| 35.0k| }while(0) ------------------ | Branch (1366:12): [Folded - Ignored] ------------------ 1367| 79.4k|; 1368| 79.4k| } 1369| | 1370| 767k|do_action: /* This label is used only to access EOF actions. */ 1371| | 1372| 767k| switch ( yy_act ) 1373| 767k| { /* beginning of action switch */ 1374| 28| case 0: /* must back up */ ------------------ | Branch (1374:4): [True: 28, False: 767k] ------------------ 1375| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1376| 28| *yy_cp = yyg->yy_hold_char; 1377| 28| yy_cp = yyg->yy_last_accepting_cpos; 1378| 28| yy_current_state = yyg->yy_last_accepting_state; 1379| 28| goto yy_find_action; 1380| | 1381| 857|case 1: ------------------ | Branch (1381:1): [True: 857, False: 766k] ------------------ 1382| 857|YY_RULE_SETUP 1383| 857|#line 165 "libyara/lexer.l" 1384| 857|{ return _DOT_DOT_; } ------------------ | | 127| 857|#define _DOT_DOT_ 259 ------------------ 1385| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1386| 1.84k|case 2: ------------------ | Branch (1386:1): [True: 1.84k, False: 765k] ------------------ 1387| 1.84k|YY_RULE_SETUP 1388| 1.84k|#line 166 "libyara/lexer.l" 1389| 1.84k|{ return _LT_; } ------------------ | | 180| 1.84k|#define _LT_ 312 ------------------ 1390| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1391| 2.06k|case 3: ------------------ | Branch (1391:1): [True: 2.06k, False: 765k] ------------------ 1392| 2.06k|YY_RULE_SETUP 1393| 2.06k|#line 167 "libyara/lexer.l" 1394| 2.06k|{ return _GT_; } ------------------ | | 182| 2.06k|#define _GT_ 314 ------------------ 1395| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1396| 3.95k|case 4: ------------------ | Branch (1396:1): [True: 3.95k, False: 763k] ------------------ 1397| 3.95k|YY_RULE_SETUP 1398| 3.95k|#line 168 "libyara/lexer.l" 1399| 3.95k|{ return _LE_; } ------------------ | | 181| 3.95k|#define _LE_ 313 ------------------ 1400| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1401| 950|case 5: ------------------ | Branch (1401:1): [True: 950, False: 766k] ------------------ 1402| 950|YY_RULE_SETUP 1403| 950|#line 169 "libyara/lexer.l" 1404| 950|{ return _GE_; } ------------------ | | 183| 950|#define _GE_ 315 ------------------ 1405| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1406| 1.03k|case 6: ------------------ | Branch (1406:1): [True: 1.03k, False: 766k] ------------------ 1407| 1.03k|YY_RULE_SETUP 1408| 1.03k|#line 170 "libyara/lexer.l" 1409| 1.03k|{ return _EQ_; } ------------------ | | 178| 1.03k|#define _EQ_ 310 ------------------ 1410| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1411| 982|case 7: ------------------ | Branch (1411:1): [True: 982, False: 766k] ------------------ 1412| 982|YY_RULE_SETUP 1413| 982|#line 171 "libyara/lexer.l" 1414| 982|{ return _NEQ_; } ------------------ | | 179| 982|#define _NEQ_ 311 ------------------ 1415| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1416| 2.55k|case 8: ------------------ | Branch (1416:1): [True: 2.55k, False: 764k] ------------------ 1417| 2.55k|YY_RULE_SETUP 1418| 2.55k|#line 172 "libyara/lexer.l" 1419| 2.55k|{ return _SHIFT_LEFT_; } ------------------ | | 184| 2.55k|#define _SHIFT_LEFT_ 316 ------------------ 1420| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1421| 3.13k|case 9: ------------------ | Branch (1421:1): [True: 3.13k, False: 764k] ------------------ 1422| 3.13k|YY_RULE_SETUP 1423| 3.13k|#line 173 "libyara/lexer.l" 1424| 3.13k|{ return _SHIFT_RIGHT_; } ------------------ | | 185| 3.13k|#define _SHIFT_RIGHT_ 317 ------------------ 1425| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1426| 568|case 10: ------------------ | Branch (1426:1): [True: 568, False: 766k] ------------------ 1427| 568|YY_RULE_SETUP 1428| 568|#line 174 "libyara/lexer.l" 1429| 568|{ return _PRIVATE_; } ------------------ | | 129| 568|#define _PRIVATE_ 261 ------------------ 1430| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1431| 435|case 11: ------------------ | Branch (1431:1): [True: 435, False: 767k] ------------------ 1432| 435|YY_RULE_SETUP 1433| 435|#line 175 "libyara/lexer.l" 1434| 435|{ return _GLOBAL_; } ------------------ | | 130| 435|#define _GLOBAL_ 262 ------------------ 1435| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1436| 14.6k|case 12: ------------------ | Branch (1436:1): [True: 14.6k, False: 752k] ------------------ 1437| 14.6k|YY_RULE_SETUP 1438| 14.6k|#line 176 "libyara/lexer.l" 1439| 14.6k|{ return _RULE_; } ------------------ | | 128| 14.6k|#define _RULE_ 260 ------------------ 1440| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1441| 253|case 13: ------------------ | Branch (1441:1): [True: 253, False: 767k] ------------------ 1442| 253|YY_RULE_SETUP 1443| 253|#line 177 "libyara/lexer.l" 1444| 253|{ return _META_; } ------------------ | | 131| 253|#define _META_ 263 ------------------ 1445| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1446| 3.32k|case 14: ------------------ | Branch (1446:1): [True: 3.32k, False: 764k] ------------------ 1447| 3.32k|YY_RULE_SETUP 1448| 3.32k|#line 178 "libyara/lexer.l" 1449| 3.32k|{ return _STRINGS_; } ------------------ | | 132| 3.32k|#define _STRINGS_ 264 ------------------ 1450| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1451| 1.13k|case 15: ------------------ | Branch (1451:1): [True: 1.13k, False: 766k] ------------------ 1452| 1.13k|YY_RULE_SETUP 1453| 1.13k|#line 179 "libyara/lexer.l" 1454| 1.13k|{ return _ASCII_; } ------------------ | | 146| 1.13k|#define _ASCII_ 278 ------------------ 1455| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1456| 1.57k|case 16: ------------------ | Branch (1456:1): [True: 1.57k, False: 765k] ------------------ 1457| 1.57k|YY_RULE_SETUP 1458| 1.57k|#line 180 "libyara/lexer.l" 1459| 1.57k|{ return _WIDE_; } ------------------ | | 147| 1.57k|#define _WIDE_ 279 ------------------ 1460| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1461| 1.70k|case 17: ------------------ | Branch (1461:1): [True: 1.70k, False: 765k] ------------------ 1462| 1.70k|YY_RULE_SETUP 1463| 1.70k|#line 181 "libyara/lexer.l" 1464| 1.70k|{ return _XOR_; } ------------------ | | 148| 1.70k|#define _XOR_ 280 ------------------ 1465| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1466| 1.60k|case 18: ------------------ | Branch (1466:1): [True: 1.60k, False: 765k] ------------------ 1467| 1.60k|YY_RULE_SETUP 1468| 1.60k|#line 182 "libyara/lexer.l" 1469| 1.60k|{ return _BASE64_; } ------------------ | | 149| 1.60k|#define _BASE64_ 281 ------------------ 1470| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1471| 1.75k|case 19: ------------------ | Branch (1471:1): [True: 1.75k, False: 765k] ------------------ 1472| 1.75k|YY_RULE_SETUP 1473| 1.75k|#line 183 "libyara/lexer.l" 1474| 1.75k|{ return _BASE64_WIDE_; } ------------------ | | 150| 1.75k|#define _BASE64_WIDE_ 282 ------------------ 1475| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 480|case 20: ------------------ | Branch (1476:1): [True: 480, False: 766k] ------------------ 1477| 480|YY_RULE_SETUP 1478| 480|#line 184 "libyara/lexer.l" 1479| 480|{ return _FULLWORD_; } ------------------ | | 152| 480|#define _FULLWORD_ 284 ------------------ 1480| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1481| 581|case 21: ------------------ | Branch (1481:1): [True: 581, False: 766k] ------------------ 1482| 581|YY_RULE_SETUP 1483| 581|#line 185 "libyara/lexer.l" 1484| 581|{ return _NOCASE_; } ------------------ | | 151| 581|#define _NOCASE_ 283 ------------------ 1485| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1486| 6.10k|case 22: ------------------ | Branch (1486:1): [True: 6.10k, False: 761k] ------------------ 1487| 6.10k|YY_RULE_SETUP 1488| 6.10k|#line 186 "libyara/lexer.l" 1489| 6.10k|{ return _CONDITION_; } ------------------ | | 133| 6.10k|#define _CONDITION_ 265 ------------------ 1490| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1491| 223|case 23: ------------------ | Branch (1491:1): [True: 223, False: 767k] ------------------ 1492| 223|YY_RULE_SETUP 1493| 223|#line 187 "libyara/lexer.l" 1494| 223|{ return _TRUE_; } ------------------ | | 172| 223|#define _TRUE_ 304 ------------------ 1495| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1496| 421|case 24: ------------------ | Branch (1496:1): [True: 421, False: 767k] ------------------ 1497| 421|YY_RULE_SETUP 1498| 421|#line 188 "libyara/lexer.l" 1499| 421|{ return _FALSE_; } ------------------ | | 173| 421|#define _FALSE_ 305 ------------------ 1500| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1501| 335|case 25: ------------------ | Branch (1501:1): [True: 335, False: 767k] ------------------ 1502| 335|YY_RULE_SETUP 1503| 335|#line 189 "libyara/lexer.l" 1504| 335|{ return _NOT_; } ------------------ | | 176| 335|#define _NOT_ 308 ------------------ 1505| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1506| 237|case 26: ------------------ | Branch (1506:1): [True: 237, False: 767k] ------------------ 1507| 237|YY_RULE_SETUP 1508| 237|#line 190 "libyara/lexer.l" 1509| 237|{ return _AND_; } ------------------ | | 175| 237|#define _AND_ 307 ------------------ 1510| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1511| 13.0k|case 27: ------------------ | Branch (1511:1): [True: 13.0k, False: 754k] ------------------ 1512| 13.0k|YY_RULE_SETUP 1513| 13.0k|#line 191 "libyara/lexer.l" 1514| 13.0k|{ return _OR_; } ------------------ | | 174| 13.0k|#define _OR_ 306 ------------------ 1515| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1516| 9.66k|case 28: ------------------ | Branch (1516:1): [True: 9.66k, False: 757k] ------------------ 1517| 9.66k|YY_RULE_SETUP 1518| 9.66k|#line 192 "libyara/lexer.l" 1519| 9.66k|{ return _AT_; } ------------------ | | 153| 9.66k|#define _AT_ 285 ------------------ 1520| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1521| 3.28k|case 29: ------------------ | Branch (1521:1): [True: 3.28k, False: 764k] ------------------ 1522| 3.28k|YY_RULE_SETUP 1523| 3.28k|#line 193 "libyara/lexer.l" 1524| 3.28k|{ return _IN_; } ------------------ | | 159| 3.28k|#define _IN_ 291 ------------------ 1525| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1526| 12.4k|case 30: ------------------ | Branch (1526:1): [True: 12.4k, False: 755k] ------------------ 1527| 12.4k|YY_RULE_SETUP 1528| 12.4k|#line 194 "libyara/lexer.l" 1529| 12.4k|{ return _OF_; } ------------------ | | 160| 12.4k|#define _OF_ 292 ------------------ 1530| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1531| 540|case 31: ------------------ | Branch (1531:1): [True: 540, False: 766k] ------------------ 1532| 540|YY_RULE_SETUP 1533| 540|#line 195 "libyara/lexer.l" 1534| 540|{ return _THEM_; } ------------------ | | 162| 540|#define _THEM_ 294 ------------------ 1535| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1536| 3.52k|case 32: ------------------ | Branch (1536:1): [True: 3.52k, False: 763k] ------------------ 1537| 3.52k|YY_RULE_SETUP 1538| 3.52k|#line 196 "libyara/lexer.l" 1539| 3.52k|{ return _FOR_; } ------------------ | | 161| 3.52k|#define _FOR_ 293 ------------------ 1540| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1541| 3.13k|case 33: ------------------ | Branch (1541:1): [True: 3.13k, False: 764k] ------------------ 1542| 3.13k|YY_RULE_SETUP 1543| 3.13k|#line 197 "libyara/lexer.l" 1544| 3.13k|{ return _ALL_; } ------------------ | | 156| 3.13k|#define _ALL_ 288 ------------------ 1545| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1546| 1.55k|case 34: ------------------ | Branch (1546:1): [True: 1.55k, False: 765k] ------------------ 1547| 1.55k|YY_RULE_SETUP 1548| 1.55k|#line 198 "libyara/lexer.l" 1549| 1.55k|{ return _ANY_; } ------------------ | | 157| 1.55k|#define _ANY_ 289 ------------------ 1550| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1551| 134|case 35: ------------------ | Branch (1551:1): [True: 134, False: 767k] ------------------ 1552| 134|YY_RULE_SETUP 1553| 134|#line 199 "libyara/lexer.l" 1554| 134|{ return _NONE_; } ------------------ | | 158| 134|#define _NONE_ 290 ------------------ 1555| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1556| 185|case 36: ------------------ | Branch (1556:1): [True: 185, False: 767k] ------------------ 1557| 185|YY_RULE_SETUP 1558| 185|#line 200 "libyara/lexer.l" 1559| 185|{ return _ENTRYPOINT_; } ------------------ | | 155| 185|#define _ENTRYPOINT_ 287 ------------------ 1560| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1561| 446|case 37: ------------------ | Branch (1561:1): [True: 446, False: 766k] ------------------ 1562| 446|YY_RULE_SETUP 1563| 446|#line 201 "libyara/lexer.l" 1564| 446|{ return _FILESIZE_; } ------------------ | | 154| 446|#define _FILESIZE_ 286 ------------------ 1565| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1566| 214|case 38: ------------------ | Branch (1566:1): [True: 214, False: 767k] ------------------ 1567| 214|YY_RULE_SETUP 1568| 214|#line 202 "libyara/lexer.l" 1569| 214|{ return _MATCHES_; } ------------------ | | 163| 214|#define _MATCHES_ 295 ------------------ 1570| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1571| 278|case 39: ------------------ | Branch (1571:1): [True: 278, False: 767k] ------------------ 1572| 278|YY_RULE_SETUP 1573| 278|#line 203 "libyara/lexer.l" 1574| 278|{ return _CONTAINS_; } ------------------ | | 164| 278|#define _CONTAINS_ 296 ------------------ 1575| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1576| 245|case 40: ------------------ | Branch (1576:1): [True: 245, False: 767k] ------------------ 1577| 245|YY_RULE_SETUP 1578| 245|#line 204 "libyara/lexer.l" 1579| 245|{ return _STARTSWITH_; } ------------------ | | 165| 245|#define _STARTSWITH_ 297 ------------------ 1580| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1581| 218|case 41: ------------------ | Branch (1581:1): [True: 218, False: 767k] ------------------ 1582| 218|YY_RULE_SETUP 1583| 218|#line 205 "libyara/lexer.l" 1584| 218|{ return _ENDSWITH_; } ------------------ | | 166| 218|#define _ENDSWITH_ 298 ------------------ 1585| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1586| 301|case 42: ------------------ | Branch (1586:1): [True: 301, False: 767k] ------------------ 1587| 301|YY_RULE_SETUP 1588| 301|#line 206 "libyara/lexer.l" 1589| 301|{ return _ICONTAINS_; } ------------------ | | 167| 301|#define _ICONTAINS_ 299 ------------------ 1590| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1591| 389|case 43: ------------------ | Branch (1591:1): [True: 389, False: 767k] ------------------ 1592| 389|YY_RULE_SETUP 1593| 389|#line 207 "libyara/lexer.l" 1594| 389|{ return _ISTARTSWITH_; } ------------------ | | 168| 389|#define _ISTARTSWITH_ 300 ------------------ 1595| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1596| 221|case 44: ------------------ | Branch (1596:1): [True: 221, False: 767k] ------------------ 1597| 221|YY_RULE_SETUP 1598| 221|#line 208 "libyara/lexer.l" 1599| 221|{ return _IENDSWITH_; } ------------------ | | 169| 221|#define _IENDSWITH_ 301 ------------------ 1600| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1601| 0|case 45: ------------------ | Branch (1601:1): [True: 0, False: 767k] ------------------ 1602| 0|YY_RULE_SETUP 1603| 0|#line 209 "libyara/lexer.l" 1604| 0|{ return _IEQUALS_; } ------------------ | | 170| 0|#define _IEQUALS_ 302 ------------------ 1605| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1606| 1.93k|case 46: ------------------ | Branch (1606:1): [True: 1.93k, False: 765k] ------------------ 1607| 1.93k|YY_RULE_SETUP 1608| 1.93k|#line 210 "libyara/lexer.l" 1609| 1.93k|{ return _IMPORT_; } ------------------ | | 171| 1.93k|#define _IMPORT_ 303 ------------------ 1610| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1611| 36|case 47: ------------------ | Branch (1611:1): [True: 36, False: 767k] ------------------ 1612| 36|YY_RULE_SETUP 1613| 36|#line 211 "libyara/lexer.l" 1614| 36|{ return _DEFINED_; } ------------------ | | 177| 36|#define _DEFINED_ 309 ------------------ 1615| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1616| 144|case 48: ------------------ | Branch (1616:1): [True: 144, False: 767k] ------------------ 1617| 144|YY_RULE_SETUP 1618| 144|#line 214 "libyara/lexer.l" 1619| 144|{ BEGIN(comment); } ------------------ | | 357| 144|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(comment); } ------------------ | | 1043| 144|#define comment 4 ------------------ 1620| 144| YY_BREAK ------------------ | | 1269| 144|#define YY_BREAK /*LINTED*/break; ------------------ 1621| 136|case 49: ------------------ | Branch (1621:1): [True: 136, False: 767k] ------------------ 1622| 136|YY_RULE_SETUP 1623| 136|#line 215 "libyara/lexer.l" 1624| 136|{ BEGIN(INITIAL); } ------------------ | | 357| 136|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(INITIAL); } ------------------ | | 1039| 136|#define INITIAL 0 ------------------ 1625| 136| YY_BREAK ------------------ | | 1269| 136|#define YY_BREAK /*LINTED*/break; ------------------ 1626| 1.21k|case 50: ------------------ | Branch (1626:1): [True: 1.21k, False: 766k] ------------------ 1627| |/* rule 50 can match eol */ 1628| 1.21k|YY_RULE_SETUP 1629| 1.21k|#line 216 "libyara/lexer.l" 1630| 1.21k|{ /* skip comments */ } 1631| 1.21k| YY_BREAK ------------------ | | 1269| 1.21k|#define YY_BREAK /*LINTED*/break; ------------------ 1632| 177|case 51: ------------------ | Branch (1632:1): [True: 177, False: 767k] ------------------ 1633| 177|YY_RULE_SETUP 1634| 177|#line 219 "libyara/lexer.l" 1635| 177|{ /* skip single-line comments */ } 1636| 177| YY_BREAK ------------------ | | 1269| 177|#define YY_BREAK /*LINTED*/break; ------------------ 1637| 1.88k|case 52: ------------------ | Branch (1637:1): [True: 1.88k, False: 765k] ------------------ 1638| 1.88k|YY_RULE_SETUP 1639| 1.88k|#line 222 "libyara/lexer.l" 1640| 1.88k|{ 1641| 1.88k| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ 1642| 1.88k| yyextra->lex_buf_len = 0; ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ 1643| 1.88k| BEGIN(include); ------------------ | | 357| 1.88k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(include); ------------------ | | 1042| 1.88k|#define include 3 ------------------ 1644| 1.88k| } 1645| 1.88k| YY_BREAK ------------------ | | 1269| 1.88k|#define YY_BREAK /*LINTED*/break; ------------------ 1646| 1.55k|case 53: ------------------ | Branch (1646:1): [True: 1.55k, False: 765k] ------------------ 1647| |/* rule 53 can match eol */ 1648| 1.55k|YY_RULE_SETUP 1649| 1.55k|#line 229 "libyara/lexer.l" 1650| 1.55k|{ yytext_to_buffer; } ------------------ | | 991| 1.55k| { \ | | 992| 1.55k| char *yptr = yytext; \ | | ------------------ | | | | 348| 1.55k|#define yytext yyg->yytext_r | | ------------------ | | 993| 1.55k| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 1.55k| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 1, False: 1.55k] | | | | ------------------ | | | | 985| 1.55k| { \ | | | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 1|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 1| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 1|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 1| } | | ------------------ | | 994| 13.9k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 12.3k, False: 1.55k] | | ------------------ | | 995| 12.3k| { \ | | 996| 12.3k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 12.3k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 12.3k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 12.3k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 12.3k| } \ | | 999| 1.55k| } ------------------ 1651| 1.55k| YY_BREAK ------------------ | | 1269| 1.55k|#define YY_BREAK /*LINTED*/break; ------------------ 1652| 1.88k|case 54: ------------------ | Branch (1652:1): [True: 1.88k, False: 765k] ------------------ 1653| 1.88k|YY_RULE_SETUP 1654| 1.88k|#line 232 "libyara/lexer.l" 1655| 1.88k|{ 1656| | 1657| 1.88k| if (compiler->include_callback != NULL) ------------------ | Branch (1657:7): [True: 1.88k, False: 0] ------------------ 1658| 1.88k| { 1659| | #ifdef _MSC_VER 1660| | char* b = NULL; 1661| | #endif 1662| 1.88k| char* s = NULL; 1663| 1.88k| char* f; 1664| | 1665| 1.88k| char buffer[1024]; 1666| 1.88k| const char* included_rules; 1667| 1.88k| char* current_file_name; 1668| 1.88k| char* include_path; 1669| | 1670| 1.88k| *yyextra->lex_buf_ptr = '\0'; // null-terminate included file path ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ 1671| | 1672| 1.88k| current_file_name = yr_compiler_get_current_file_name(compiler); 1673| | 1674| 1.88k| if (current_file_name == NULL || ------------------ | Branch (1674:9): [True: 1.88k, False: 0] ------------------ 1675| 1.88k| compiler->include_callback != _yr_compiler_default_include_callback || ------------------ | Branch (1675:9): [True: 0, False: 0] ------------------ 1676| 1.88k| is_absolute_path(yyextra->lex_buf)) ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ | Branch (1676:9): [True: 0, False: 0] ------------------ 1677| 1.88k| { 1678| 1.88k| include_path = yyextra->lex_buf; ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ 1679| 1.88k| } 1680| 0| else 1681| 0| { 1682| 0| strlcpy(buffer, current_file_name, sizeof(buffer)); 1683| 0| s = strrchr(buffer, '/'); 1684| | 1685| | #ifdef _MSC_VER 1686| | b = strrchr(buffer, '\\'); // in Windows both path delimiters are accepted 1687| | #endif 1688| | 1689| | #ifdef _MSC_VER 1690| | if (s != NULL || b != NULL) 1691| | #else 1692| 0| if (s != NULL) ------------------ | Branch (1692:11): [True: 0, False: 0] ------------------ 1693| 0| #endif 1694| 0| { 1695| | #ifdef _MSC_VER 1696| | f = (b > s) ? (b + 1) : (s + 1); 1697| | #else 1698| 0| f = s + 1; 1699| 0| #endif 1700| | 1701| 0| strlcpy(f, yyextra->lex_buf, sizeof(buffer) - (f - buffer)); ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1702| 0| include_path = buffer; 1703| 0| } 1704| 0| else 1705| 0| { 1706| 0| include_path = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1707| 0| } 1708| 0| } 1709| | 1710| 1.88k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1711| 1.88k| compiler->arena, 1712| 1.88k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.88k|#define YR_NAMESPACES_TABLE 0 ------------------ 1713| 1.88k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1714| | 1715| 1.88k| included_rules = compiler->include_callback( 1716| 1.88k| include_path, 1717| 1.88k| current_file_name, 1718| 1.88k| ns->name, 1719| 1.88k| compiler->incl_clbk_user_data); 1720| | 1721| 1.88k| if (included_rules != NULL) ------------------ | Branch (1721:9): [True: 0, False: 1.88k] ------------------ 1722| 0| { 1723| 0| int error_code = _yr_compiler_push_file_name(compiler, include_path); 1724| | 1725| 0| if (error_code != ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (1725:11): [True: 0, False: 0] ------------------ 1726| 0| { 1727| 0| if (error_code == ERROR_INCLUDES_CIRCULAR_REFERENCE) ------------------ | | 67| 0|#define ERROR_INCLUDES_CIRCULAR_REFERENCE 22 ------------------ | Branch (1727:13): [True: 0, False: 0] ------------------ 1728| 0| { 1729| 0| yyerror(yyscanner, compiler, "includes circular reference"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1730| 0| } 1731| 0| else if (error_code == ERROR_INCLUDE_DEPTH_EXCEEDED) ------------------ | | 68| 0|#define ERROR_INCLUDE_DEPTH_EXCEEDED 23 ------------------ | Branch (1731:18): [True: 0, False: 0] ------------------ 1732| 0| { 1733| 0| yyerror(yyscanner, compiler, "includes depth exceeded"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1734| 0| } 1735| | 1736| 0| if (compiler->include_free != NULL) ------------------ | Branch (1736:13): [True: 0, False: 0] ------------------ 1737| 0| { 1738| 0| compiler->include_free(included_rules, compiler->incl_clbk_user_data); 1739| 0| } 1740| | 1741| 0| yyterminate(); ------------------ | | 1232| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1742| 0| } 1743| | 1744| | // Workaround for flex issue: https://github.com/westes/flex/issues/58 1745| 0| yypush_buffer_state(YY_CURRENT_BUFFER, yyscanner); ------------------ | | 74| 0|#define yypush_buffer_state yara_yypush_buffer_state ------------------ yypush_buffer_state(YY_CURRENT_BUFFER, yyscanner); ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 1746| 0| yy_scan_string(included_rules, yyscanner); ------------------ | | 38| 0|#define yy_scan_string yara_yy_scan_string ------------------ 1747| 0| yyset_lineno(1, yyscanner); ------------------ | | 188| 0|#define yyset_lineno yara_yyset_lineno ------------------ 1748| | 1749| 0| if (compiler->include_free != NULL) ------------------ | Branch (1749:11): [True: 0, False: 0] ------------------ 1750| 0| { 1751| 0| compiler->include_free(included_rules, compiler->incl_clbk_user_data); 1752| 0| } 1753| 0| } 1754| 1.88k| else 1755| 1.88k| { 1756| 1.88k| char* err_msg_fmt; 1757| 1.88k| char err_msg[512]; 1758| | 1759| 1.88k| if (compiler->include_callback == _yr_compiler_default_include_callback) ------------------ | Branch (1759:11): [True: 1.88k, False: 0] ------------------ 1760| 1.88k| { 1761| 1.88k| err_msg_fmt = "can't open include file: %s"; 1762| 1.88k| } 1763| 0| else 1764| 0| { 1765| 0| err_msg_fmt = "callback failed to provide include resource: %s"; 1766| 0| } 1767| | 1768| 1.88k| snprintf( 1769| 1.88k| err_msg, 1770| 1.88k| sizeof(err_msg), 1771| 1.88k| err_msg_fmt, 1772| 1.88k| yyextra->lex_buf); ------------------ | | 346| 1.88k|#define yyextra yyg->yyextra_r ------------------ 1773| | 1774| 1.88k| yyerror(yyscanner, compiler, err_msg); ------------------ | | 48| 1.88k|#define yyerror yara_yyerror ------------------ 1775| 1.88k| } 1776| | 1777| 1.88k| } 1778| 0| else // not allowing includes 1779| 0| { 1780| 0| yyerror(yyscanner, compiler, "includes are disabled"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1781| 0| } 1782| | 1783| 1.88k| BEGIN(INITIAL); ------------------ | | 357| 1.88k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 1.88k|#define INITIAL 0 ------------------ 1784| 1.88k|} 1785| 1.88k| YY_BREAK ------------------ | | 1269| 1.88k|#define YY_BREAK /*LINTED*/break; ------------------ 1786| 1.11k|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 1.11k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.11k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1786:1): [True: 1.11k, False: 766k] ------------------ 1787| 1.24k|case YY_STATE_EOF(str): ------------------ | | 365| 1.24k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.24k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1787:1): [True: 128, False: 767k] ------------------ 1788| 1.36k|case YY_STATE_EOF(regexp): ------------------ | | 365| 1.36k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.36k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1788:1): [True: 124, False: 767k] ------------------ 1789| 1.36k|case YY_STATE_EOF(include): ------------------ | | 365| 1.36k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.36k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1789:1): [True: 3, False: 767k] ------------------ 1790| 1.37k|case YY_STATE_EOF(comment): ------------------ | | 365| 1.37k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.37k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1790:1): [True: 8, False: 767k] ------------------ 1791| 1.37k|#line 364 "libyara/lexer.l" 1792| 1.37k|{ 1793| | 1794| 1.37k| yypop_buffer_state(yyscanner); ------------------ | | 80| 1.37k|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 1795| | 1796| 1.37k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1.37k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.37k, False: 0] | | ------------------ | | 510| 1.37k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.37k| : NULL) ------------------ | Branch (1796:7): [True: 1.37k, False: 0] ------------------ 1797| 1.37k| yyterminate(); ------------------ | | 1232| 1.37k|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1.37k|#define YY_NULL 0 | | ------------------ ------------------ 1798| | 1799| 0| return _END_OF_INCLUDED_FILE_; ------------------ | | 126| 0|#define _END_OF_INCLUDED_FILE_ 258 ------------------ 1800| 1.37k|} 1801| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1802| 580|case 55: ------------------ | Branch (1802:1): [True: 580, False: 766k] ------------------ 1803| 580|YY_RULE_SETUP 1804| 580|#line 375 "libyara/lexer.l" 1805| 580|{ 1806| | 1807| 580| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 580| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 580|#define yytext yyg->yytext_r ------------------ 1808| | 1809| 580| if (yylval->c_string == NULL) ------------------ | | 1097| 580| # define yylval yyg->yylval_r ------------------ | Branch (1809:7): [True: 0, False: 580] ------------------ 1810| 580| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1811| | 1812| 580| return _STRING_IDENTIFIER_WITH_WILDCARD_; ------------------ | | 139| 580|#define _STRING_IDENTIFIER_WITH_WILDCARD_ 271 ------------------ 1813| 580|} 1814| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1815| 36.7k|case 56: ------------------ | Branch (1815:1): [True: 36.7k, False: 730k] ------------------ 1816| 36.7k|YY_RULE_SETUP 1817| 36.7k|#line 386 "libyara/lexer.l" 1818| 36.7k|{ 1819| | 1820| 36.7k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 36.7k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 36.7k|#define yytext yyg->yytext_r ------------------ 1821| | 1822| 36.7k| if (yylval->c_string == NULL) ------------------ | | 1097| 36.7k| # define yylval yyg->yylval_r ------------------ | Branch (1822:7): [True: 0, False: 36.7k] ------------------ 1823| 36.7k| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1824| | 1825| 36.7k| return _STRING_IDENTIFIER_; ------------------ | | 135| 36.7k|#define _STRING_IDENTIFIER_ 267 ------------------ 1826| 36.7k|} 1827| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1828| 4.49k|case 57: ------------------ | Branch (1828:1): [True: 4.49k, False: 762k] ------------------ 1829| 4.49k|YY_RULE_SETUP 1830| 4.49k|#line 397 "libyara/lexer.l" 1831| 4.49k|{ 1832| | 1833| 4.49k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 4.49k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 4.49k|#define yytext yyg->yytext_r ------------------ 1834| | 1835| 4.49k| if (yylval->c_string == NULL) ------------------ | | 1097| 4.49k| # define yylval yyg->yylval_r ------------------ | Branch (1835:7): [True: 0, False: 4.49k] ------------------ 1836| 0| { 1837| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1838| 0| } 1839| 4.49k| else 1840| 4.49k| { 1841| 4.49k| yylval->c_string[0] = '$'; /* replace # by $*/ ------------------ | | 1097| 4.49k| # define yylval yyg->yylval_r ------------------ 1842| 4.49k| } 1843| | 1844| 4.49k| return _STRING_COUNT_; ------------------ | | 136| 4.49k|#define _STRING_COUNT_ 268 ------------------ 1845| 4.49k|} 1846| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1847| 4.98k|case 58: ------------------ | Branch (1847:1): [True: 4.98k, False: 762k] ------------------ 1848| 4.98k|YY_RULE_SETUP 1849| 4.98k|#line 414 "libyara/lexer.l" 1850| 4.98k|{ 1851| | 1852| 4.98k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 4.98k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 4.98k|#define yytext yyg->yytext_r ------------------ 1853| | 1854| 4.98k| if (yylval->c_string == NULL) ------------------ | | 1097| 4.98k| # define yylval yyg->yylval_r ------------------ | Branch (1854:7): [True: 0, False: 4.98k] ------------------ 1855| 0| { 1856| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1857| 0| } 1858| 4.98k| else 1859| 4.98k| { 1860| 4.98k| yylval->c_string[0] = '$'; /* replace @ by $*/ ------------------ | | 1097| 4.98k| # define yylval yyg->yylval_r ------------------ 1861| 4.98k| } 1862| | 1863| 4.98k| return _STRING_OFFSET_; ------------------ | | 137| 4.98k|#define _STRING_OFFSET_ 269 ------------------ 1864| 4.98k|} 1865| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1866| 12.2k|case 59: ------------------ | Branch (1866:1): [True: 12.2k, False: 755k] ------------------ 1867| 12.2k|YY_RULE_SETUP 1868| 12.2k|#line 431 "libyara/lexer.l" 1869| 12.2k|{ 1870| | 1871| 12.2k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 12.2k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 12.2k|#define yytext yyg->yytext_r ------------------ 1872| | 1873| 12.2k| if (yylval->c_string == NULL) ------------------ | | 1097| 12.2k| # define yylval yyg->yylval_r ------------------ | Branch (1873:7): [True: 0, False: 12.2k] ------------------ 1874| 0| { 1875| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1876| 0| } 1877| 12.2k| else 1878| 12.2k| { 1879| 12.2k| yylval->c_string[0] = '$'; /* replace ! by $*/ ------------------ | | 1097| 12.2k| # define yylval yyg->yylval_r ------------------ 1880| 12.2k| } 1881| | 1882| 12.2k| return _STRING_LENGTH_; ------------------ | | 138| 12.2k|#define _STRING_LENGTH_ 270 ------------------ 1883| 12.2k|} 1884| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1885| 1.17k|case 60: ------------------ | Branch (1885:1): [True: 1.17k, False: 766k] ------------------ 1886| 1.17k|YY_RULE_SETUP 1887| 1.17k|#line 448 "libyara/lexer.l" 1888| 1.17k|{ 1889| | 1890| 1.17k| char* text = yytext; ------------------ | | 348| 1.17k|#define yytext yyg->yytext_r ------------------ 1891| | 1892| 1.17k| if (*text == 'u') ------------------ | Branch (1892:7): [True: 315, False: 863] ------------------ 1893| 315| { 1894| 315| yylval->integer = 3; ------------------ | | 1097| 315| # define yylval yyg->yylval_r ------------------ 1895| 315| text++; 1896| 315| } 1897| 863| else 1898| 863| { 1899| 863| yylval->integer = 0; ------------------ | | 1097| 863| # define yylval yyg->yylval_r ------------------ 1900| 863| } 1901| | 1902| 1.17k| if (strstr(text, "int8") == text) ------------------ | Branch (1902:7): [True: 681, False: 497] ------------------ 1903| 681| { 1904| 681| yylval->integer += 0; ------------------ | | 1097| 681| # define yylval yyg->yylval_r ------------------ 1905| 681| text += 4; 1906| 681| } 1907| 497| else if (strstr(text, "int16") == text) ------------------ | Branch (1907:12): [True: 317, False: 180] ------------------ 1908| 317| { 1909| 317| yylval->integer += 1; ------------------ | | 1097| 317| # define yylval yyg->yylval_r ------------------ 1910| 317| text += 5; 1911| 317| } 1912| 180| else if (strstr(text, "int32") == text) ------------------ | Branch (1912:12): [True: 180, False: 0] ------------------ 1913| 180| { 1914| 180| yylval->integer += 2; ------------------ | | 1097| 180| # define yylval yyg->yylval_r ------------------ 1915| 180| text += 5; 1916| 180| } 1917| | 1918| 1.17k| if (strcmp(text, "be") == 0) ------------------ | Branch (1918:7): [True: 176, False: 1.00k] ------------------ 1919| 176| { 1920| 176| yylval->integer += 6; ------------------ | | 1097| 176| # define yylval yyg->yylval_r ------------------ 1921| 176| } 1922| | 1923| 1.17k| return _INTEGER_FUNCTION_; ------------------ | | 142| 1.17k|#define _INTEGER_FUNCTION_ 274 ------------------ 1924| 12.2k|} 1925| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1926| 64.7k|case 61: ------------------ | Branch (1926:1): [True: 64.7k, False: 702k] ------------------ 1927| 64.7k|YY_RULE_SETUP 1928| 64.7k|#line 487 "libyara/lexer.l" 1929| 64.7k|{ 1930| | 1931| 64.7k| if (strlen(yytext) > 128) ------------------ | | 348| 64.7k|#define yytext yyg->yytext_r ------------------ | Branch (1931:7): [True: 6, False: 64.7k] ------------------ 1932| 64.7k| syntax_error("identifier too long"); ------------------ | | 978| 6| { \ | | 979| 6| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 6| strlcpy( \ | | | | 307| 6| compiler->last_error_extra_info, \ | | | | 308| 6| info, \ | | | | 309| 6| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 6| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 6| { \ | | | | 972| 6| compiler->last_error = error_code; \ | | | | 973| 6| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 6|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 6| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 6|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 6|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 6| } | | ------------------ | | 981| 0| } ------------------ 1933| | 1934| 64.7k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 64.7k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 64.7k|#define yytext yyg->yytext_r ------------------ 1935| | 1936| 64.7k| if (yylval->c_string == NULL) ------------------ | | 1097| 64.7k| # define yylval yyg->yylval_r ------------------ | Branch (1936:7): [True: 0, False: 64.7k] ------------------ 1937| 64.7k| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1938| | 1939| 64.7k| return _IDENTIFIER_; ------------------ | | 134| 64.7k|#define _IDENTIFIER_ 266 ------------------ 1940| 64.7k|} 1941| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1942| 52.4k|case 62: ------------------ | Branch (1942:1): [True: 52.4k, False: 714k] ------------------ 1943| 52.4k|YY_RULE_SETUP 1944| 52.4k|#line 501 "libyara/lexer.l" 1945| 52.4k|{ 1946| | 1947| 52.4k| char *endptr; 1948| | 1949| 52.4k| errno = 0; 1950| 52.4k| yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 1097| 52.4k| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 348| 52.4k|#define yytext yyg->yytext_r ------------------ 1951| | 1952| 52.4k| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 52.4k| # define yylval yyg->yylval_r ------------------ | Branch (1952:7): [True: 234, False: 52.2k] | Branch (1952:39): [True: 16, False: 218] ------------------ 1953| 16| { 1954| 16| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 306| 16| strlcpy( \ | | 307| 16| compiler->last_error_extra_info, \ | | 308| 16| info, \ | | 309| 16| sizeof(compiler->last_error_extra_info)); ------------------ 1955| 16| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 16| { \ | | 972| 16| compiler->last_error = error_code; \ | | 973| 16| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 16|#define yyerror yara_yyerror | | ------------------ | | 974| 16| yyterminate(); \ | | ------------------ | | | | 1232| 16|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 16|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 16| } ------------------ 1956| 0| } 1957| 52.4k| else if (strstr(yytext, "KB") != NULL) ------------------ | | 348| 52.4k|#define yytext yyg->yytext_r ------------------ | Branch (1957:12): [True: 155, False: 52.3k] ------------------ 1958| 155| { 1959| 155| if (yylval->integer > LLONG_MAX / 1024) ------------------ | | 1097| 155| # define yylval yyg->yylval_r ------------------ | Branch (1959:9): [True: 1, False: 154] ------------------ 1960| 1| { 1961| 1| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 306| 1| strlcpy( \ | | 307| 1| compiler->last_error_extra_info, \ | | 308| 1| info, \ | | 309| 1| sizeof(compiler->last_error_extra_info)); ------------------ 1962| 1| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 1| { \ | | 972| 1| compiler->last_error = error_code; \ | | 973| 1| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 974| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 1| } ------------------ 1963| 0| } 1964| 154| else 1965| 154| { 1966| 154| yylval->integer *= 1024; ------------------ | | 1097| 154| # define yylval yyg->yylval_r ------------------ 1967| 154| } 1968| 155| } 1969| 52.3k| else if (strstr(yytext, "MB") != NULL) ------------------ | | 348| 52.3k|#define yytext yyg->yytext_r ------------------ | Branch (1969:12): [True: 797, False: 51.5k] ------------------ 1970| 797| { 1971| 797| if (yylval->integer > LLONG_MAX / 1048576) ------------------ | | 1097| 797| # define yylval yyg->yylval_r ------------------ | Branch (1971:9): [True: 0, False: 797] ------------------ 1972| 0| { 1973| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1974| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1975| 0| } 1976| 797| else 1977| 797| { 1978| 797| yylval->integer *= 1048576; ------------------ | | 1097| 797| # define yylval yyg->yylval_r ------------------ 1979| 797| } 1980| 797| } 1981| | 1982| 52.4k| return _NUMBER_; ------------------ | | 140| 52.4k|#define _NUMBER_ 272 ------------------ 1983| 52.4k|} 1984| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1985| 4.18k|case 63: ------------------ | Branch (1985:1): [True: 4.18k, False: 763k] ------------------ 1986| 4.18k|YY_RULE_SETUP 1987| 4.18k|#line 541 "libyara/lexer.l" 1988| 4.18k|{ 1989| 4.18k| yylval->double_ = atof(yytext); ------------------ | | 1097| 4.18k| # define yylval yyg->yylval_r ------------------ yylval->double_ = atof(yytext); ------------------ | | 348| 4.18k|#define yytext yyg->yytext_r ------------------ 1990| 4.18k| return _DOUBLE_; ------------------ | | 141| 4.18k|#define _DOUBLE_ 273 ------------------ 1991| 52.4k|} 1992| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1993| 622|case 64: ------------------ | Branch (1993:1): [True: 622, False: 766k] ------------------ 1994| 622|YY_RULE_SETUP 1995| 622|#line 546 "libyara/lexer.l" 1996| 622|{ 1997| | 1998| 622| char *endptr; 1999| | 2000| 622| errno = 0; 2001| 622| yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 1097| 622| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 348| 622|#define yytext yyg->yytext_r ------------------ 2002| | 2003| 622| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 622| # define yylval yyg->yylval_r ------------------ | Branch (2003:7): [True: 202, False: 420] | Branch (2003:39): [True: 0, False: 202] ------------------ 2004| 0| { 2005| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2006| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 2007| 0| } 2008| | 2009| 622| return _NUMBER_; ------------------ | | 140| 622|#define _NUMBER_ 272 ------------------ 2010| 622|} 2011| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2012| 446|case 65: ------------------ | Branch (2012:1): [True: 446, False: 766k] ------------------ 2013| 446|YY_RULE_SETUP 2014| 446|#line 562 "libyara/lexer.l" 2015| 446|{ 2016| | 2017| 446| char *endptr; 2018| | 2019| 446| errno = 0; 2020| 446| yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 1097| 446| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 348| 446|#define yytext yyg->yytext_r ------------------ 2021| | 2022| 446| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 446| # define yylval yyg->yylval_r ------------------ | Branch (2022:7): [True: 214, False: 232] | Branch (2022:39): [True: 0, False: 214] ------------------ 2023| 0| { 2024| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2025| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 2026| 0| } 2027| | 2028| 446| return _NUMBER_; ------------------ | | 140| 446|#define _NUMBER_ 272 ------------------ 2029| 446|} 2030| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2031| 15.5k|case 66: ------------------ | Branch (2031:1): [True: 15.5k, False: 751k] ------------------ 2032| 15.5k|YY_RULE_SETUP 2033| 15.5k|#line 579 "libyara/lexer.l" 2034| 15.5k|{ /* saw closing quote - all done */ 2035| | 2036| 15.5k| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 15.5k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 15.5k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 15.5k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 15.5k] | | ------------------ | | 1005| 15.5k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 15.5k| else \ | | 1010| 15.5k| { \ | | 1011| 15.5k| str->length = (uint32_t) (str_len); \ | | 1012| 15.5k| str->flags = 0; \ | | 1013| 15.5k| } \ ------------------ 2037| | 2038| 15.5k| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 15.5k|#define yyextra yyg->yyextra_r ------------------ 2039| 15.5k| memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 15.5k|#define yyextra yyg->yyextra_r ------------------ memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 15.5k|#define yyextra yyg->yyextra_r ------------------ 2040| | 2041| 15.5k| yylval->sized_string = s; ------------------ | | 1097| 15.5k| # define yylval yyg->yylval_r ------------------ 2042| | 2043| 15.5k| BEGIN(INITIAL); ------------------ | | 357| 15.5k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 15.5k|#define INITIAL 0 ------------------ 2044| | 2045| 15.5k| return _TEXT_STRING_; ------------------ | | 143| 15.5k|#define _TEXT_STRING_ 275 ------------------ 2046| 15.5k|} 2047| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2048| 196|case 67: ------------------ | Branch (2048:1): [True: 196, False: 767k] ------------------ 2049| 196|YY_RULE_SETUP 2050| 196|#line 594 "libyara/lexer.l" 2051| 196|{ 2052| | 2053| 196| lex_check_space_ok("\t", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 196| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 195] | | ------------------ | | 985| 196| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2054| 195| *yyextra->lex_buf_ptr++ = '\t'; ------------------ | | 346| 195|#define yyextra yyg->yyextra_r ------------------ 2055| 195| yyextra->lex_buf_len++; ------------------ | | 346| 195|#define yyextra yyg->yyextra_r ------------------ 2056| 195|} 2057| 195| YY_BREAK ------------------ | | 1269| 195|#define YY_BREAK /*LINTED*/break; ------------------ 2058| 162|case 68: ------------------ | Branch (2058:1): [True: 162, False: 767k] ------------------ 2059| 162|YY_RULE_SETUP 2060| 162|#line 602 "libyara/lexer.l" 2061| 162|{ 2062| | 2063| 162| lex_check_space_ok("\r", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 162| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 161] | | ------------------ | | 985| 162| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2064| 161| *yyextra->lex_buf_ptr++ = '\r'; ------------------ | | 346| 161|#define yyextra yyg->yyextra_r ------------------ 2065| 161| yyextra->lex_buf_len++; ------------------ | | 346| 161|#define yyextra yyg->yyextra_r ------------------ 2066| 161|} 2067| 161| YY_BREAK ------------------ | | 1269| 161|#define YY_BREAK /*LINTED*/break; ------------------ 2068| 298|case 69: ------------------ | Branch (2068:1): [True: 298, False: 767k] ------------------ 2069| 298|YY_RULE_SETUP 2070| 298|#line 610 "libyara/lexer.l" 2071| 298|{ 2072| | 2073| 298| lex_check_space_ok("\n", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 298| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 297] | | ------------------ | | 985| 298| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2074| 297| *yyextra->lex_buf_ptr++ = '\n'; ------------------ | | 346| 297|#define yyextra yyg->yyextra_r ------------------ 2075| 297| yyextra->lex_buf_len++; ------------------ | | 346| 297|#define yyextra yyg->yyextra_r ------------------ 2076| 297|} 2077| 297| YY_BREAK ------------------ | | 1269| 297|#define YY_BREAK /*LINTED*/break; ------------------ 2078| 163|case 70: ------------------ | Branch (2078:1): [True: 163, False: 767k] ------------------ 2079| 163|YY_RULE_SETUP 2080| 163|#line 618 "libyara/lexer.l" 2081| 163|{ 2082| | 2083| 163| lex_check_space_ok("\"", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 163| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 162] | | ------------------ | | 985| 163| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2084| 162| *yyextra->lex_buf_ptr++ = '\"'; ------------------ | | 346| 162|#define yyextra yyg->yyextra_r ------------------ 2085| 162| yyextra->lex_buf_len++; ------------------ | | 346| 162|#define yyextra yyg->yyextra_r ------------------ 2086| 162|} 2087| 162| YY_BREAK ------------------ | | 1269| 162|#define YY_BREAK /*LINTED*/break; ------------------ 2088| 353|case 71: ------------------ | Branch (2088:1): [True: 353, False: 767k] ------------------ 2089| 353|YY_RULE_SETUP 2090| 353|#line 626 "libyara/lexer.l" 2091| 353|{ 2092| | 2093| 353| lex_check_space_ok("\\", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 353| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 352] | | ------------------ | | 985| 353| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2094| 352| *yyextra->lex_buf_ptr++ = '\\'; ------------------ | | 346| 352|#define yyextra yyg->yyextra_r ------------------ 2095| 352| yyextra->lex_buf_len++; ------------------ | | 346| 352|#define yyextra yyg->yyextra_r ------------------ 2096| 352|} 2097| 352| YY_BREAK ------------------ | | 1269| 352|#define YY_BREAK /*LINTED*/break; ------------------ 2098| 438|case 72: ------------------ | Branch (2098:1): [True: 438, False: 766k] ------------------ 2099| 438|YY_RULE_SETUP 2100| 438|#line 634 "libyara/lexer.l" 2101| 438|{ 2102| | 2103| 438| int result; 2104| | 2105| 438| sscanf(yytext + 2, "%x", &result); ------------------ | | 348| 438|#define yytext yyg->yytext_r ------------------ 2106| 438| lex_check_space_ok("X", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 438| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 437] | | ------------------ | | 985| 438| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2107| 437| *yyextra->lex_buf_ptr++ = result; ------------------ | | 346| 437|#define yyextra yyg->yyextra_r ------------------ 2108| 437| yyextra->lex_buf_len++; ------------------ | | 346| 437|#define yyextra yyg->yyextra_r ------------------ 2109| 437|} 2110| 437| YY_BREAK ------------------ | | 1269| 437|#define YY_BREAK /*LINTED*/break; ------------------ 2111| 11.3k|case 73: ------------------ | Branch (2111:1): [True: 11.3k, False: 756k] ------------------ 2112| 11.3k|YY_RULE_SETUP 2113| 11.3k|#line 645 "libyara/lexer.l" 2114| 11.3k|{ yytext_to_buffer; } ------------------ | | 991| 11.3k| { \ | | 992| 11.3k| char *yptr = yytext; \ | | ------------------ | | | | 348| 11.3k|#define yytext yyg->yytext_r | | ------------------ | | 993| 11.3k| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 11.3k| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 7, False: 11.3k] | | | | ------------------ | | | | 985| 11.3k| { \ | | | | 986| 7| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 7|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 7| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 7|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 7|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 7| } | | ------------------ | | 994| 977k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 966k, False: 11.3k] | | ------------------ | | 995| 966k| { \ | | 996| 966k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 966k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 966k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 966k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 966k| } \ | | 999| 11.3k| } ------------------ 2115| 11.3k| YY_BREAK ------------------ | | 1269| 11.3k|#define YY_BREAK /*LINTED*/break; ------------------ 2116| 11|case 74: ------------------ | Branch (2116:1): [True: 11, False: 767k] ------------------ 2117| |/* rule 74 can match eol */ 2118| 11|YY_RULE_SETUP 2119| 11|#line 648 "libyara/lexer.l" 2120| 11|{ 2121| 11| syntax_error("unterminated string"); ------------------ | | 978| 11| { \ | | 979| 11| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 11| strlcpy( \ | | | | 307| 11| compiler->last_error_extra_info, \ | | | | 308| 11| info, \ | | | | 309| 11| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 11| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 11| { \ | | | | 972| 11| compiler->last_error = error_code; \ | | | | 973| 11| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 11|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 11| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 11|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 11|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 11| } | | ------------------ | | 981| 0| } ------------------ 2122| 0|} 2123| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2124| 15|case 75: ------------------ | Branch (2124:1): [True: 15, False: 767k] ------------------ 2125| |/* rule 75 can match eol */ 2126| 15|YY_RULE_SETUP 2127| 15|#line 653 "libyara/lexer.l" 2128| 15|{ 2129| 15| syntax_error("illegal escape sequence"); ------------------ | | 978| 15| { \ | | 979| 15| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 15| strlcpy( \ | | | | 307| 15| compiler->last_error_extra_info, \ | | | | 308| 15| info, \ | | | | 309| 15| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 15| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 15| { \ | | | | 972| 15| compiler->last_error = error_code; \ | | | | 973| 15| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 15|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 15| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 15|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 15|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 15| } | | ------------------ | | 981| 0| } ------------------ 2130| 0|} 2131| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2132| 17.6k|case 76: ------------------ | Branch (2132:1): [True: 17.6k, False: 749k] ------------------ 2133| 17.6k|YY_RULE_SETUP 2134| 17.6k|#line 658 "libyara/lexer.l" 2135| 17.6k|{ 2136| | 2137| 17.6k| if (yyextra->lex_buf_len > 0) ------------------ | | 346| 17.6k|#define yyextra yyg->yyextra_r ------------------ | Branch (2137:7): [True: 17.6k, False: 0] ------------------ 2138| 17.6k| { 2139| 17.6k| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 17.6k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 17.6k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 17.6k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 17.6k] | | ------------------ | | 1005| 17.6k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 17.6k| else \ | | 1010| 17.6k| { \ | | 1011| 17.6k| str->length = (uint32_t) (str_len); \ | | 1012| 17.6k| str->flags = 0; \ | | 1013| 17.6k| } \ ------------------ 2140| | 2141| 17.6k| if (yytext[1] == 'i') ------------------ | | 348| 17.6k|#define yytext yyg->yytext_r ------------------ | Branch (2141:9): [True: 2.56k, False: 15.1k] ------------------ 2142| 2.56k| s->flags |= SIZED_STRING_FLAGS_NO_CASE; ------------------ | | 39| 2.56k|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ 2143| | 2144| 17.6k| if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 17.6k|#define yytext yyg->yytext_r ------------------ if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 17.4k|#define yytext yyg->yytext_r ------------------ | Branch (2144:9): [True: 270, False: 17.4k] | Branch (2144:29): [True: 464, False: 16.9k] ------------------ 2145| 734| s->flags |= SIZED_STRING_FLAGS_DOT_ALL; ------------------ | | 43| 734|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ 2146| | 2147| 17.6k| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 17.6k|#define yyextra yyg->yyextra_r ------------------ 2148| 17.6k| strlcpy(s->c_string, yyextra->lex_buf, s->length + 1); ------------------ | | 346| 17.6k|#define yyextra yyg->yyextra_r ------------------ 2149| | 2150| 17.6k| yylval->sized_string = s; ------------------ | | 1097| 17.6k| # define yylval yyg->yylval_r ------------------ 2151| 17.6k| } 2152| 0| else 2153| 0| { 2154| 0| syntax_error("empty regular expression"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 0| strlcpy( \ | | | | 307| 0| compiler->last_error_extra_info, \ | | | | 308| 0| info, \ | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2155| 0| } 2156| | 2157| 17.6k| BEGIN(INITIAL); ------------------ | | 357| 17.6k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 17.6k|#define INITIAL 0 ------------------ 2158| 17.6k| return _REGEXP_; ------------------ | | 145| 17.6k|#define _REGEXP_ 277 ------------------ 2159| 17.6k|} 2160| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2161| 176|case 77: ------------------ | Branch (2161:1): [True: 176, False: 767k] ------------------ 2162| 176|YY_RULE_SETUP 2163| 176|#line 685 "libyara/lexer.l" 2164| 176|{ 2165| | 2166| 176| lex_check_space_ok("/", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 176| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 175] | | ------------------ | | 985| 176| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2167| 175| *yyextra->lex_buf_ptr++ = '/'; ------------------ | | 346| 175|#define yyextra yyg->yyextra_r ------------------ 2168| 175| yyextra->lex_buf_len++ ; ------------------ | | 346| 175|#define yyextra yyg->yyextra_r ------------------ 2169| 175|} 2170| 175| YY_BREAK ------------------ | | 1269| 175|#define YY_BREAK /*LINTED*/break; ------------------ 2171| 36.0k|case 78: ------------------ | Branch (2171:1): [True: 36.0k, False: 731k] ------------------ 2172| 36.0k|YY_RULE_SETUP 2173| 36.0k|#line 693 "libyara/lexer.l" 2174| 36.0k|{ 2175| | 2176| 36.0k| lex_check_space_ok("\\.", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 36.0k| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 36.0k] | | ------------------ | | 985| 36.0k| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2177| | 2178| 36.0k| if (yytext[1] == 0) ------------------ | | 348| 36.0k|#define yytext yyg->yytext_r ------------------ | Branch (2178:7): [True: 0, False: 36.0k] ------------------ 2179| 36.0k| syntax_error("malformed regular expression"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 0| strlcpy( \ | | | | 307| 0| compiler->last_error_extra_info, \ | | | | 308| 0| info, \ | | | | 309| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2180| | 2181| 36.0k| *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 346| 36.0k|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 348| 36.0k|#define yytext yyg->yytext_r ------------------ 2182| 36.0k| *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 346| 36.0k|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 348| 36.0k|#define yytext yyg->yytext_r ------------------ 2183| 36.0k| yyextra->lex_buf_len += 2; ------------------ | | 346| 36.0k|#define yyextra yyg->yyextra_r ------------------ 2184| 36.0k|} 2185| 36.0k| YY_BREAK ------------------ | | 1269| 36.0k|#define YY_BREAK /*LINTED*/break; ------------------ 2186| 28.2k|case 79: ------------------ | Branch (2186:1): [True: 28.2k, False: 739k] ------------------ 2187| 28.2k|YY_RULE_SETUP 2188| 28.2k|#line 706 "libyara/lexer.l" 2189| 28.2k|{ yytext_to_buffer; } ------------------ | | 991| 28.2k| { \ | | 992| 28.2k| char *yptr = yytext; \ | | ------------------ | | | | 348| 28.2k|#define yytext yyg->yytext_r | | ------------------ | | 993| 28.2k| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 28.2k| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 2, False: 28.2k] | | | | ------------------ | | | | 985| 28.2k| { \ | | | | 986| 2| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 2| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 2|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 2|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 2| } | | ------------------ | | 994| 652k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 624k, False: 28.2k] | | ------------------ | | 995| 624k| { \ | | 996| 624k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 624k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 624k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 624k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 624k| } \ | | 999| 28.2k| } ------------------ 2190| 28.2k| YY_BREAK ------------------ | | 1269| 28.2k|#define YY_BREAK /*LINTED*/break; ------------------ 2191| 5|case 80: ------------------ | Branch (2191:1): [True: 5, False: 767k] ------------------ 2192| |/* rule 80 can match eol */ 2193| 5|YY_RULE_SETUP 2194| 5|#line 709 "libyara/lexer.l" 2195| 5|{ 2196| 5| syntax_error("unterminated regular expression"); ------------------ | | 978| 5| { \ | | 979| 5| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 5| strlcpy( \ | | | | 307| 5| compiler->last_error_extra_info, \ | | | | 308| 5| info, \ | | | | 309| 5| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 5| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 5| { \ | | | | 972| 5| compiler->last_error = error_code; \ | | | | 973| 5| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 5|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 5| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 5|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 5|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 5| } | | ------------------ | | 981| 0| } ------------------ 2197| 0|} 2198| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2199| 15.6k|case 81: ------------------ | Branch (2199:1): [True: 15.6k, False: 751k] ------------------ 2200| 15.6k|YY_RULE_SETUP 2201| 15.6k|#line 714 "libyara/lexer.l" 2202| 15.6k|{ 2203| | 2204| 15.6k| yylval->sized_string = NULL; ------------------ | | 1097| 15.6k| # define yylval yyg->yylval_r ------------------ 2205| 15.6k| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 15.6k|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 15.6k|#define yyextra yyg->yyextra_r ------------------ 2206| 15.6k| yyextra->lex_buf_len = 0; ------------------ | | 346| 15.6k|#define yyextra yyg->yyextra_r ------------------ 2207| 15.6k| BEGIN(str); ------------------ | | 357| 15.6k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(str); ------------------ | | 1040| 15.6k|#define str 1 ------------------ 2208| 15.6k|} 2209| 15.6k| YY_BREAK ------------------ | | 1269| 15.6k|#define YY_BREAK /*LINTED*/break; ------------------ 2210| 17.8k|case 82: ------------------ | Branch (2210:1): [True: 17.8k, False: 749k] ------------------ 2211| 17.8k|YY_RULE_SETUP 2212| 17.8k|#line 723 "libyara/lexer.l" 2213| 17.8k|{ 2214| | 2215| 17.8k| yylval->sized_string = NULL; ------------------ | | 1097| 17.8k| # define yylval yyg->yylval_r ------------------ 2216| 17.8k| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 17.8k|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 17.8k|#define yyextra yyg->yyextra_r ------------------ 2217| 17.8k| yyextra->lex_buf_len = 0; ------------------ | | 346| 17.8k|#define yyextra yyg->yyextra_r ------------------ 2218| 17.8k| BEGIN(regexp); ------------------ | | 357| 17.8k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(regexp); ------------------ | | 1041| 17.8k|#define regexp 2 ------------------ 2219| 17.8k|} 2220| 17.8k| YY_BREAK ------------------ | | 1269| 17.8k|#define YY_BREAK /*LINTED*/break; ------------------ 2221| 1.72k|case 83: ------------------ | Branch (2221:1): [True: 1.72k, False: 765k] ------------------ 2222| |/* rule 83 can match eol */ 2223| 1.72k|YY_RULE_SETUP 2224| 1.72k|#line 732 "libyara/lexer.l" 2225| 1.72k|{ 2226| | // Match hex-digits with whitespace or comments. The latter are stripped 2227| | // out by hex_lexer.l 2228| | // TODO(vmalvarez): Integrate the hex string lexer and parser into this one, 2229| | // by having a single lexer/parser instead of two different ones we can avoid 2230| | // complex regular expressions like the one above, which is actually trying to 2231| | // do some parsing in the lexer. 2232| | 2233| 1.72k| alloc_sized_string(s, strlen(yytext)); ------------------ | | 1002| 1.72k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 1.72k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 1.72k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 1.72k] | | ------------------ | | 1005| 1.72k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 1.72k| else \ | | 1010| 1.72k| { \ | | 1011| 1.72k| str->length = (uint32_t) (str_len); \ | | 1012| 1.72k| str->flags = 0; \ | | 1013| 1.72k| } \ ------------------ 2234| | 2235| 1.72k| strlcpy(s->c_string, yytext, s->length + 1); ------------------ | | 348| 1.72k|#define yytext yyg->yytext_r ------------------ 2236| 1.72k| yylval->sized_string = s; ------------------ | | 1097| 1.72k| # define yylval yyg->yylval_r ------------------ 2237| | 2238| 1.72k| return _HEX_STRING_; ------------------ | | 144| 1.72k|#define _HEX_STRING_ 276 ------------------ 2239| 1.72k|} 2240| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2241| 74.9k|case 84: ------------------ | Branch (2241:1): [True: 74.9k, False: 692k] ------------------ 2242| |/* rule 84 can match eol */ 2243| 74.9k|YY_RULE_SETUP 2244| 74.9k|#line 749 "libyara/lexer.l" 2245| |/* skip whitespace */ 2246| 74.9k| YY_BREAK ------------------ | | 1269| 74.9k|#define YY_BREAK /*LINTED*/break; ------------------ 2247| 248k|case 85: ------------------ | Branch (2247:1): [True: 248k, False: 519k] ------------------ 2248| 248k|YY_RULE_SETUP 2249| 248k|#line 751 "libyara/lexer.l" 2250| 248k|{ 2251| | 2252| 248k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 248k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 247k|#define yytext yyg->yytext_r ------------------ | Branch (2252:7): [True: 247k, False: 273] | Branch (2252:26): [True: 247k, False: 3] ------------------ 2253| 247k| { 2254| 247k| return yytext[0]; ------------------ | | 348| 247k|#define yytext yyg->yytext_r ------------------ 2255| 247k| } 2256| 276| else 2257| 276| { 2258| 276| syntax_error("non-ascii character"); ------------------ | | 978| 276| { \ | | 979| 276| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 306| 276| strlcpy( \ | | | | 307| 276| compiler->last_error_extra_info, \ | | | | 308| 276| info, \ | | | | 309| 276| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 276| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 276| { \ | | | | 972| 276| compiler->last_error = error_code; \ | | | | 973| 276| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 276|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 276| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 276|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 276|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 276| } | | ------------------ | | 981| 0| } ------------------ 2259| 0| } 2260| 248k|} 2261| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2262| 12|case 86: ------------------ | Branch (2262:1): [True: 12, False: 767k] ------------------ 2263| 12|YY_RULE_SETUP 2264| 12|#line 763 "libyara/lexer.l" 2265| 12|ECHO; 2266| 12| YY_BREAK ------------------ | | 1269| 12|#define YY_BREAK /*LINTED*/break; ------------------ 2267| 0|#line 2267 "libyara/lexer.c" 2268| | 2269| 2.84k| case YY_END_OF_BUFFER: ------------------ | | 584| 2.84k|#define YY_END_OF_BUFFER 87 ------------------ | Branch (2269:2): [True: 2.84k, False: 764k] ------------------ 2270| 2.84k| { 2271| | /* Amount of text matched not including the EOB char. */ 2272| 2.84k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 2.84k|#define yytext_ptr yytext_r ------------------ 2273| | 2274| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2275| 2.84k| *yy_cp = yyg->yy_hold_char; 2276| 2.84k| YY_RESTORE_YY_MORE_OFFSET 2277| | 2278| 2.84k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 486| 2.84k|#define YY_BUFFER_NEW 0 ------------------ | Branch (2278:8): [True: 1.43k, False: 1.40k] ------------------ 2279| 1.43k| { 2280| | /* We're scanning a new file or input source. It's 2281| | * possible that this happened because the user 2282| | * just pointed yyin at a new source and called 2283| | * yylex(). If so, then we have to assure 2284| | * consistency between YY_CURRENT_BUFFER and our 2285| | * globals. Here is the right place to do so, because 2286| | * this is the first action (other than possibly a 2287| | * back-up) that will match for the new input source. 2288| | */ 2289| 1.43k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 1.43k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2290| 1.43k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 1.43k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 1.43k|#define yyin yyg->yyin_r ------------------ 2291| 1.43k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 1.43k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 487| 1.43k|#define YY_BUFFER_NORMAL 1 ------------------ 2292| 1.43k| } 2293| | 2294| | /* Note that here we test for yy_c_buf_p "<=" to the position 2295| | * of the first EOB in the buffer, since yy_c_buf_p will 2296| | * already have been incremented past the NUL character 2297| | * (since all states make transitions on EOB to the 2298| | * end-of-buffer state). Contrast this with the test 2299| | * in input(). 2300| | */ 2301| 2.84k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2301:8): [True: 0, False: 2.84k] ------------------ 2302| 0| { /* This was really a NUL. */ 2303| 0| yy_state_type yy_next_state; 2304| | 2305| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 2306| | 2307| 0| yy_current_state = yy_get_previous_state( yyscanner ); 2308| | 2309| | /* Okay, we're now positioned to make the NUL 2310| | * transition. We couldn't have 2311| | * yy_get_previous_state() go ahead and do it 2312| | * for us because it doesn't know how to deal 2313| | * with the possibility of jamming (and we don't 2314| | * want to build jamming into it because then it 2315| | * will run more slowly). 2316| | */ 2317| | 2318| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 2319| | 2320| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 0|#define YY_MORE_ADJ 0 ------------------ 2321| | 2322| 0| if ( yy_next_state ) ------------------ | Branch (2322:9): [True: 0, False: 0] ------------------ 2323| 0| { 2324| | /* Consume the NUL. */ 2325| 0| yy_cp = ++yyg->yy_c_buf_p; 2326| 0| yy_current_state = yy_next_state; 2327| 0| goto yy_match; 2328| 0| } 2329| | 2330| 0| else 2331| 0| { 2332| 0| yy_cp = yyg->yy_last_accepting_cpos; 2333| 0| yy_current_state = yyg->yy_last_accepting_state; 2334| 0| goto yy_find_action; 2335| 0| } 2336| 0| } 2337| | 2338| 2.84k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (2338:17): [True: 0, False: 2.84k] ------------------ 2339| 2.84k| { 2340| 1.37k| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 1.37k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (2340:4): [True: 1.37k, False: 1.46k] ------------------ 2341| 1.37k| { 2342| 1.37k| yyg->yy_did_buffer_switch_on_eof = 0; 2343| | 2344| 1.37k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 1.37k|#define yywrap yara_yywrap | | ------------------ | | | | 561| 1.37k|#define yara_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:32): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2345| 1.37k| { 2346| | /* Note: because we've taken care in 2347| | * yy_get_next_buffer() to have set up 2348| | * yytext, we can now set up 2349| | * yy_c_buf_p so that if some total 2350| | * hoser (like flex itself) wants to 2351| | * call the scanner after we return the 2352| | * YY_NULL, it'll still work - another 2353| | * YY_NULL will get returned. 2354| | */ 2355| 1.37k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.37k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1.37k|#define YY_MORE_ADJ 0 ------------------ 2356| | 2357| 1.37k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 1.37k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.37k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ 2358| 1.37k| goto do_action; 2359| 1.37k| } 2360| | 2361| 0| else 2362| 0| { 2363| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (2363:11): [True: 0, False: 0] ------------------ 2364| 0| YY_NEW_FILE; ------------------ | | 367| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart yara_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 2365| 0| } 2366| 0| break; 2367| 1.37k| } 2368| | 2369| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (2369:4): [True: 0, False: 2.84k] ------------------ 2370| 0| yyg->yy_c_buf_p = 2371| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 2372| | 2373| 0| yy_current_state = yy_get_previous_state( yyscanner ); 2374| | 2375| 0| yy_cp = yyg->yy_c_buf_p; 2376| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 0|#define YY_MORE_ADJ 0 ------------------ 2377| 0| goto yy_match; 2378| | 2379| 1.46k| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 1.46k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (2379:4): [True: 1.46k, False: 1.37k] ------------------ 2380| 1.46k| yyg->yy_c_buf_p = 2381| 1.46k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 1.46k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2382| | 2383| 1.46k| yy_current_state = yy_get_previous_state( yyscanner ); 2384| | 2385| 1.46k| yy_cp = yyg->yy_c_buf_p; 2386| 1.46k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.46k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1.46k|#define YY_MORE_ADJ 0 ------------------ 2387| 1.46k| goto yy_find_action; 2388| 2.84k| } 2389| 0| break; 2390| 2.84k| } 2391| | 2392| 0| default: ------------------ | Branch (2392:2): [True: 0, False: 767k] ------------------ 2393| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2394| 767k| "fatal flex scanner internal error--no action found" ); 2395| 767k| } /* end of action switch */ 2396| 767k| } /* end of scanning one token */ 2397| 571k| } /* end of user's declarations */ 2398| 571k|} /* end of yylex */ yara_yy_switch_to_buffer: 2714| 1.72k|{ 2715| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2716| | 2717| | /* TODO. We should be able to replace this entire function body 2718| | * with 2719| | * yypop_buffer_state(); 2720| | * yypush_buffer_state(new_buffer); 2721| | */ 2722| 1.72k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 1.72k|#define yyensure_buffer_stack yara_yyensure_buffer_stack ------------------ 2723| 1.72k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ | Branch (2723:7): [True: 0, False: 1.72k] ------------------ 2724| 0| return; 2725| | 2726| 1.72k| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1.72k] | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ 2727| 0| { 2728| | /* Flush out information for old buffer. */ 2729| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 2730| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2731| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2732| 0| } 2733| | 2734| 1.72k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 1.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2735| 1.72k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.72k|#define yy_load_buffer_state yara_yy_load_buffer_state ------------------ 2736| | 2737| | /* We don't actually know whether we did this switch during 2738| | * EOF (yywrap()) processing, but the only time this flag 2739| | * is looked at is after yywrap() is called, so it's safe 2740| | * to go ahead and always set it. 2741| | */ 2742| 1.72k| yyg->yy_did_buffer_switch_on_eof = 1; 2743| 1.72k|} yara_yy_delete_buffer: 2789| 1.72k|{ 2790| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2791| | 2792| 1.72k| if ( ! b ) ------------------ | Branch (2792:7): [True: 0, False: 1.72k] ------------------ 2793| 0| return; 2794| | 2795| 1.72k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ | Branch (2795:7): [True: 1.72k, False: 0] ------------------ 2796| 1.72k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 1.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2797| | 2798| 1.72k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2798:7): [True: 1.72k, False: 0] ------------------ 2799| 1.72k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 1.72k|#define yyfree yara_yyfree ------------------ 2800| | 2801| 1.72k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 1.72k|#define yyfree yara_yyfree ------------------ 2802| 1.72k|} yara_yypop_buffer_state: 2899| 1.72k|{ 2900| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2901| 1.72k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ | Branch (2901:6): [True: 349, False: 1.37k] ------------------ 2902| 349| return; 2903| | 2904| 1.37k| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 1.37k|#define yy_delete_buffer yara_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 509| 1.37k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.37k, False: 0] | | ------------------ | | 510| 1.37k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.37k| : NULL) ------------------ 2905| 1.37k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 1.37k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2906| 1.37k| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2906:6): [True: 0, False: 1.37k] ------------------ 2907| 0| --yyg->yy_buffer_stack_top; 2908| | 2909| 1.37k| if (YY_CURRENT_BUFFER) { ------------------ | | 509| 1.37k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1.37k] | | | Branch (509:29): [True: 1.37k, False: 0] | | ------------------ | | 510| 1.37k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.37k| : NULL) ------------------ 2910| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state yara_yy_load_buffer_state ------------------ 2911| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2912| 0| } 2913| 1.37k|} yara_yy_scan_buffer: 2969| 1.72k|{ 2970| 1.72k| YY_BUFFER_STATE b; 2971| | 2972| 1.72k| if ( size < 2 || ------------------ | Branch (2972:7): [True: 0, False: 1.72k] ------------------ 2973| 1.72k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 3.44k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2973:7): [True: 0, False: 1.72k] ------------------ 2974| 1.72k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 1.72k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2974:7): [True: 0, False: 1.72k] ------------------ 2975| | /* They forgot to leave room for the EOB's. */ 2976| 0| return NULL; 2977| | 2978| 1.72k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 1.72k|#define yyalloc yara_yyalloc ------------------ 2979| 1.72k| if ( ! b ) ------------------ | Branch (2979:7): [True: 0, False: 1.72k] ------------------ 2980| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2981| | 2982| 1.72k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2983| 1.72k| b->yy_buf_pos = b->yy_ch_buf = base; 2984| 1.72k| b->yy_is_our_buffer = 0; 2985| 1.72k| b->yy_input_file = NULL; 2986| 1.72k| b->yy_n_chars = b->yy_buf_size; 2987| 1.72k| b->yy_is_interactive = 0; 2988| 1.72k| b->yy_at_bol = 1; 2989| 1.72k| b->yy_fill_buffer = 0; 2990| 1.72k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 1.72k|#define YY_BUFFER_NEW 0 ------------------ 2991| | 2992| 1.72k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 1.72k|#define yy_switch_to_buffer yara_yy_switch_to_buffer ------------------ 2993| | 2994| 1.72k| return b; 2995| 1.72k|} yara_yy_scan_string: 3006| 1.72k|{ 3007| | 3008| 1.72k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 1.72k|#define yy_scan_bytes yara_yy_scan_bytes ------------------ 3009| 1.72k|} yara_yy_scan_bytes: 3019| 1.72k|{ 3020| 1.72k| YY_BUFFER_STATE b; 3021| 1.72k| char *buf; 3022| 1.72k| yy_size_t n; 3023| 1.72k| int i; 3024| | 3025| | /* Get memory for full buffer, including space for trailing EOB's. */ 3026| 1.72k| n = (yy_size_t) (_yybytes_len + 2); 3027| 1.72k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 1.72k|#define yyalloc yara_yyalloc ------------------ 3028| 1.72k| if ( ! buf ) ------------------ | Branch (3028:7): [True: 0, False: 1.72k] ------------------ 3029| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3030| | 3031| 3.51M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (3031:15): [True: 3.51M, False: 1.72k] ------------------ 3032| 3.51M| buf[i] = yybytes[i]; 3033| | 3034| 1.72k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 1.72k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 3035| | 3036| 1.72k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 1.72k|#define yy_scan_buffer yara_yy_scan_buffer ------------------ 3037| 1.72k| if ( ! b ) ------------------ | Branch (3037:7): [True: 0, False: 1.72k] ------------------ 3038| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3039| | 3040| | /* It's okay to grow etc. this buffer, and we should throw it 3041| | * away when we're done. 3042| | */ 3043| 1.72k| b->yy_is_our_buffer = 1; 3044| | 3045| 1.72k| return b; 3046| 1.72k|} yara_yyget_extra: 3083| 2.71M|{ 3084| 2.71M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3085| 2.71M| return yyextra; ------------------ | | 346| 2.71M|#define yyextra yyg->yyextra_r ------------------ 3086| 2.71M|} yara_yyget_lineno: 3092| 32.8k|{ 3093| 32.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3094| | 3095| 32.8k| if (! YY_CURRENT_BUFFER) ------------------ | | 509| 32.8k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 32.8k, False: 0] | | ------------------ | | 510| 32.8k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 32.8k| : NULL) ------------------ | Branch (3095:13): [True: 384, False: 32.4k] ------------------ 3096| 384| return 0; 3097| | 3098| 32.4k| return yylineno; ------------------ | | 349| 32.4k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 32.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 3099| 32.8k|} yara_yyset_extra: 3156| 1.72k|{ 3157| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3158| 1.72k| yyextra = user_defined ; ------------------ | | 346| 1.72k|#define yyextra yyg->yyextra_r ------------------ 3159| 1.72k|} yara_yyset_lineno: 3166| 1.72k|{ 3167| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3168| | 3169| | /* lineno is only valid if an input buffer exists. */ 3170| 1.72k| if (! YY_CURRENT_BUFFER ) ------------------ | | 509| 1.72k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.72k, False: 0] | | ------------------ | | 510| 1.72k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.72k| : NULL) ------------------ | Branch (3170:13): [True: 0, False: 1.72k] ------------------ 3171| 0| YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3172| | 3173| 1.72k| yylineno = _line_number; ------------------ | | 349| 1.72k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 1.72k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 3174| 1.72k|} yara_yylex_init: 3242| 1.72k|{ 3243| 1.72k| if (ptr_yy_globals == NULL){ ------------------ | Branch (3243:9): [True: 0, False: 1.72k] ------------------ 3244| 0| errno = EINVAL; 3245| 0| return 1; 3246| 0| } 3247| | 3248| 1.72k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 1.72k|#define yyalloc yara_yyalloc ------------------ 3249| | 3250| 1.72k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (3250:9): [True: 0, False: 1.72k] ------------------ 3251| 0| errno = ENOMEM; 3252| 0| return 1; 3253| 0| } 3254| | 3255| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 3256| 1.72k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 3257| | 3258| 1.72k| return yy_init_globals ( *ptr_yy_globals ); 3259| 1.72k|} yara_yylex_destroy: 3330| 1.72k|{ 3331| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3332| | 3333| | /* Pop the buffer stack, destroying each element. */ 3334| 2.07k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 2.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 349, False: 1.72k] | | | Branch (509:29): [True: 2.07k, False: 0] | | ------------------ | | 510| 2.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 2.07k| : NULL) ------------------ 3335| 349| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 349|#define yy_delete_buffer yara_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 349|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 349, False: 0] | | ------------------ | | 510| 349| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 349| : NULL) ------------------ 3336| 349| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 349|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3337| 349| yypop_buffer_state(yyscanner); ------------------ | | 80| 349|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 3338| 349| } 3339| | 3340| | /* Destroy the stack itself. */ 3341| 1.72k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 1.72k|#define yyfree yara_yyfree ------------------ 3342| 1.72k| yyg->yy_buffer_stack = NULL; 3343| | 3344| | /* Destroy the start condition stack. */ 3345| 1.72k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 1.72k|#define yyfree yara_yyfree ------------------ 3346| 1.72k| yyg->yy_start_stack = NULL; 3347| | 3348| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 3349| | * yylex() is called, initialization will occur. */ 3350| 1.72k| yy_init_globals( yyscanner); 3351| | 3352| | /* Destroy the main struct (reentrant only). */ 3353| 1.72k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 1.72k|#define yyfree yara_yyfree ------------------ 3354| 1.72k| yyscanner = NULL; 3355| 1.72k| return 0; 3356| 1.72k|} yara_yyalloc: 3386| 6.89k|{ 3387| 6.89k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3388| 6.89k| (void)yyg; 3389| 6.89k| return malloc(size); 3390| 6.89k|} yara_yyfree: 3408| 8.62k|{ 3409| 8.62k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3410| 8.62k| (void)yyg; 3411| 8.62k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3412| 8.62k|} yara_yywarning: 3424| 11.7k|{ 3425| 11.7k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 11.7k|#define yyget_extra yara_yyget_extra ------------------ 3426| | 3427| 11.7k| char* file_name; 3428| 11.7k| char message[512]; 3429| 11.7k| va_list message_args; 3430| | 3431| 11.7k| if (compiler->callback == NULL) ------------------ | Branch (3431:7): [True: 11.7k, False: 0] ------------------ 3432| 11.7k| return; 3433| | 3434| 0| va_start(message_args, message_fmt); 3435| | 3436| 0| if (compiler->file_name_stack_ptr > 0) ------------------ | Branch (3436:7): [True: 0, False: 0] ------------------ 3437| 0| file_name = compiler->file_name_stack[compiler->file_name_stack_ptr - 1]; 3438| 0| else 3439| 0| file_name = NULL; 3440| | 3441| 0| vsnprintf(message, sizeof(message), message_fmt, message_args); 3442| | 3443| 0| YR_RULE* current_rule = NULL; 3444| | 3445| 0| if (compiler->current_rule_idx != UINT32_MAX) ------------------ | Branch (3445:7): [True: 0, False: 0] ------------------ 3446| 0| current_rule = yr_arena_get_ptr( 3447| 0| compiler->arena, 3448| 0| YR_RULES_TABLE, ------------------ | | 58| 0|#define YR_RULES_TABLE 1 ------------------ 3449| 0| compiler->current_rule_idx * sizeof(YR_RULE)); 3450| | 3451| 0| compiler->callback( 3452| 0| YARA_ERROR_LEVEL_WARNING, ------------------ | | 42| 0|#define YARA_ERROR_LEVEL_WARNING 1 ------------------ 3453| 0| file_name, 3454| 0| compiler->current_line ? compiler->current_line : yyget_lineno(yyscanner), ------------------ | | 55| 0|#define yyget_lineno yara_yyget_lineno ------------------ | Branch (3454:7): [True: 0, False: 0] ------------------ 3455| 0| current_rule, 3456| 0| message, 3457| 0| compiler->user_data); 3458| | 3459| 0| va_end(message_args); 3460| 0|} yara_yyerror: 3478| 15.5k|{ 3479| 15.5k| char message[512] = {'\0'}; 3480| 15.5k| char* file_name = NULL; 3481| | 3482| 15.5k| compiler->errors++; 3483| | 3484| 15.5k| if (compiler->current_line != 0) ------------------ | Branch (3484:7): [True: 1.05k, False: 14.4k] ------------------ 3485| 1.05k| compiler->last_error_line = compiler->current_line; 3486| 14.4k| else 3487| 14.4k| compiler->last_error_line = yyget_lineno(yyscanner); ------------------ | | 55| 14.4k|#define yyget_lineno yara_yyget_lineno ------------------ 3488| | 3489| 15.5k| compiler->current_line = 0; 3490| | 3491| 15.5k| if (compiler->file_name_stack_ptr > 0) ------------------ | Branch (3491:7): [True: 0, False: 15.5k] ------------------ 3492| 0| { 3493| 0| file_name = compiler->file_name_stack[compiler->file_name_stack_ptr - 1]; 3494| 0| } 3495| 15.5k| else 3496| 15.5k| { 3497| 15.5k| file_name = NULL; 3498| 15.5k| } 3499| | 3500| 15.5k| YR_RULE* current_rule = NULL; 3501| | 3502| 15.5k| if (compiler->current_rule_idx != UINT32_MAX) ------------------ | Branch (3502:7): [True: 12.5k, False: 2.99k] ------------------ 3503| 12.5k| current_rule = yr_arena_get_ptr( 3504| 12.5k| compiler->arena, 3505| 12.5k| YR_RULES_TABLE, ------------------ | | 58| 12.5k|#define YR_RULES_TABLE 1 ------------------ 3506| 12.5k| compiler->current_rule_idx * sizeof(YR_RULE)); 3507| | 3508| | // if error_message != NULL the error comes from yyparse internal code 3509| | // else the error comes from my code and the error code is set in 3510| | // compiler->last_error 3511| | 3512| 15.5k| if (error_message != NULL) ------------------ | Branch (3512:7): [True: 7.73k, False: 7.80k] ------------------ 3513| 7.73k| { 3514| 7.73k| yr_compiler_set_error_extra_info(compiler, error_message); ------------------ | | 306| 7.73k| strlcpy( \ | | 307| 7.73k| compiler->last_error_extra_info, \ | | 308| 7.73k| info, \ | | 309| 7.73k| sizeof(compiler->last_error_extra_info)); ------------------ 3515| 7.73k| compiler->last_error = ERROR_SYNTAX_ERROR; ------------------ | | 56| 7.73k|#define ERROR_SYNTAX_ERROR 11 ------------------ 3516| | 3517| 7.73k| if (compiler->callback != NULL) ------------------ | Branch (3517:9): [True: 0, False: 7.73k] ------------------ 3518| 0| { 3519| 0| compiler->callback( 3520| 0| YARA_ERROR_LEVEL_ERROR, ------------------ | | 41| 0|#define YARA_ERROR_LEVEL_ERROR 0 ------------------ 3521| 0| file_name, 3522| 0| compiler->last_error_line, 3523| 0| current_rule, 3524| 0| error_message, 3525| 0| compiler->user_data); 3526| 0| } 3527| 7.73k| } 3528| 7.80k| else if (compiler->callback != NULL) ------------------ | Branch (3528:12): [True: 0, False: 7.80k] ------------------ 3529| 0| { 3530| 0| yr_compiler_get_error_message(compiler, message, sizeof(message)); 3531| | 3532| 0| compiler->callback( 3533| 0| YARA_ERROR_LEVEL_ERROR, ------------------ | | 41| 0|#define YARA_ERROR_LEVEL_ERROR 0 ------------------ 3534| 0| file_name, 3535| 0| compiler->last_error_line, 3536| 0| current_rule, 3537| 0| message, 3538| 0| compiler->user_data); 3539| 0| } 3540| 15.5k|} yr_lex_parse_rules_string: 3582| 1.72k|{ 3583| 1.72k| yyscan_t yyscanner; 3584| | 3585| 1.72k| compiler->errors = 0; 3586| | 3587| 1.72k| if (rules_string == NULL) ------------------ | Branch (3587:7): [True: 0, False: 1.72k] ------------------ 3588| 0| return 0; 3589| | 3590| 1.72k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 1.72k|#define yylex_init yara_yylex_init ------------------ | Branch (3590:7): [True: 0, False: 1.72k] ------------------ 3591| 0| { 3592| 0| compiler->errors = 1; 3593| 0| compiler->last_error = ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 3594| 0| return compiler->errors; 3595| 0| } 3596| | 3597| 1.72k| if (setjmp(compiler->error_recovery) != 0) ------------------ | Branch (3597:7): [True: 0, False: 1.72k] ------------------ 3598| 0| return compiler->errors; 3599| | 3600| | #if YYDEBUG 3601| | yydebug = 1; 3602| | #endif 3603| | 3604| 1.72k| yyset_extra(compiler, yyscanner); ------------------ | | 140| 1.72k|#define yyset_extra yara_yyset_extra ------------------ 3605| 1.72k| yy_scan_string(rules_string, yyscanner); ------------------ | | 38| 1.72k|#define yy_scan_string yara_yy_scan_string ------------------ 3606| 1.72k| yyset_lineno(1, yyscanner); ------------------ | | 188| 1.72k|#define yyset_lineno yara_yyset_lineno ------------------ 3607| 1.72k| yyparse(yyscanner, compiler); ------------------ | | 46| 1.72k|#define yyparse yara_yyparse ------------------ 3608| 1.72k| yylex_destroy(yyscanner); ------------------ | | 116| 1.72k|#define yylex_destroy yara_yylex_destroy ------------------ 3609| | 3610| 1.72k| return compiler->errors; 3611| 1.72k|} lexer.c:yy_get_next_buffer: 2408| 2.84k|{ 2409| 2.84k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2410| 2.84k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2411| 2.84k| char *source = yyg->yytext_ptr; ------------------ | | 567| 2.84k|#define yytext_ptr yytext_r ------------------ 2412| 2.84k| int number_to_move, i; 2413| 2.84k| int ret_val; 2414| | 2415| 2.84k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2415:7): [True: 0, False: 2.84k] ------------------ 2416| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2417| 2.84k| "fatal flex scanner internal error--end of buffer missed" ); 2418| | 2419| 2.84k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 2.84k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2419:7): [True: 2.84k, False: 0] ------------------ 2420| 2.84k| { /* Don't try to fill the buffer, so this is an EOF. */ 2421| 2.84k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 2.84k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 895| 2.84k|#define YY_MORE_ADJ 0 ------------------ | Branch (2421:8): [True: 1.37k, False: 1.46k] ------------------ 2422| 1.37k| { 2423| | /* We matched a single character, the EOB, so 2424| | * treat this as a final EOF. 2425| | */ 2426| 1.37k| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 1.37k|#define EOB_ACT_END_OF_FILE 1 ------------------ 2427| 1.37k| } 2428| | 2429| 1.46k| else 2430| 1.46k| { 2431| | /* We matched some text prior to the EOB, first 2432| | * process it. 2433| | */ 2434| 1.46k| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 1.46k|#define EOB_ACT_LAST_MATCH 2 ------------------ 2435| 1.46k| } 2436| 2.84k| } 2437| | 2438| | /* Try to read more data. */ 2439| | 2440| | /* First move last chars to start of buffer. */ 2441| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 2442| | 2443| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (2443:15): [True: 0, False: 0] ------------------ 2444| 0| *(dest++) = *(source++); 2445| | 2446| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (2446:7): [True: 0, False: 0] ------------------ 2447| | /* don't do the read, it's not guaranteed to return an EOF, 2448| | * just force an EOF 2449| | */ 2450| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2451| | 2452| 0| else 2453| 0| { 2454| 0| int num_to_read = 2455| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2456| | 2457| 0| while ( num_to_read <= 0 ) ------------------ | Branch (2457:11): [True: 0, False: 0] ------------------ 2458| 0| { /* Not enough room in the buffer - grow it. */ 2459| | 2460| | /* just a shorter name for the current buffer */ 2461| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2462| | 2463| 0| int yy_c_buf_p_offset = 2464| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 2465| | 2466| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (2466:9): [True: 0, False: 0] ------------------ 2467| 0| { 2468| 0| int new_size = b->yy_buf_size * 2; 2469| | 2470| 0| if ( new_size <= 0 ) ------------------ | Branch (2470:10): [True: 0, False: 0] ------------------ 2471| 0| b->yy_buf_size += b->yy_buf_size / 8; 2472| 0| else 2473| 0| b->yy_buf_size *= 2; 2474| | 2475| 0| b->yy_ch_buf = (char *) 2476| | /* Include room in for 2 EOB chars. */ 2477| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2478| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 2479| 0| } 2480| 0| else 2481| | /* Can't grow it, we don't own it. */ 2482| 0| b->yy_ch_buf = NULL; 2483| | 2484| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (2484:9): [True: 0, False: 0] ------------------ 2485| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2486| 0| "fatal error - scanner input buffer overflow" ); 2487| | 2488| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 2489| | 2490| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2491| 0| number_to_move - 1; 2492| | 2493| 0| } 2494| | 2495| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1179| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (2495:8): [True: 0, False: 0] ------------------ 2496| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1179| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 2497| | 2498| | /* Read in more data. */ 2499| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1196| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (1196:7): [True: 0, False: 0] | | ------------------ | | 1197| 0| { \ | | 1198| 0| int c = '*'; \ | | 1199| 0| int n; \ | | 1200| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1200:16): [True: 0, False: 0] | | ------------------ | | 1201| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1201:9): [True: 0, False: 0] | | | Branch (1201:38): [True: 0, False: 0] | | ------------------ | | 1202| 0| buf[n] = (char) c; \ | | 1203| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1203:8): [True: 0, False: 0] | | ------------------ | | 1204| 0| buf[n++] = (char) c; \ | | 1205| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1205:8): [True: 0, False: 0] | | | Branch (1205:20): [True: 0, False: 0] | | ------------------ | | 1206| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) | | ------------------ | | 1207| 0| result = n; \ | | 1208| 0| } \ | | 1209| 0| else \ | | 1210| 0| { \ | | 1211| 0| errno=0; \ | | 1212| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1212:11): [True: 0, False: 0] | | | Branch (1212:78): [True: 0, False: 0] | | ------------------ | | 1213| 0| { \ | | 1214| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1214:8): [True: 0, False: 0] | | ------------------ | | 1215| 0| { \ | | 1216| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) | | ------------------ | | 1217| 0| break; \ | | 1218| 0| } \ | | 1219| 0| errno=0; \ | | 1220| 0| clearerr(yyin); \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | 1221| 0| } \ | | 1222| 0| }\ ------------------ 2500| 0| yyg->yy_n_chars, num_to_read ); 2501| | 2502| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2503| 0| } 2504| | 2505| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (2505:7): [True: 0, False: 0] ------------------ 2506| 0| { 2507| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 895| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (2507:8): [True: 0, False: 0] ------------------ 2508| 0| { 2509| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 398| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 2510| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart yara_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ 2511| 0| } 2512| | 2513| 0| else 2514| 0| { 2515| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 399| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 2516| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2517| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 2518| 0| } 2519| 0| } 2520| | 2521| 0| else 2522| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 2523| | 2524| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2524:6): [True: 0, False: 0] ------------------ 2525| | /* Extend the array by 50%, plus the number we really need. */ 2526| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 2527| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2528| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2529| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2529:8): [True: 0, False: 0] ------------------ 2530| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2531| | /* "- 2" to take care of EOB's */ 2532| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2533| 0| } 2534| | 2535| 0| yyg->yy_n_chars += number_to_move; 2536| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2537| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2538| | 2539| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2540| | 2541| 0| return ret_val; 2542| 2.84k|} lexer.c:yy_get_previous_state: 2547| 1.46k|{ 2548| 1.46k| yy_state_type yy_current_state; 2549| 1.46k| char *yy_cp; 2550| 1.46k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2551| | 2552| 1.46k| yy_current_state = yyg->yy_start; 2553| | 2554| 238k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 1.46k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 895| 1.46k|#define YY_MORE_ADJ 0 ------------------ | Branch (2554:47): [True: 236k, False: 1.46k] ------------------ 2555| 236k| { 2556| 236k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 236k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (2556:19): [True: 236k, False: 0] ------------------ 2557| 236k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2557:8): [True: 76.7k, False: 160k] ------------------ 2558| 76.7k| { 2559| 76.7k| yyg->yy_last_accepting_state = yy_current_state; 2560| 76.7k| yyg->yy_last_accepting_cpos = yy_cp; 2561| 76.7k| } 2562| 468k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2562:11): [True: 231k, False: 236k] ------------------ 2563| 231k| { 2564| 231k| yy_current_state = (int) yy_def[yy_current_state]; 2565| 231k| if ( yy_current_state >= 295 ) ------------------ | Branch (2565:9): [True: 231k, False: 134] ------------------ 2566| 231k| yy_c = yy_meta[yy_c]; 2567| 231k| } 2568| 236k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2569| 236k| } 2570| | 2571| 1.46k| return yy_current_state; 2572| 1.46k|} lexer.c:yara_yy_load_buffer_state: 2746| 3.44k|{ 2747| 3.44k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2748| 3.44k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 3.44k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2749| 3.44k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 3.44k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 3.44k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2750| 3.44k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 3.44k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 3.44k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2751| 3.44k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2752| 3.44k|} lexer.c:yara_yyensure_buffer_stack: 2919| 1.72k|{ 2920| 1.72k| yy_size_t num_to_alloc; 2921| 1.72k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2922| | 2923| 1.72k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2923:6): [True: 1.72k, False: 0] ------------------ 2924| | 2925| | /* First allocation is just for 2 elements, since we don't know if this 2926| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2927| | * immediate realloc on the next call. 2928| | */ 2929| 1.72k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2930| 1.72k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 1.72k|#define yyalloc yara_yyalloc ------------------ 2931| 1.72k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2932| 1.72k| , yyscanner); 2933| 1.72k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2933:8): [True: 0, False: 1.72k] ------------------ 2934| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2935| | 2936| 1.72k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2937| | 2938| 1.72k| yyg->yy_buffer_stack_max = num_to_alloc; 2939| 1.72k| yyg->yy_buffer_stack_top = 0; 2940| 1.72k| return; 2941| 1.72k| } 2942| | 2943| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2943:6): [True: 0, False: 0] ------------------ 2944| | 2945| | /* Increase the buffer to prepare for a possible push. */ 2946| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2947| | 2948| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2949| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2950| 0| (yyg->yy_buffer_stack, 2951| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2952| 0| , yyscanner); 2953| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2953:8): [True: 0, False: 0] ------------------ 2954| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2955| | 2956| | /* zero only the new slots.*/ 2957| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2958| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2959| 0| } 2960| 0|} lexer.c:yy_init_globals: 3296| 3.44k|{ 3297| 3.44k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3298| | /* Initialization is the same as for the non-reentrant scanner. 3299| | * This function is called from yylex_destroy(), so don't allocate here. 3300| | */ 3301| | 3302| 3.44k| yyg->yy_buffer_stack = NULL; 3303| 3.44k| yyg->yy_buffer_stack_top = 0; 3304| 3.44k| yyg->yy_buffer_stack_max = 0; 3305| 3.44k| yyg->yy_c_buf_p = NULL; 3306| 3.44k| yyg->yy_init = 0; 3307| 3.44k| yyg->yy_start = 0; 3308| | 3309| 3.44k| yyg->yy_start_stack_ptr = 0; 3310| 3.44k| yyg->yy_start_stack_depth = 0; 3311| 3.44k| yyg->yy_start_stack = NULL; 3312| | 3313| |/* Defined in main.c */ 3314| |#ifdef YY_STDINIT 3315| | yyin = stdin; 3316| | yyout = stdout; 3317| |#else 3318| 3.44k| yyin = NULL; ------------------ | | 344| 3.44k|#define yyin yyg->yyin_r ------------------ 3319| 3.44k| yyout = NULL; ------------------ | | 345| 3.44k|#define yyout yyg->yyout_r ------------------ 3320| 3.44k|#endif 3321| | 3322| | /* For future reference: Set errno on error, since we are called by 3323| | * yylex_init() 3324| | */ 3325| 3.44k| return 0; 3326| 3.44k|} yr_initialize: 242| 2|{ 243| 2| YR_DEBUG_FPRINTF(2, stderr, "+ %s() {\n", __FUNCTION__); 244| | 245| 2| uint32_t def_stack_size = DEFAULT_STACK_SIZE; ------------------ | | 81| 2|#define DEFAULT_STACK_SIZE 16384 ------------------ 246| 2| uint32_t def_max_strings_per_rule = DEFAULT_MAX_STRINGS_PER_RULE; ------------------ | | 82| 2|#define DEFAULT_MAX_STRINGS_PER_RULE 10000 ------------------ 247| 2| uint32_t def_max_match_data = DEFAULT_MAX_MATCH_DATA; ------------------ | | 83| 2|#define DEFAULT_MAX_MATCH_DATA 512 ------------------ 248| 2| uint64_t def_max_process_memory_chunk = DEFAULT_MAX_PROCESS_MEMORY_CHUNK; ------------------ | | 84| 2|#define DEFAULT_MAX_PROCESS_MEMORY_CHUNK 1073741824 ------------------ 249| | 250| 2| init_count++; 251| | 252| 2| if (init_count > 1) ------------------ | Branch (252:7): [True: 0, False: 2] ------------------ 253| 0| return ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 254| | 255| | // Initialize random number generator, as it is used for generating object 256| | // canaries. 257| 2| srand((unsigned) time(NULL)); 258| | 259| 514| for (int i = 0; i < 256; i++) ------------------ | Branch (259:19): [True: 512, False: 2] ------------------ 260| 512| { 261| 512| if (i >= 'a' && i <= 'z') ------------------ | Branch (261:9): [True: 318, False: 194] | Branch (261:21): [True: 52, False: 266] ------------------ 262| 52| yr_altercase[i] = i - 32; 263| 460| else if (i >= 'A' && i <= 'Z') ------------------ | Branch (263:14): [True: 330, False: 130] | Branch (263:26): [True: 52, False: 278] ------------------ 264| 52| yr_altercase[i] = i + 32; 265| 408| else 266| 408| yr_altercase[i] = i; 267| | 268| 512| yr_lowercase[i] = tolower(i); 269| 512| } 270| | 271| 2| FAIL_ON_ERROR(yr_heap_alloc()); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 272| 2| FAIL_ON_ERROR(yr_thread_storage_create(&yr_yyfatal_trampoline_tls)); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 273| 2| FAIL_ON_ERROR(yr_thread_storage_create(&yr_trycatch_trampoline_tls)); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 274| | 275| |#if defined HAVE_LIBCRYPTO && OPENSSL_VERSION_NUMBER < 0x10100000L 276| | 277| | openssl_locks = (YR_MUTEX *) OPENSSL_malloc( 278| | CRYPTO_num_locks() * sizeof(YR_MUTEX)); 279| | 280| | for (int i = 0; i < CRYPTO_num_locks(); i++) 281| | yr_mutex_create(&openssl_locks[i]); 282| | 283| | CRYPTO_THREADID_set_callback(_thread_id); 284| | CRYPTO_set_locking_callback(_locking_function); 285| | 286| |#elif defined(HAVE_WINCRYPT_H) 287| | 288| | if (!CryptAcquireContext( 289| | &yr_cryptprov, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) 290| | { 291| | return ERROR_INTERNAL_FATAL_ERROR; 292| | } 293| | 294| |#elif defined(HAVE_COMMON_CRYPTO) 295| | 296| | ... 297| | 298| |#endif 299| | 300| 2| FAIL_ON_ERROR(yr_modules_initialize()); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 301| | 302| | // Initialize default configuration options 303| | 304| 2| FAIL_ON_ERROR(yr_set_configuration(YR_CONFIG_STACK_SIZE, &def_stack_size)); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 305| | 306| 2| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 307| 2| YR_CONFIG_MAX_STRINGS_PER_RULE, &def_max_strings_per_rule)); 308| | 309| 2| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 310| 2| YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK, &def_max_process_memory_chunk)); 311| | 312| 2| FAIL_ON_ERROR( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 313| 2| yr_set_configuration(YR_CONFIG_MAX_MATCH_DATA, &def_max_match_data)); 314| | 315| 2| YR_DEBUG_FPRINTF(2, stderr, "} // %s()\n", __FUNCTION__); 316| | 317| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 318| 2|} yr_set_configuration: 396| 8|{ 397| 8| if (src == NULL) ------------------ | Branch (397:7): [True: 0, False: 8] ------------------ 398| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 399| | 400| 8| switch (name) 401| 8| { // lump all the cases using same types together in one cascade 402| 2| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (402:3): [True: 2, False: 6] ------------------ 403| 4| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (403:3): [True: 2, False: 6] ------------------ 404| 6| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (404:3): [True: 2, False: 6] ------------------ 405| 6| yr_cfgs[name].ui32 = *(uint32_t *) src; 406| 6| break; 407| | 408| 2| case YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK: ------------------ | Branch (408:3): [True: 2, False: 6] ------------------ 409| 2| yr_cfgs[name].ui64 = *(uint64_t *) src; 410| 2| break; 411| | 412| 0| default: ------------------ | Branch (412:3): [True: 0, False: 8] ------------------ 413| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 414| 8| } 415| | 416| 8| return ERROR_SUCCESS; ------------------ | | 40| 8|#define ERROR_SUCCESS 0 ------------------ 417| 8|} yr_get_configuration: 486| 388|{ 487| 388| if (dest == NULL) ------------------ | Branch (487:7): [True: 0, False: 388] ------------------ 488| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 489| | 490| 388| switch (name) 491| 388| { // lump all the cases using same types together in one cascade 492| 0| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (492:3): [True: 0, False: 388] ------------------ 493| 388| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (493:3): [True: 388, False: 0] ------------------ 494| 388| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (494:3): [True: 0, False: 388] ------------------ 495| 388| *(uint32_t *) dest = yr_cfgs[name].ui32; 496| 388| break; 497| | 498| 0| case YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK: ------------------ | Branch (498:3): [True: 0, False: 388] ------------------ 499| 0| *(uint64_t *) dest = yr_cfgs[name].ui64; 500| 0| break; 501| | 502| 0| default: ------------------ | Branch (502:3): [True: 0, False: 388] ------------------ 503| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 504| 388| } 505| | 506| 388| return ERROR_SUCCESS; ------------------ | | 40| 388|#define ERROR_SUCCESS 0 ------------------ 507| 388|} yr_get_configuration_uint32: 522| 388|{ 523| 388| switch (name) 524| 388| { 525| | // Accept only the configuration options that are of type uint32_t. 526| 0| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (526:3): [True: 0, False: 388] ------------------ 527| 388| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (527:3): [True: 388, False: 0] ------------------ 528| 388| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (528:3): [True: 0, False: 388] ------------------ 529| 388| return yr_get_configuration(name, (void *) dest); 530| 0| default: ------------------ | Branch (530:3): [True: 0, False: 388] ------------------ 531| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 532| 388| } 533| 388|} yr_heap_alloc: 120| 2|{ 121| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 122| 2|} yr_calloc: 130| 3.67k|{ 131| 3.67k| return calloc(count, size); 132| 3.67k|} yr_malloc: 135| 29.4M|{ 136| 29.4M| return malloc(size); 137| 29.4M|} yr_realloc: 140| 11.4k|{ 141| 11.4k| return realloc(ptr, size); 142| 11.4k|} yr_strdup: 145| 188k|{ 146| 188k| return strdup(str); 147| 188k|} yr_free: 155| 29.6M|{ 156| 29.6M| free(ptr); 157| 29.6M|} yr_modules_initialize: 64| 2|{ 65| 22| for (YR_MODULE* module = yr_modules_table; module->initialize != NULL; ------------------ | Branch (65:46): [True: 20, False: 2] ------------------ 66| 20| module++) 67| 20| { 68| 20| int result = module->initialize(module); 69| | 70| 20| if (result != ERROR_SUCCESS) ------------------ | | 40| 20|#define ERROR_SUCCESS 0 ------------------ | Branch (70:9): [True: 0, False: 20] ------------------ 71| 0| return result; 72| 20| } 73| | 74| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 75| 2|} yr_modules_do_declarations: 93| 360|{ 94| 360| for (YR_MODULE* module = yr_modules_table; 95| 2.39k| module->name != NULL && module->declarations != NULL; ------------------ | Branch (95:8): [True: 2.22k, False: 177] | Branch (95:32): [True: 2.22k, False: 0] ------------------ 96| 2.03k| module++) 97| 2.22k| { 98| 2.22k| if (strcmp(module->name, module_name) == 0) ------------------ | Branch (98:9): [True: 183, False: 2.03k] ------------------ 99| 183| return module->declarations(main_structure); 100| 2.22k| } 101| | 102| 177| return ERROR_UNKNOWN_MODULE; ------------------ | | 81| 177|#define ERROR_UNKNOWN_MODULE 34 ------------------ 103| 360|} console__initialize: 260| 2|{ 261| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 262| 2|} dex__declarations: 193| 2|begin_declarations ------------------ | | 59| 2| { \ | | 60| 2| YR_OBJECT* stack[64]; \ | | 61| 2| int stack_top = 0; \ | | 62| 2| stack[stack_top] = module; ------------------ 194| 2| declare_string("DEX_FILE_MAGIC_035"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 195| 2| declare_string("DEX_FILE_MAGIC_036"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 196| 2| declare_string("DEX_FILE_MAGIC_037"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 197| 2| declare_string("DEX_FILE_MAGIC_038"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 198| 2| declare_string("DEX_FILE_MAGIC_039"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 199| | 200| 2| declare_integer("ENDIAN_CONSTANT"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 201| 2| declare_integer("REVERSE_ENDIAN_CONSTANT"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 202| 2| declare_integer("NO_INDEX"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 203| 2| declare_integer("ACC_PUBLIC"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 204| 2| declare_integer("ACC_PRIVATE"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 205| 2| declare_integer("ACC_PROTECTED"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 206| 2| declare_integer("ACC_STATIC"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 207| 2| declare_integer("ACC_FINAL"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 208| 2| declare_integer("ACC_SYNCHRONIZED"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 209| 2| declare_integer("ACC_VOLATILE"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 210| 2| declare_integer("ACC_BRIDGE"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 211| 2| declare_integer("ACC_TRANSIENT"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 212| 2| declare_integer("ACC_VARARGS"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 213| 2| declare_integer("ACC_NATIVE"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 214| 2| declare_integer("ACC_INTERFACE"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 215| 2| declare_integer("ACC_ABSTRACT"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 216| 2| declare_integer("ACC_STRICT"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 217| 2| declare_integer("ACC_SYNTHETIC"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 218| 2| declare_integer("ACC_ANNOTATION"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 219| 2| declare_integer("ACC_ENUM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 220| 2| declare_integer("ACC_CONSTRUCTOR"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 221| 2| declare_integer("ACC_DECLARED_SYNCHRONIZED"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 222| | 223| 2| declare_integer("TYPE_HEADER_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 224| 2| declare_integer("TYPE_STRING_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 225| 2| declare_integer("TYPE_TYPE_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 226| 2| declare_integer("TYPE_PROTO_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 227| 2| declare_integer("TYPE_FIELD_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 228| 2| declare_integer("TYPE_METHOD_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 229| 2| declare_integer("TYPE_CLASS_DEF_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 230| 2| declare_integer("TYPE_CALL_SITE_ID_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 231| 2| declare_integer("TYPE_METHOD_HANDLE_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 232| 2| declare_integer("TYPE_MAP_LIST"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 233| 2| declare_integer("TYPE_TYPE_LIST"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 234| 2| declare_integer("TYPE_ANNOTATION_SET_REF_LIST"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 235| 2| declare_integer("TYPE_ANNOTATION_SET_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 236| 2| declare_integer("TYPE_CLASS_DATA_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 237| 2| declare_integer("TYPE_CODE_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 238| 2| declare_integer("TYPE_STRING_DATA_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 239| 2| declare_integer("TYPE_DEBUG_INFO_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 240| 2| declare_integer("TYPE_ANNOTATION_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 241| 2| declare_integer("TYPE_ENCODED_ARRAY_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 242| 2| declare_integer("TYPE_ANNOTATIONS_DIRECTORY_ITEM"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 243| | 244| 4| begin_struct("header") ------------------ | | 69| 2| { \ | | 70| 2| YR_OBJECT* structure; \ | | 71| 2| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 72| 2| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 2| "too many nested structures"); \ | | 76| 2| stack[++stack_top] = structure; \ | | 77| 2| } ------------------ 245| 2| declare_string("magic"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 246| 2| declare_integer("checksum"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 247| 2| declare_string("signature"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 248| 2| declare_integer("file_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 249| 2| declare_integer("header_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 250| 2| declare_integer("endian_tag"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 251| 2| declare_integer("link_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 252| 2| declare_integer("link_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 253| 2| declare_integer("map_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 254| 2| declare_integer("string_ids_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 255| 2| declare_integer("string_ids_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 256| 2| declare_integer("type_ids_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 257| 2| declare_integer("type_ids_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 258| 2| declare_integer("proto_ids_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 259| 2| declare_integer("proto_ids_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 260| 2| declare_integer("field_ids_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 261| 2| declare_integer("field_ids_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 262| 2| declare_integer("method_ids_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 263| 2| declare_integer("method_ids_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 264| 2| declare_integer("class_defs_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 265| 2| declare_integer("class_defs_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 266| 2| declare_integer("data_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 267| 2| declare_integer("data_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 268| 4| end_struct("header") ------------------ | | 108| 2| { \ | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | 113| 2| stack_top--; \ | | 114| 2| } ------------------ 269| | 270| 6| begin_struct_array("string_ids") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 271| 2| declare_integer("offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 272| 2| declare_integer("size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 273| 2| declare_string("value"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 274| 4| end_struct_array("string_ids") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 275| | 276| 6| begin_struct_array("type_ids") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 277| 2| declare_integer("descriptor_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 278| 4| end_struct_array("type_ids") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 279| | 280| 6| begin_struct_array("proto_ids") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 281| 2| declare_integer("shorty_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 282| 2| declare_integer("return_type_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 283| 2| declare_integer("parameters_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 284| 4| end_struct_array("proto_ids") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 285| | 286| 6| begin_struct_array("field_ids") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 287| 2| declare_integer("class_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 288| 2| declare_integer("type_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 289| 2| declare_integer("name_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 290| 4| end_struct_array("field_ids") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 291| | 292| 6| begin_struct_array("method_ids") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 293| 2| declare_integer("class_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 294| 2| declare_integer("proto_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 295| 2| declare_integer("name_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 296| 4| end_struct_array("method_ids") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 297| | 298| 6| begin_struct_array("class_defs") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 299| 2| declare_integer("class_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 300| 2| declare_integer("access_flags"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 301| 2| declare_integer("super_class_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 302| 2| declare_integer("interfaces_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 303| 2| declare_integer("source_file_idx"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 304| 2| declare_integer("annotations_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 305| 2| declare_integer("class_data_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 306| 2| declare_integer("static_values_offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 307| 4| end_struct_array("class_defs") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 308| | 309| 6| begin_struct_array("class_data_item") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 310| 2| declare_integer("static_fields_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 311| 2| declare_integer("instance_fields_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 312| 2| declare_integer("direct_methods_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 313| 2| declare_integer("virtual_methods_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 314| 4| end_struct_array("class_data_item") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 315| | 316| 4| begin_struct("map_list") ------------------ | | 69| 2| { \ | | 70| 2| YR_OBJECT* structure; \ | | 71| 2| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 72| 2| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 2| "too many nested structures"); \ | | 76| 2| stack[++stack_top] = structure; \ | | 77| 2| } ------------------ 317| 2| declare_integer("size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 318| 6| begin_struct_array("map_item") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 319| 2| declare_integer("type"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 320| 2| declare_integer("unused"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 321| 2| declare_integer("size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 322| 2| declare_integer("offset"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 323| 4| end_struct_array("map_item"); ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 324| 4| end_struct("map_list") ------------------ | | 108| 2| { \ | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | 113| 2| stack_top--; \ | | 114| 2| } ------------------ 325| | 326| 2| declare_integer("number_of_fields"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 327| 6| begin_struct_array("field") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 328| 2| declare_string("class_name"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 329| 2| declare_string("name"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 330| 2| declare_string("proto"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 331| 2| declare_integer("static"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 332| 2| declare_integer("instance"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 333| 2| declare_integer("field_idx_diff"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 334| 2| declare_integer("access_flags"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 335| 4| end_struct_array("field") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 336| | 337| 2| declare_function("has_method", "s", "i", has_method_string); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 338| 2| declare_function("has_method", "ss", "i", has_method_and_class_string); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 339| 2| declare_function("has_method", "r", "i", has_method_regexp); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 340| 2| declare_function("has_method", "rr", "i", has_method_and_class_regexp); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 341| 2| declare_function("has_class", "s", "i", has_class_string); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 342| 2| declare_function("has_class", "r", "i", has_class_regexp); ------------------ | | 191| 2| { \ | | 192| 2| YR_OBJECT* function; \ | | 193| 2| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 194| 2| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 2| } ------------------ 343| | 344| 2| declare_integer("number_of_methods"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 345| 6| begin_struct_array("method") ------------------ | | 80| 2| { \ | | 81| 2| YR_OBJECT* structure; \ | | 82| 2| YR_OBJECT* array; \ | | 83| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 84| 2| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 86| 2| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 2| "too many nested structures"); \ | | 90| 2| stack[++stack_top] = structure; \ | | 91| 2| } ------------------ 346| 2| declare_string("class_name"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 347| 2| declare_string("name"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 348| 2| declare_string("proto"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 349| 2| declare_integer("direct"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 350| 2| declare_integer("virtual"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 351| 2| declare_integer("method_idx_diff"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 352| 2| declare_integer("access_flags"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 353| 2| declare_integer("code_off"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 354| | 355| 4| begin_struct("code_item") ------------------ | | 69| 2| { \ | | 70| 2| YR_OBJECT* structure; \ | | 71| 2| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 72| 2| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 2| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 2| "too many nested structures"); \ | | 76| 2| stack[++stack_top] = structure; \ | | 77| 2| } ------------------ 356| 2| declare_integer("registers_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 357| 2| declare_integer("ins_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 358| 2| declare_integer("outs_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 359| 2| declare_integer("tries_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 360| 2| declare_integer("debug_info_off"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 361| 2| declare_integer("insns_size"); ------------------ | | 125| 2| { \ | | 126| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 127| 2| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 2| } ------------------ 362| 2| declare_string("insns"); ------------------ | | 169| 2| { \ | | 170| 2| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 2| { \ | | | | 135| 2| int __error = (x); \ | | | | 136| 2| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 2|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 2] | | | | ------------------ | | | | 137| 2| return __error; \ | | | | 138| 2| } | | ------------------ | | 171| 2| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 2| } ------------------ 363| 4| end_struct("code_item") ------------------ | | 108| 2| { \ | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 2| assertf( \ | | ------------------ | | | | 164| 2| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 2] | | | | ------------------ | | | | 165| 2| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | 113| 2| stack_top--; \ | | 114| 2| } ------------------ 364| 4| end_struct_array("method") ------------------ | | 117| 2| end_struct \ | | ------------------ | | | | 108| 2| { \ | | | | 109| 2| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 2| assertf( \ | | | | ------------------ | | | | | | 164| 2| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 2] | | | | | | ------------------ | | | | | | 165| 2| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 2| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 2| "unbalanced begin_struct/end_struct"); \ | | | | 113| 2| stack_top--; \ | | | | 114| 2| } | | ------------------ | | 118| 2| (name) ------------------ 365| 2|end_declarations ------------------ | | 65| 2| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 2| } ------------------ dex__initialize: 1433| 2|{ 1434| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 1435| 2|} dotnet__initialize: 3465| 2|{ 3466| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 3467| 2|} elf__declarations: 831| 15|begin_declarations ------------------ | | 59| 15| { \ | | 60| 15| YR_OBJECT* stack[64]; \ | | 61| 15| int stack_top = 0; \ | | 62| 15| stack[stack_top] = module; ------------------ 832| 15| declare_integer("ET_NONE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 833| 15| declare_integer("ET_REL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 834| 15| declare_integer("ET_EXEC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 835| 15| declare_integer("ET_DYN"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 836| 15| declare_integer("ET_CORE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 837| | 838| 15| declare_integer("EM_NONE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 839| 15| declare_integer("EM_M32"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 840| 15| declare_integer("EM_SPARC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 841| 15| declare_integer("EM_386"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 842| 15| declare_integer("EM_68K"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 843| 15| declare_integer("EM_88K"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 844| 15| declare_integer("EM_860"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 845| 15| declare_integer("EM_MIPS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 846| 15| declare_integer("EM_MIPS_RS3_LE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 847| 15| declare_integer("EM_PPC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 848| 15| declare_integer("EM_PPC64"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 849| 15| declare_integer("EM_ARM"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 850| 15| declare_integer("EM_X86_64"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 851| 15| declare_integer("EM_AARCH64"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 852| | 853| 15| declare_integer("SHT_NULL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 854| 15| declare_integer("SHT_PROGBITS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 855| 15| declare_integer("SHT_SYMTAB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 856| 15| declare_integer("SHT_STRTAB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 857| 15| declare_integer("SHT_RELA"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 858| 15| declare_integer("SHT_HASH"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 859| 15| declare_integer("SHT_DYNAMIC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 860| 15| declare_integer("SHT_NOTE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 861| 15| declare_integer("SHT_NOBITS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 862| 15| declare_integer("SHT_REL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 863| 15| declare_integer("SHT_SHLIB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 864| 15| declare_integer("SHT_DYNSYM"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 865| | 866| 15| declare_integer("SHF_WRITE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 867| 15| declare_integer("SHF_ALLOC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 868| 15| declare_integer("SHF_EXECINSTR"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 869| | 870| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 871| 15| declare_integer("machine"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 872| 15| declare_integer("entry_point"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 873| | 874| 15| declare_integer("number_of_sections"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 875| 15| declare_integer("sh_offset"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 876| 15| declare_integer("sh_entry_size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 877| | 878| 15| declare_integer("number_of_segments"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 879| 15| declare_integer("ph_offset"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 880| 15| declare_integer("ph_entry_size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 881| | 882| 45| begin_struct_array("sections") ------------------ | | 80| 15| { \ | | 81| 15| YR_OBJECT* structure; \ | | 82| 15| YR_OBJECT* array; \ | | 83| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 84| 15| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 86| 15| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 15| assertf( \ | | ------------------ | | | | 164| 15| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 15] | | | | ------------------ | | | | 165| 15| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 15| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 15| "too many nested structures"); \ | | 90| 15| stack[++stack_top] = structure; \ | | 91| 15| } ------------------ 883| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 884| 15| declare_integer("flags"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 885| 15| declare_integer("address"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 886| 15| declare_string("name"); ------------------ | | 169| 15| { \ | | 170| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 171| 15| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 15| } ------------------ 887| 15| declare_integer("size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 888| 15| declare_integer("offset"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 889| 30| end_struct_array("sections") ------------------ | | 117| 15| end_struct \ | | ------------------ | | | | 108| 15| { \ | | | | 109| 15| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 15| assertf( \ | | | | ------------------ | | | | | | 164| 15| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 165| 15| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 15| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 15| "unbalanced begin_struct/end_struct"); \ | | | | 113| 15| stack_top--; \ | | | | 114| 15| } | | ------------------ | | 118| 15| (name) ------------------ 890| | 891| 15| declare_integer("PT_NULL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 892| 15| declare_integer("PT_LOAD"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 893| 15| declare_integer("PT_DYNAMIC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 894| 15| declare_integer("PT_INTERP"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 895| 15| declare_integer("PT_NOTE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 896| 15| declare_integer("PT_SHLIB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 897| 15| declare_integer("PT_PHDR"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 898| 15| declare_integer("PT_TLS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 899| 15| declare_integer("PT_GNU_EH_FRAME"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 900| 15| declare_integer("PT_GNU_STACK"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 901| | 902| 15| declare_integer("DT_NULL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 903| 15| declare_integer("DT_NEEDED"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 904| 15| declare_integer("DT_PLTRELSZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 905| 15| declare_integer("DT_PLTGOT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 906| 15| declare_integer("DT_HASH"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 907| 15| declare_integer("DT_STRTAB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 908| 15| declare_integer("DT_SYMTAB"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 909| 15| declare_integer("DT_RELA"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 910| 15| declare_integer("DT_RELASZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 911| 15| declare_integer("DT_RELAENT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 912| 15| declare_integer("DT_STRSZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 913| 15| declare_integer("DT_SYMENT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 914| 15| declare_integer("DT_INIT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 915| 15| declare_integer("DT_FINI"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 916| 15| declare_integer("DT_SONAME"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 917| 15| declare_integer("DT_RPATH"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 918| 15| declare_integer("DT_SYMBOLIC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 919| 15| declare_integer("DT_REL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 920| 15| declare_integer("DT_RELSZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 921| 15| declare_integer("DT_RELENT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 922| 15| declare_integer("DT_PLTREL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 923| 15| declare_integer("DT_DEBUG"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 924| 15| declare_integer("DT_TEXTREL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 925| 15| declare_integer("DT_JMPREL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 926| 15| declare_integer("DT_BIND_NOW"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 927| 15| declare_integer("DT_INIT_ARRAY"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 928| 15| declare_integer("DT_FINI_ARRAY"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 929| 15| declare_integer("DT_INIT_ARRAYSZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 930| 15| declare_integer("DT_FINI_ARRAYSZ"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 931| 15| declare_integer("DT_RUNPATH"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 932| 15| declare_integer("DT_FLAGS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 933| 15| declare_integer("DT_ENCODING"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 934| | 935| 15| declare_integer("STT_NOTYPE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 936| 15| declare_integer("STT_OBJECT"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 937| 15| declare_integer("STT_FUNC"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 938| 15| declare_integer("STT_SECTION"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 939| 15| declare_integer("STT_FILE"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 940| 15| declare_integer("STT_COMMON"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 941| 15| declare_integer("STT_TLS"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 942| | 943| 15| declare_integer("STB_LOCAL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 944| 15| declare_integer("STB_GLOBAL"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 945| 15| declare_integer("STB_WEAK"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 946| | 947| 15| declare_integer("PF_X"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 948| 15| declare_integer("PF_W"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 949| 15| declare_integer("PF_R"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 950| | 951| 45| begin_struct_array("segments") ------------------ | | 80| 15| { \ | | 81| 15| YR_OBJECT* structure; \ | | 82| 15| YR_OBJECT* array; \ | | 83| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 84| 15| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 86| 15| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 15| assertf( \ | | ------------------ | | | | 164| 15| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 15] | | | | ------------------ | | | | 165| 15| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 15| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 15| "too many nested structures"); \ | | 90| 15| stack[++stack_top] = structure; \ | | 91| 15| } ------------------ 952| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 953| 15| declare_integer("flags"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 954| 15| declare_integer("offset"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 955| 15| declare_integer("virtual_address"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 956| 15| declare_integer("physical_address"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 957| 15| declare_integer("file_size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 958| 15| declare_integer("memory_size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 959| 15| declare_integer("alignment"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 960| 30| end_struct_array("segments") ------------------ | | 117| 15| end_struct \ | | ------------------ | | | | 108| 15| { \ | | | | 109| 15| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 15| assertf( \ | | | | ------------------ | | | | | | 164| 15| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 165| 15| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 15| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 15| "unbalanced begin_struct/end_struct"); \ | | | | 113| 15| stack_top--; \ | | | | 114| 15| } | | ------------------ | | 118| 15| (name) ------------------ 961| | 962| 15| declare_integer("dynamic_section_entries"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 963| 45| begin_struct_array("dynamic") ------------------ | | 80| 15| { \ | | 81| 15| YR_OBJECT* structure; \ | | 82| 15| YR_OBJECT* array; \ | | 83| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 84| 15| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 86| 15| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 15| assertf( \ | | ------------------ | | | | 164| 15| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 15] | | | | ------------------ | | | | 165| 15| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 15| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 15| "too many nested structures"); \ | | 90| 15| stack[++stack_top] = structure; \ | | 91| 15| } ------------------ 964| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 965| 15| declare_integer("val"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 966| 30| end_struct_array("dynamic") ------------------ | | 117| 15| end_struct \ | | ------------------ | | | | 108| 15| { \ | | | | 109| 15| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 15| assertf( \ | | | | ------------------ | | | | | | 164| 15| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 165| 15| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 15| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 15| "unbalanced begin_struct/end_struct"); \ | | | | 113| 15| stack_top--; \ | | | | 114| 15| } | | ------------------ | | 118| 15| (name) ------------------ 967| | 968| 15| declare_integer("symtab_entries"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 969| 45| begin_struct_array("symtab") ------------------ | | 80| 15| { \ | | 81| 15| YR_OBJECT* structure; \ | | 82| 15| YR_OBJECT* array; \ | | 83| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 84| 15| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 86| 15| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 15| assertf( \ | | ------------------ | | | | 164| 15| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 15] | | | | ------------------ | | | | 165| 15| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 15| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 15| "too many nested structures"); \ | | 90| 15| stack[++stack_top] = structure; \ | | 91| 15| } ------------------ 970| 15| declare_string("name"); ------------------ | | 169| 15| { \ | | 170| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 171| 15| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 15| } ------------------ 971| 15| declare_integer("value"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 972| 15| declare_integer("size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 973| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 974| 15| declare_integer("bind"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 975| 15| declare_integer("shndx"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 976| 30| end_struct_array("symtab") ------------------ | | 117| 15| end_struct \ | | ------------------ | | | | 108| 15| { \ | | | | 109| 15| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 15| assertf( \ | | | | ------------------ | | | | | | 164| 15| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 165| 15| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 15| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 15| "unbalanced begin_struct/end_struct"); \ | | | | 113| 15| stack_top--; \ | | | | 114| 15| } | | ------------------ | | 118| 15| (name) ------------------ 977| | 978| 15| declare_integer("dynsym_entries"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 979| 45| begin_struct_array("dynsym") ------------------ | | 80| 15| { \ | | 81| 15| YR_OBJECT* structure; \ | | 82| 15| YR_OBJECT* array; \ | | 83| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 84| 15| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 86| 15| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 15| assertf( \ | | ------------------ | | | | 164| 15| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 15] | | | | ------------------ | | | | 165| 15| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 15| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 15| "too many nested structures"); \ | | 90| 15| stack[++stack_top] = structure; \ | | 91| 15| } ------------------ 980| 15| declare_string("name"); ------------------ | | 169| 15| { \ | | 170| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 171| 15| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 15| } ------------------ 981| 15| declare_integer("value"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 982| 15| declare_integer("size"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 983| 15| declare_integer("type"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 984| 15| declare_integer("bind"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 985| 15| declare_integer("shndx"); ------------------ | | 125| 15| { \ | | 126| 15| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 127| 15| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 15| } ------------------ 986| 30| end_struct_array("dynsym") ------------------ | | 117| 15| end_struct \ | | ------------------ | | | | 108| 15| { \ | | | | 109| 15| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 15| assertf( \ | | | | ------------------ | | | | | | 164| 15| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 15] | | | | | | ------------------ | | | | | | 165| 15| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 15| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 15| "unbalanced begin_struct/end_struct"); \ | | | | 113| 15| stack_top--; \ | | | | 114| 15| } | | ------------------ | | 118| 15| (name) ------------------ 987| | 988| 15| declare_function("telfhash", "", "s", telfhash); ------------------ | | 191| 15| { \ | | 192| 15| YR_OBJECT* function; \ | | 193| 15| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 15| { \ | | | | 135| 15| int __error = (x); \ | | | | 136| 15| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 15|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 15] | | | | ------------------ | | | | 137| 15| return __error; \ | | | | 138| 15| } | | ------------------ | | 194| 15| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 15| } ------------------ 989| | 990| |#if defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) || \ 991| | defined(HAVE_COMMONCRYPTO_COMMONCRYPTO_H) 992| | declare_function("import_md5", "", "s", import_md5); 993| |#endif // defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) 994| | 995| 15|end_declarations ------------------ | | 65| 15| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 15|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 15| } ------------------ elf__initialize: 998| 2|{ 999| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 1000| 2|} macho__declarations: 1079| 7|begin_declarations ------------------ | | 59| 7| { \ | | 60| 7| YR_OBJECT* stack[64]; \ | | 61| 7| int stack_top = 0; \ | | 62| 7| stack[stack_top] = module; ------------------ 1080| | // Magic constants 1081| 7| declare_integer("MH_MAGIC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1082| 7| declare_integer("MH_CIGAM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1083| 7| declare_integer("MH_MAGIC_64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1084| 7| declare_integer("MH_CIGAM_64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1085| | 1086| | // Fat magic constants 1087| 7| declare_integer("FAT_MAGIC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1088| 7| declare_integer("FAT_CIGAM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1089| 7| declare_integer("FAT_MAGIC_64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1090| 7| declare_integer("FAT_CIGAM_64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1091| | 1092| | // 64-bit masks 1093| 7| declare_integer("CPU_ARCH_ABI64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1094| 7| declare_integer("CPU_SUBTYPE_LIB64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1095| | 1096| | // CPU types 1097| 7| declare_integer("CPU_TYPE_MC680X0"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1098| 7| declare_integer("CPU_TYPE_X86"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1099| 7| declare_integer("CPU_TYPE_I386"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1100| 7| declare_integer("CPU_TYPE_X86_64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1101| 7| declare_integer("CPU_TYPE_MIPS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1102| 7| declare_integer("CPU_TYPE_MC98000"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1103| 7| declare_integer("CPU_TYPE_ARM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1104| 7| declare_integer("CPU_TYPE_ARM64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1105| 7| declare_integer("CPU_TYPE_MC88000"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1106| 7| declare_integer("CPU_TYPE_SPARC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1107| 7| declare_integer("CPU_TYPE_POWERPC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1108| 7| declare_integer("CPU_TYPE_POWERPC64"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1109| | 1110| | // CPU sub-types 1111| 7| declare_integer("CPU_SUBTYPE_INTEL_MODEL_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1112| 7| declare_integer("CPU_SUBTYPE_386"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1113| 7| declare_integer("CPU_SUBTYPE_I386_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1114| 7| declare_integer("CPU_SUBTYPE_X86_64_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1115| 7| declare_integer("CPU_SUBTYPE_486"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1116| 7| declare_integer("CPU_SUBTYPE_486SX"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1117| 7| declare_integer("CPU_SUBTYPE_586"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1118| 7| declare_integer("CPU_SUBTYPE_PENT"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1119| 7| declare_integer("CPU_SUBTYPE_PENTPRO"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1120| 7| declare_integer("CPU_SUBTYPE_PENTII_M3"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1121| 7| declare_integer("CPU_SUBTYPE_PENTII_M5"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1122| 7| declare_integer("CPU_SUBTYPE_CELERON"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1123| 7| declare_integer("CPU_SUBTYPE_CELERON_MOBILE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1124| 7| declare_integer("CPU_SUBTYPE_PENTIUM_3"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1125| 7| declare_integer("CPU_SUBTYPE_PENTIUM_3_M"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1126| 7| declare_integer("CPU_SUBTYPE_PENTIUM_3_XEON"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1127| 7| declare_integer("CPU_SUBTYPE_PENTIUM_M"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1128| 7| declare_integer("CPU_SUBTYPE_PENTIUM_4"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1129| 7| declare_integer("CPU_SUBTYPE_PENTIUM_4_M"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1130| 7| declare_integer("CPU_SUBTYPE_ITANIUM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1131| 7| declare_integer("CPU_SUBTYPE_ITANIUM_2"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1132| 7| declare_integer("CPU_SUBTYPE_XEON"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1133| 7| declare_integer("CPU_SUBTYPE_XEON_MP"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1134| 7| declare_integer("CPU_SUBTYPE_ARM_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1135| 7| declare_integer("CPU_SUBTYPE_ARM_V4T"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1136| 7| declare_integer("CPU_SUBTYPE_ARM_V6"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1137| 7| declare_integer("CPU_SUBTYPE_ARM_V5"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1138| 7| declare_integer("CPU_SUBTYPE_ARM_V5TEJ"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1139| 7| declare_integer("CPU_SUBTYPE_ARM_XSCALE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1140| 7| declare_integer("CPU_SUBTYPE_ARM_V7"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1141| 7| declare_integer("CPU_SUBTYPE_ARM_V7F"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1142| 7| declare_integer("CPU_SUBTYPE_ARM_V7S"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1143| 7| declare_integer("CPU_SUBTYPE_ARM_V7K"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1144| 7| declare_integer("CPU_SUBTYPE_ARM_V6M"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1145| 7| declare_integer("CPU_SUBTYPE_ARM_V7M"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1146| 7| declare_integer("CPU_SUBTYPE_ARM_V7EM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1147| 7| declare_integer("CPU_SUBTYPE_ARM64_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1148| 7| declare_integer("CPU_SUBTYPE_SPARC_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1149| 7| declare_integer("CPU_SUBTYPE_POWERPC_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1150| 7| declare_integer("CPU_SUBTYPE_MC980000_ALL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1151| 7| declare_integer("CPU_SUBTYPE_POWERPC_601"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1152| 7| declare_integer("CPU_SUBTYPE_MC98601"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1153| 7| declare_integer("CPU_SUBTYPE_POWERPC_602"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1154| 7| declare_integer("CPU_SUBTYPE_POWERPC_603"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1155| 7| declare_integer("CPU_SUBTYPE_POWERPC_603e"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1156| 7| declare_integer("CPU_SUBTYPE_POWERPC_603ev"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1157| 7| declare_integer("CPU_SUBTYPE_POWERPC_604"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1158| 7| declare_integer("CPU_SUBTYPE_POWERPC_604e"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1159| 7| declare_integer("CPU_SUBTYPE_POWERPC_620"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1160| 7| declare_integer("CPU_SUBTYPE_POWERPC_750"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1161| 7| declare_integer("CPU_SUBTYPE_POWERPC_7400"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1162| 7| declare_integer("CPU_SUBTYPE_POWERPC_7450"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1163| 7| declare_integer("CPU_SUBTYPE_POWERPC_970"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1164| | 1165| | // File types 1166| 7| declare_integer("MH_OBJECT"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1167| 7| declare_integer("MH_EXECUTE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1168| 7| declare_integer("MH_FVMLIB"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1169| 7| declare_integer("MH_CORE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1170| 7| declare_integer("MH_PRELOAD"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1171| 7| declare_integer("MH_DYLIB"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1172| 7| declare_integer("MH_DYLINKER"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1173| 7| declare_integer("MH_BUNDLE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1174| 7| declare_integer("MH_DYLIB_STUB"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1175| 7| declare_integer("MH_DSYM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1176| 7| declare_integer("MH_KEXT_BUNDLE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1177| | 1178| | // Header flags 1179| 7| declare_integer("MH_NOUNDEFS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1180| 7| declare_integer("MH_INCRLINK"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1181| 7| declare_integer("MH_DYLDLINK"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1182| 7| declare_integer("MH_BINDATLOAD"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1183| 7| declare_integer("MH_PREBOUND"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1184| 7| declare_integer("MH_SPLIT_SEGS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1185| 7| declare_integer("MH_LAZY_INIT"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1186| 7| declare_integer("MH_TWOLEVEL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1187| 7| declare_integer("MH_FORCE_FLAT"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1188| 7| declare_integer("MH_NOMULTIDEFS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1189| 7| declare_integer("MH_NOFIXPREBINDING"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1190| 7| declare_integer("MH_PREBINDABLE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1191| 7| declare_integer("MH_ALLMODSBOUND"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1192| 7| declare_integer("MH_SUBSECTIONS_VIA_SYMBOLS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1193| 7| declare_integer("MH_CANONICAL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1194| 7| declare_integer("MH_WEAK_DEFINES"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1195| 7| declare_integer("MH_BINDS_TO_WEAK"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1196| 7| declare_integer("MH_ALLOW_STACK_EXECUTION"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1197| 7| declare_integer("MH_ROOT_SAFE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1198| 7| declare_integer("MH_SETUID_SAFE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1199| 7| declare_integer("MH_NO_REEXPORTED_DYLIBS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1200| 7| declare_integer("MH_PIE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1201| 7| declare_integer("MH_DEAD_STRIPPABLE_DYLIB"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1202| 7| declare_integer("MH_HAS_TLV_DESCRIPTORS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1203| 7| declare_integer("MH_NO_HEAP_EXECUTION"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1204| 7| declare_integer("MH_APP_EXTENSION_SAFE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1205| | 1206| | // Segment flags 1207| 7| declare_integer("SG_HIGHVM"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1208| 7| declare_integer("SG_FVMLIB"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1209| 7| declare_integer("SG_NORELOC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1210| 7| declare_integer("SG_PROTECTED_VERSION_1"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1211| | 1212| | // Section masks 1213| 7| declare_integer("SECTION_TYPE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1214| 7| declare_integer("SECTION_ATTRIBUTES"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1215| | 1216| | // Section types 1217| 7| declare_integer("S_REGULAR"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1218| 7| declare_integer("S_ZEROFILL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1219| 7| declare_integer("S_CSTRING_LITERALS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1220| 7| declare_integer("S_4BYTE_LITERALS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1221| 7| declare_integer("S_8BYTE_LITERALS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1222| 7| declare_integer("S_LITERAL_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1223| 7| declare_integer("S_NON_LAZY_SYMBOL_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1224| 7| declare_integer("S_LAZY_SYMBOL_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1225| 7| declare_integer("S_SYMBOL_STUBS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1226| 7| declare_integer("S_MOD_INIT_FUNC_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1227| 7| declare_integer("S_MOD_TERM_FUNC_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1228| 7| declare_integer("S_COALESCED"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1229| 7| declare_integer("S_GB_ZEROFILL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1230| 7| declare_integer("S_INTERPOSING"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1231| 7| declare_integer("S_16BYTE_LITERALS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1232| 7| declare_integer("S_DTRACE_DOF"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1233| 7| declare_integer("S_LAZY_DYLIB_SYMBOL_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1234| 7| declare_integer("S_THREAD_LOCAL_REGULAR"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1235| 7| declare_integer("S_THREAD_LOCAL_ZEROFILL"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1236| 7| declare_integer("S_THREAD_LOCAL_VARIABLES"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1237| 7| declare_integer("S_THREAD_LOCAL_VARIABLE_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1238| 7| declare_integer("S_THREAD_LOCAL_INIT_FUNCTION_POINTERS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1239| | 1240| | // Section attributes 1241| 7| declare_integer("S_ATTR_PURE_INSTRUCTIONS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1242| 7| declare_integer("S_ATTR_NO_TOC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1243| 7| declare_integer("S_ATTR_STRIP_STATIC_SYMS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1244| 7| declare_integer("S_ATTR_NO_DEAD_STRIP"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1245| 7| declare_integer("S_ATTR_LIVE_SUPPORT"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1246| 7| declare_integer("S_ATTR_SELF_MODIFYING_CODE"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1247| 7| declare_integer("S_ATTR_DEBUG"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1248| 7| declare_integer("S_ATTR_SOME_INSTRUCTIONS"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1249| 7| declare_integer("S_ATTR_EXT_RELOC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1250| 7| declare_integer("S_ATTR_LOC_RELOC"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1251| | 1252| | // Header 1253| 7| declare_integer("magic"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1254| 7| declare_integer("cputype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1255| 7| declare_integer("cpusubtype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1256| 7| declare_integer("filetype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1257| 7| declare_integer("ncmds"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1258| 7| declare_integer("sizeofcmds"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1259| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1260| 7| declare_integer("reserved"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1261| | 1262| | // Segments and nested sections 1263| 7| declare_integer("number_of_segments"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1264| | 1265| 21| begin_struct_array("segments") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1266| 7| declare_string("segname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1267| 7| declare_integer("vmaddr"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1268| 7| declare_integer("vmsize"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1269| 7| declare_integer("fileoff"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1270| 7| declare_integer("fsize"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1271| 7| declare_integer("maxprot"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1272| 7| declare_integer("initprot"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1273| 7| declare_integer("nsects"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1274| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1275| 21| begin_struct_array("sections") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1276| 7| declare_string("sectname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1277| 7| declare_string("segname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1278| 7| declare_integer("addr"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1279| 7| declare_integer("size"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1280| 7| declare_integer("offset"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1281| 7| declare_integer("align"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1282| 7| declare_integer("reloff"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1283| 7| declare_integer("nreloc"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1284| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1285| 7| declare_integer("reserved1"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1286| 7| declare_integer("reserved2"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1287| 7| declare_integer("reserved3"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1288| 14| end_struct_array("sections"); ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1289| 14| end_struct_array("segments") ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1290| | 1291| | // Entry point and stack size 1292| 7| declare_integer("entry_point"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1293| 7| declare_integer("stack_size"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1294| | 1295| | // Mach-O fat binary header 1296| 7| declare_integer("fat_magic"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1297| 7| declare_integer("nfat_arch"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1298| | 1299| 21| begin_struct_array("fat_arch") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1300| 7| declare_integer("cputype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1301| 7| declare_integer("cpusubtype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1302| 7| declare_integer("offset"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1303| 7| declare_integer("size"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1304| 7| declare_integer("align"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1305| 14| end_struct_array("fat_arch") ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1306| | 1307| | // Included Mach-O files (must be same as single file structure above) 1308| 21| begin_struct_array("file") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1309| | 1310| | // Single file header 1311| 7| declare_integer("magic"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1312| 7| declare_integer("cputype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1313| 7| declare_integer("cpusubtype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1314| 7| declare_integer("filetype"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1315| 7| declare_integer("ncmds"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1316| 7| declare_integer("sizeofcmds"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1317| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1318| 7| declare_integer("reserved"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1319| | 1320| | // Segments and nested sections 1321| 7| declare_integer("number_of_segments"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1322| | 1323| 21| begin_struct_array("segments") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1324| 7| declare_string("segname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1325| 7| declare_integer("vmaddr"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1326| 7| declare_integer("vmsize"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1327| 7| declare_integer("fileoff"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1328| 7| declare_integer("fsize"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1329| 7| declare_integer("maxprot"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1330| 7| declare_integer("initprot"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1331| 7| declare_integer("nsects"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1332| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1333| 21| begin_struct_array("sections") ------------------ | | 80| 7| { \ | | 81| 7| YR_OBJECT* structure; \ | | 82| 7| YR_OBJECT* array; \ | | 83| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 84| 7| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 86| 7| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 7| assertf( \ | | ------------------ | | | | 164| 7| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 7] | | | | ------------------ | | | | 165| 7| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 7| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 7| "too many nested structures"); \ | | 90| 7| stack[++stack_top] = structure; \ | | 91| 7| } ------------------ 1334| 7| declare_string("sectname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1335| 7| declare_string("segname"); ------------------ | | 169| 7| { \ | | 170| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 171| 7| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 7| } ------------------ 1336| 7| declare_integer("addr"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1337| 7| declare_integer("size"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1338| 7| declare_integer("offset"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1339| 7| declare_integer("align"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1340| 7| declare_integer("reloff"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1341| 7| declare_integer("nreloc"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1342| 7| declare_integer("flags"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1343| 7| declare_integer("reserved1"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1344| 7| declare_integer("reserved2"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1345| 7| declare_integer("reserved3"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1346| 14| end_struct_array("sections"); ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1347| 14| end_struct_array("segments") ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1348| | 1349| | // Entry point and stack size 1350| 7| declare_integer("entry_point"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1351| 7| declare_integer("stack_size"); ------------------ | | 125| 7| { \ | | 126| 7| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 127| 7| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 7| } ------------------ 1352| | 1353| 14| end_struct_array("file"); ------------------ | | 117| 7| end_struct \ | | ------------------ | | | | 108| 7| { \ | | | | 109| 7| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 7| assertf( \ | | | | ------------------ | | | | | | 164| 7| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 7] | | | | | | ------------------ | | | | | | 165| 7| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 7| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 7| "unbalanced begin_struct/end_struct"); \ | | | | 113| 7| stack_top--; \ | | | | 114| 7| } | | ------------------ | | 118| 7| (name) ------------------ 1354| | 1355| | // Mach-O fat binary helper functions 1356| 14| declare_function("file_index_for_arch", "i", "i", file_index_type); ------------------ | | 191| 7| { \ | | 192| 7| YR_OBJECT* function; \ | | 193| 7| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 194| 7| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 7| } ------------------ 1357| 7| declare_function("file_index_for_arch", "ii", "i", file_index_subtype); ------------------ | | 191| 7| { \ | | 192| 7| YR_OBJECT* function; \ | | 193| 7| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 194| 7| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 7| } ------------------ 1358| 7| declare_function("entry_point_for_arch", "i", "i", ep_for_arch_type); ------------------ | | 191| 7| { \ | | 192| 7| YR_OBJECT* function; \ | | 193| 7| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 194| 7| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 7| } ------------------ 1359| 7| declare_function("entry_point_for_arch", "ii", "i", ep_for_arch_subtype); ------------------ | | 191| 7| { \ | | 192| 7| YR_OBJECT* function; \ | | 193| 7| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 7| { \ | | | | 135| 7| int __error = (x); \ | | | | 136| 7| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 7|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 7] | | | | ------------------ | | | | 137| 7| return __error; \ | | | | 138| 7| } | | ------------------ | | 194| 7| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 7| } ------------------ 1360| 7|end_declarations ------------------ | | 65| 7| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 7|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 7| } ------------------ macho__initialize: 1363| 2|{ 1364| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 1365| 2|} math__declarations: 788| 6|begin_declarations ------------------ | | 59| 6| { \ | | 60| 6| YR_OBJECT* stack[64]; \ | | 61| 6| int stack_top = 0; \ | | 62| 6| stack[stack_top] = module; ------------------ 789| 6| declare_float("MEAN_BYTES"); ------------------ | | 147| 6| { \ | | 148| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 149| 6| yr_object_create(OBJECT_TYPE_FLOAT, name, stack[stack_top], NULL)); \ | | 150| 6| } ------------------ 790| 6| declare_function("in_range", "fff", "i", in_range); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 791| 6| declare_function("deviation", "iif", "f", data_deviation); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 792| 6| declare_function("deviation", "sf", "f", string_deviation); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 793| 6| declare_function("mean", "ii", "f", data_mean); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 794| 6| declare_function("mean", "s", "f", string_mean); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 795| 6| declare_function("serial_correlation", "ii", "f", data_serial_correlation); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 796| 6| declare_function("serial_correlation", "s", "f", string_serial_correlation); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 797| 6| declare_function("monte_carlo_pi", "ii", "f", data_monte_carlo_pi); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 798| 6| declare_function("monte_carlo_pi", "s", "f", string_monte_carlo_pi); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 799| 6| declare_function("entropy", "ii", "f", data_entropy); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 800| 6| declare_function("entropy", "s", "f", string_entropy); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 801| 6| declare_function("min", "ii", "i", min); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 802| 6| declare_function("max", "ii", "i", max); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 803| 6| declare_function("to_number", "b", "i", to_number); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 804| 6| declare_function("abs", "i", "i", yr_math_abs); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 805| 6| declare_function("count", "iii", "i", count_range); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 806| 6| declare_function("count", "i", "i", count_global); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 807| 6| declare_function("percentage", "iii", "f", percentage_range); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 808| 6| declare_function("percentage", "i", "f", percentage_global); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 809| 6| declare_function("mode", "ii", "i", mode_range); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 810| 6| declare_function("mode", "", "i", mode_global); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 811| 6| declare_function("to_string", "i", "s", to_string); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 812| 6| declare_function("to_string", "ii", "s", to_string_base); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 813| 6|end_declarations ------------------ | | 65| 6| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 6|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 6| } ------------------ math__initialize: 816| 2|{ 817| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 818| 2|} pe__declarations: 3527| 147|begin_declarations ------------------ | | 59| 147| { \ | | 60| 147| YR_OBJECT* stack[64]; \ | | 61| 147| int stack_top = 0; \ | | 62| 147| stack[stack_top] = module; ------------------ 3528| 147| declare_integer("MACHINE_UNKNOWN"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3529| 147| declare_integer("MACHINE_AM33"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3530| 147| declare_integer("MACHINE_AMD64"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3531| 147| declare_integer("MACHINE_ARM"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3532| 147| declare_integer("MACHINE_ARMNT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3533| 147| declare_integer("MACHINE_ARM64"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3534| 147| declare_integer("MACHINE_EBC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3535| 147| declare_integer("MACHINE_I386"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3536| 147| declare_integer("MACHINE_IA64"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3537| 147| declare_integer("MACHINE_M32R"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3538| 147| declare_integer("MACHINE_MIPS16"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3539| 147| declare_integer("MACHINE_MIPSFPU"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3540| 147| declare_integer("MACHINE_MIPSFPU16"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3541| 147| declare_integer("MACHINE_POWERPC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3542| 147| declare_integer("MACHINE_POWERPCFP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3543| 147| declare_integer("MACHINE_R4000"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3544| 147| declare_integer("MACHINE_SH3"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3545| 147| declare_integer("MACHINE_SH3DSP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3546| 147| declare_integer("MACHINE_SH4"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3547| 147| declare_integer("MACHINE_SH5"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3548| 147| declare_integer("MACHINE_THUMB"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3549| 147| declare_integer("MACHINE_WCEMIPSV2"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3550| 147| declare_integer("MACHINE_TARGET_HOST"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3551| 147| declare_integer("MACHINE_R3000"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3552| 147| declare_integer("MACHINE_R10000"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3553| 147| declare_integer("MACHINE_ALPHA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3554| 147| declare_integer("MACHINE_SH3E"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3555| 147| declare_integer("MACHINE_ALPHA64"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3556| 147| declare_integer("MACHINE_AXP64"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3557| 147| declare_integer("MACHINE_TRICORE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3558| 147| declare_integer("MACHINE_CEF"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3559| 147| declare_integer("MACHINE_CEE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3560| | 3561| 147| declare_integer("SUBSYSTEM_UNKNOWN"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3562| 147| declare_integer("SUBSYSTEM_NATIVE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3563| 147| declare_integer("SUBSYSTEM_WINDOWS_GUI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3564| 147| declare_integer("SUBSYSTEM_WINDOWS_CUI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3565| 147| declare_integer("SUBSYSTEM_OS2_CUI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3566| 147| declare_integer("SUBSYSTEM_POSIX_CUI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3567| 147| declare_integer("SUBSYSTEM_NATIVE_WINDOWS"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3568| 147| declare_integer("SUBSYSTEM_WINDOWS_CE_GUI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3569| 147| declare_integer("SUBSYSTEM_EFI_APPLICATION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3570| 147| declare_integer("SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3571| 147| declare_integer("SUBSYSTEM_EFI_RUNTIME_DRIVER"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3572| 147| declare_integer("SUBSYSTEM_EFI_ROM_IMAGE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3573| 147| declare_integer("SUBSYSTEM_XBOX"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3574| 147| declare_integer("SUBSYSTEM_WINDOWS_BOOT_APPLICATION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3575| | 3576| 147| declare_integer("HIGH_ENTROPY_VA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3577| 147| declare_integer("DYNAMIC_BASE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3578| 147| declare_integer("FORCE_INTEGRITY"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3579| 147| declare_integer("NX_COMPAT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3580| 147| declare_integer("NO_ISOLATION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3581| 147| declare_integer("NO_SEH"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3582| 147| declare_integer("NO_BIND"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3583| 147| declare_integer("APPCONTAINER"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3584| 147| declare_integer("WDM_DRIVER"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3585| 147| declare_integer("GUARD_CF"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3586| 147| declare_integer("TERMINAL_SERVER_AWARE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3587| | 3588| 147| declare_integer("RELOCS_STRIPPED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3589| 147| declare_integer("EXECUTABLE_IMAGE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3590| 147| declare_integer("LINE_NUMS_STRIPPED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3591| 147| declare_integer("LOCAL_SYMS_STRIPPED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3592| 147| declare_integer("AGGRESIVE_WS_TRIM"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3593| 147| declare_integer("LARGE_ADDRESS_AWARE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3594| 147| declare_integer("BYTES_REVERSED_LO"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3595| 147| declare_integer("MACHINE_32BIT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3596| 147| declare_integer("DEBUG_STRIPPED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3597| 147| declare_integer("REMOVABLE_RUN_FROM_SWAP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3598| 147| declare_integer("NET_RUN_FROM_SWAP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3599| 147| declare_integer("SYSTEM"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3600| 147| declare_integer("DLL"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3601| 147| declare_integer("UP_SYSTEM_ONLY"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3602| 147| declare_integer("BYTES_REVERSED_HI"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3603| | 3604| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_EXPORT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3605| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_IMPORT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3606| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_RESOURCE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3607| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_EXCEPTION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3608| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_SECURITY"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3609| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_BASERELOC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3610| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_DEBUG"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3611| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_ARCHITECTURE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3612| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_COPYRIGHT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3613| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_GLOBALPTR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3614| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_TLS"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3615| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3616| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3617| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_IAT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3618| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3619| 147| declare_integer("IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3620| | 3621| 147| declare_integer("IMAGE_NT_OPTIONAL_HDR32_MAGIC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3622| 147| declare_integer("IMAGE_NT_OPTIONAL_HDR64_MAGIC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3623| 147| declare_integer("IMAGE_ROM_OPTIONAL_HDR_MAGIC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3624| | 3625| 147| declare_integer("SECTION_NO_PAD"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3626| 147| declare_integer("SECTION_CNT_CODE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3627| 147| declare_integer("SECTION_CNT_INITIALIZED_DATA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3628| 147| declare_integer("SECTION_CNT_UNINITIALIZED_DATA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3629| 147| declare_integer("SECTION_LNK_OTHER"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3630| 147| declare_integer("SECTION_LNK_INFO"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3631| 147| declare_integer("SECTION_LNK_REMOVE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3632| 147| declare_integer("SECTION_LNK_COMDAT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3633| 147| declare_integer("SECTION_NO_DEFER_SPEC_EXC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3634| 147| declare_integer("SECTION_GPREL"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3635| 147| declare_integer("SECTION_MEM_FARDATA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3636| 147| declare_integer("SECTION_MEM_PURGEABLE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3637| 147| declare_integer("SECTION_MEM_16BIT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3638| 147| declare_integer("SECTION_MEM_LOCKED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3639| 147| declare_integer("SECTION_MEM_PRELOAD"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3640| 147| declare_integer("SECTION_ALIGN_1BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3641| 147| declare_integer("SECTION_ALIGN_2BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3642| 147| declare_integer("SECTION_ALIGN_4BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3643| 147| declare_integer("SECTION_ALIGN_8BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3644| 147| declare_integer("SECTION_ALIGN_16BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3645| 147| declare_integer("SECTION_ALIGN_32BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3646| 147| declare_integer("SECTION_ALIGN_64BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3647| 147| declare_integer("SECTION_ALIGN_128BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3648| 147| declare_integer("SECTION_ALIGN_256BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3649| 147| declare_integer("SECTION_ALIGN_512BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3650| 147| declare_integer("SECTION_ALIGN_1024BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3651| 147| declare_integer("SECTION_ALIGN_2048BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3652| 147| declare_integer("SECTION_ALIGN_4096BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3653| 147| declare_integer("SECTION_ALIGN_8192BYTES"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3654| 147| declare_integer("SECTION_ALIGN_MASK"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3655| 147| declare_integer("SECTION_LNK_NRELOC_OVFL"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3656| 147| declare_integer("SECTION_MEM_DISCARDABLE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3657| 147| declare_integer("SECTION_MEM_NOT_CACHED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3658| 147| declare_integer("SECTION_MEM_NOT_PAGED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3659| 147| declare_integer("SECTION_MEM_SHARED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3660| 147| declare_integer("SECTION_MEM_EXECUTE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3661| 147| declare_integer("SECTION_MEM_READ"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3662| 147| declare_integer("SECTION_MEM_WRITE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3663| 147| declare_integer("SECTION_SCALE_INDEX"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3664| | 3665| 147| declare_integer("RESOURCE_TYPE_CURSOR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3666| 147| declare_integer("RESOURCE_TYPE_BITMAP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3667| 147| declare_integer("RESOURCE_TYPE_ICON"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3668| 147| declare_integer("RESOURCE_TYPE_MENU"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3669| 147| declare_integer("RESOURCE_TYPE_DIALOG"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3670| 147| declare_integer("RESOURCE_TYPE_STRING"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3671| 147| declare_integer("RESOURCE_TYPE_FONTDIR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3672| 147| declare_integer("RESOURCE_TYPE_FONT"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3673| 147| declare_integer("RESOURCE_TYPE_ACCELERATOR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3674| 147| declare_integer("RESOURCE_TYPE_RCDATA"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3675| 147| declare_integer("RESOURCE_TYPE_MESSAGETABLE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3676| 147| declare_integer("RESOURCE_TYPE_GROUP_CURSOR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3677| 147| declare_integer("RESOURCE_TYPE_GROUP_ICON"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3678| 147| declare_integer("RESOURCE_TYPE_VERSION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3679| 147| declare_integer("RESOURCE_TYPE_DLGINCLUDE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3680| 147| declare_integer("RESOURCE_TYPE_PLUGPLAY"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3681| 147| declare_integer("RESOURCE_TYPE_VXD"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3682| 147| declare_integer("RESOURCE_TYPE_ANICURSOR"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3683| 147| declare_integer("RESOURCE_TYPE_ANIICON"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3684| 147| declare_integer("RESOURCE_TYPE_HTML"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3685| 147| declare_integer("RESOURCE_TYPE_MANIFEST"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3686| | 3687| 147| declare_integer("IMAGE_DEBUG_TYPE_UNKNOWN"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3688| 147| declare_integer("IMAGE_DEBUG_TYPE_COFF"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3689| 147| declare_integer("IMAGE_DEBUG_TYPE_CODEVIEW"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3690| 147| declare_integer("IMAGE_DEBUG_TYPE_FPO"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3691| 147| declare_integer("IMAGE_DEBUG_TYPE_MISC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3692| 147| declare_integer("IMAGE_DEBUG_TYPE_EXCEPTION"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3693| 147| declare_integer("IMAGE_DEBUG_TYPE_FIXUP"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3694| 147| declare_integer("IMAGE_DEBUG_TYPE_OMAP_TO_SRC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3695| 147| declare_integer("IMAGE_DEBUG_TYPE_OMAP_FROM_SRC"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3696| 147| declare_integer("IMAGE_DEBUG_TYPE_BORLAND"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3697| 147| declare_integer("IMAGE_DEBUG_TYPE_RESERVED10"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3698| 147| declare_integer("IMAGE_DEBUG_TYPE_CLSID"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3699| 147| declare_integer("IMAGE_DEBUG_TYPE_VC_FEATURE"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3700| 147| declare_integer("IMAGE_DEBUG_TYPE_POGO"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3701| 147| declare_integer("IMAGE_DEBUG_TYPE_ILTCG"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3702| 147| declare_integer("IMAGE_DEBUG_TYPE_MPX"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3703| 147| declare_integer("IMAGE_DEBUG_TYPE_REPRO"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3704| | 3705| 147| declare_integer("IMPORT_DELAYED"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3706| 147| declare_integer("IMPORT_STANDARD"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3707| 147| declare_integer("IMPORT_ANY"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3708| | 3709| 147| declare_integer("is_pe"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3710| 147| declare_integer("machine"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3711| 147| declare_integer("number_of_sections"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3712| 147| declare_integer("timestamp"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3713| 147| declare_integer("pointer_to_symbol_table"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3714| 147| declare_integer("number_of_symbols"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3715| 147| declare_integer("size_of_optional_header"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3716| 147| declare_integer("characteristics"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3717| | 3718| 147| declare_integer("entry_point"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3719| 147| declare_integer("entry_point_raw"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3720| 147| declare_integer("image_base"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3721| 147| declare_integer("number_of_rva_and_sizes"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3722| 147| declare_integer("number_of_version_infos"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3723| | 3724| 294| declare_string_dictionary("version_info"); ------------------ | | 183| 147| { \ | | 184| 147| YR_OBJECT* dict; \ | | 185| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 186| 147| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &dict)); \ | | 187| 147| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_STRING, name, dict, NULL)); \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 188| 147| } ------------------ 3725| | 3726| 441| begin_struct_array("version_info_list") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3727| 147| declare_string("key"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3728| 147| declare_string("value"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3729| 294| end_struct_array("version_info_list"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3730| | 3731| 294| declare_integer("opthdr_magic"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3732| 147| declare_integer("size_of_code"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3733| 147| declare_integer("size_of_initialized_data"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3734| 147| declare_integer("size_of_uninitialized_data"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3735| 147| declare_integer("base_of_code"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3736| 147| declare_integer("base_of_data"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3737| 147| declare_integer("section_alignment"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3738| 147| declare_integer("file_alignment"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3739| | 3740| 294| begin_struct("linker_version") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3741| 147| declare_integer("major"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3742| 147| declare_integer("minor"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3743| 294| end_struct("linker_version"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3744| | 3745| 294| begin_struct("os_version") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3746| 147| declare_integer("major"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3747| 147| declare_integer("minor"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3748| 294| end_struct("os_version"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3749| | 3750| 294| begin_struct("image_version") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3751| 147| declare_integer("major"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3752| 147| declare_integer("minor"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3753| 294| end_struct("image_version"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3754| | 3755| 294| begin_struct("subsystem_version") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3756| 147| declare_integer("major"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3757| 147| declare_integer("minor"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3758| 294| end_struct("subsystem_version"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3759| | 3760| 294| declare_integer("win32_version_value"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3761| 147| declare_integer("size_of_image"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3762| 147| declare_integer("size_of_headers"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3763| | 3764| 147| declare_integer("checksum"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3765| 147| declare_function("calculate_checksum", "", "i", calculate_checksum); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3766| 147| declare_integer("subsystem"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3767| | 3768| 147| declare_integer("dll_characteristics"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3769| 147| declare_integer("size_of_stack_reserve"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3770| 147| declare_integer("size_of_stack_commit"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3771| 147| declare_integer("size_of_heap_reserve"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3772| 147| declare_integer("size_of_heap_commit"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3773| 147| declare_integer("loader_flags"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3774| | 3775| 441| begin_struct_array("data_directories") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3776| 147| declare_integer("virtual_address"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3777| 147| declare_integer("size"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3778| 294| end_struct_array("data_directories"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3779| | 3780| 441| begin_struct_array("sections") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3781| 147| declare_string("name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3782| 147| declare_string("full_name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3783| 147| declare_integer("characteristics"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3784| 147| declare_integer("virtual_address"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3785| 147| declare_integer("virtual_size"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3786| 147| declare_integer("raw_data_offset"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3787| 147| declare_integer("raw_data_size"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3788| 147| declare_integer("pointer_to_relocations"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3789| 147| declare_integer("pointer_to_line_numbers"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3790| 147| declare_integer("number_of_relocations"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3791| 147| declare_integer("number_of_line_numbers"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3792| 294| end_struct_array("sections"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3793| | 3794| 294| begin_struct("overlay") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3795| 147| declare_integer("offset"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3796| 147| declare_integer("size"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3797| 294| end_struct("overlay"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3798| | 3799| 294| begin_struct("rich_signature") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3800| 147| declare_integer("offset"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3801| 147| declare_integer("length"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3802| 147| declare_integer("key"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3803| 147| declare_string("raw_data"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3804| 147| declare_string("clear_data"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3805| 147| declare_string("version_data"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3806| 147| declare_function("version", "i", "i", rich_version); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3807| 147| declare_function("version", "ii", "i", rich_version_toolid); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3808| 147| declare_function("toolid", "i", "i", rich_toolid); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3809| 147| declare_function("toolid", "ii", "i", rich_toolid_version); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3810| 294| end_struct("rich_signature"); ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3811| | 3812| |#if defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) || \ 3813| | defined(HAVE_COMMONCRYPTO_COMMONCRYPTO_H) 3814| | declare_function("imphash", "", "s", imphash); 3815| |#endif 3816| | 3817| 294| declare_function("section_index", "s", "i", section_index_name); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3818| 147| declare_function("section_index", "i", "i", section_index_addr); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3819| 147| declare_function("exports", "s", "i", exports); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3820| 147| declare_function("exports", "r", "i", exports_regexp); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3821| 147| declare_function("exports", "i", "i", exports_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3822| 147| declare_function("exports_index", "s", "i", exports_index_name); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3823| 147| declare_function("exports_index", "i", "i", exports_index_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3824| 147| declare_function("exports_index", "r", "i", exports_index_regex); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3825| 147| declare_function("imports", "ss", "i", imports_standard); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3826| 147| declare_function("imports", "si", "i", imports_standard_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3827| 147| declare_function("imports", "s", "i", imports_standard_dll); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3828| 147| declare_function("imports", "rr", "i", imports_standard_regex); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3829| 147| declare_function("imports", "iss", "i", imports); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3830| 147| declare_function("imports", "isi", "i", imports_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3831| 147| declare_function("imports", "is", "i", imports_dll); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3832| 147| declare_function("imports", "irr", "i", imports_regex); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3833| 147| declare_function("import_rva", "ss", "i", import_rva); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3834| 147| declare_function("import_rva", "si", "i", import_rva_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3835| 147| declare_function("delayed_import_rva", "ss", "i", delayed_import_rva); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3836| 147| declare_function("delayed_import_rva", "si", "i", delayed_import_rva_ordinal); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3837| 147| declare_function("locale", "i", "i", locale); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3838| 147| declare_function("language", "i", "i", language); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3839| 147| declare_function("is_dll", "", "i", is_dll); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3840| 147| declare_function("is_32bit", "", "i", is_32bit); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3841| 147| declare_function("is_64bit", "", "i", is_64bit); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3842| | 3843| 147| declare_integer("number_of_imports"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3844| 147| declare_integer("number_of_imported_functions"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3845| 147| declare_integer("number_of_delayed_imports"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3846| 147| declare_integer("number_of_delayed_imported_functions"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3847| 147| declare_integer("number_of_exports"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3848| | 3849| 147| declare_string("dll_name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3850| 147| declare_integer("export_timestamp"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3851| 441| begin_struct_array("export_details") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3852| 147| declare_integer("offset"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3853| 147| declare_string("name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3854| 147| declare_string("forward_name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3855| 147| declare_integer("ordinal"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3856| 147| declare_integer("rva"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3857| 294| end_struct_array("export_details") ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3858| | 3859| 441| begin_struct_array("import_details") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3860| 147| declare_string("library_name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3861| 147| declare_integer("number_of_functions"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3862| 441| begin_struct_array("functions") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3863| 147| declare_string("name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3864| 147| declare_integer("ordinal"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3865| 147| declare_integer("rva"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3866| 294| end_struct_array("functions"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3867| 294| end_struct_array("import_details"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3868| | 3869| 441| begin_struct_array("delayed_import_details") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3870| 147| declare_string("library_name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3871| 147| declare_integer("number_of_functions"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3872| 441| begin_struct_array("functions") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3873| 147| declare_string("name"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3874| 147| declare_integer("ordinal"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3875| 147| declare_integer("rva"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3876| 294| end_struct_array("functions"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3877| 294| end_struct_array("delayed_import_details"); ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3878| | 3879| 294| declare_integer("resource_timestamp"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3880| | 3881| 294| begin_struct("resource_version") ------------------ | | 69| 147| { \ | | 70| 147| YR_OBJECT* structure; \ | | 71| 147| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 72| 147| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 147| "too many nested structures"); \ | | 76| 147| stack[++stack_top] = structure; \ | | 77| 147| } ------------------ 3882| 147| declare_integer("major"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3883| 147| declare_integer("minor"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3884| 294| end_struct("resource_version") ------------------ | | 108| 147| { \ | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | 113| 147| stack_top--; \ | | 114| 147| } ------------------ 3885| | 3886| 441| begin_struct_array("resources") ------------------ | | 80| 147| { \ | | 81| 147| YR_OBJECT* structure; \ | | 82| 147| YR_OBJECT* array; \ | | 83| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 84| 147| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 86| 147| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 147| assertf( \ | | ------------------ | | | | 164| 147| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 147] | | | | ------------------ | | | | 165| 147| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 147| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 147| "too many nested structures"); \ | | 90| 147| stack[++stack_top] = structure; \ | | 91| 147| } ------------------ 3887| 147| declare_integer("rva"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3888| 147| declare_integer("offset"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3889| 147| declare_integer("length"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3890| 147| declare_integer("type"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3891| 147| declare_integer("id"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3892| 147| declare_integer("language"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3893| 147| declare_string("type_string"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3894| 147| declare_string("name_string"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3895| 147| declare_string("language_string"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3896| 294| end_struct_array("resources") ------------------ | | 117| 147| end_struct \ | | ------------------ | | | | 108| 147| { \ | | | | 109| 147| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 147| assertf( \ | | | | ------------------ | | | | | | 164| 147| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 147] | | | | | | ------------------ | | | | | | 165| 147| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 147| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 147| "unbalanced begin_struct/end_struct"); \ | | | | 113| 147| stack_top--; \ | | | | 114| 147| } | | ------------------ | | 118| 147| (name) ------------------ 3897| | 3898| 147| declare_integer("number_of_resources"); ------------------ | | 125| 147| { \ | | 126| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 127| 147| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 147| } ------------------ 3899| 147| declare_string("pdb_path"); ------------------ | | 169| 147| { \ | | 170| 147| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 171| 147| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 147| } ------------------ 3900| | 3901| |#if defined(HAVE_LIBCRYPTO) && !defined(BORINGSSL) 3902| | begin_struct_array("signatures") 3903| | declare_string("thumbprint"); 3904| | declare_string("issuer"); 3905| | declare_string("subject"); 3906| | declare_integer("version"); 3907| | declare_string("algorithm"); 3908| | declare_string("algorithm_oid"); 3909| | declare_string("serial"); 3910| | declare_integer("not_before"); 3911| | declare_integer("not_after"); 3912| | 3913| | declare_integer("verified"); 3914| | declare_string("digest_alg"); 3915| | declare_string("digest"); 3916| | declare_string("file_digest"); 3917| | declare_integer("number_of_certificates"); 3918| | begin_struct_array("certificates") 3919| | ; 3920| | declare_string("thumbprint"); 3921| | declare_string("issuer"); 3922| | declare_string("subject"); 3923| | declare_integer("version"); 3924| | declare_string("algorithm"); 3925| | declare_string("algorithm_oid"); 3926| | declare_string("serial"); 3927| | declare_integer("not_before"); 3928| | declare_integer("not_after"); 3929| | end_struct_array("certificates"); 3930| | 3931| | begin_struct("signer_info") 3932| | ; 3933| | declare_string("program_name"); 3934| | declare_string("digest"); 3935| | declare_string("digest_alg"); 3936| | declare_integer("length_of_chain"); 3937| | begin_struct_array("chain") 3938| | ; 3939| | declare_string("thumbprint"); 3940| | declare_string("issuer"); 3941| | declare_string("subject"); 3942| | declare_integer("version"); 3943| | declare_string("algorithm"); 3944| | declare_string("algorithm_oid"); 3945| | declare_string("serial"); 3946| | declare_integer("not_before"); 3947| | declare_integer("not_after"); 3948| | end_struct_array("chain"); 3949| | end_struct("signer_info"); 3950| | 3951| | declare_integer("number_of_countersignatures"); 3952| | begin_struct_array("countersignatures") 3953| | ; 3954| | declare_integer("verified"); 3955| | declare_integer("sign_time"); 3956| | declare_string("digest_alg"); 3957| | declare_string("digest"); 3958| | declare_integer("length_of_chain"); 3959| | begin_struct_array("chain") 3960| | ; 3961| | declare_string("thumbprint"); 3962| | declare_string("issuer"); 3963| | declare_string("subject"); 3964| | declare_integer("version"); 3965| | declare_string("algorithm"); 3966| | declare_string("algorithm_oid"); 3967| | declare_string("serial"); 3968| | declare_integer("not_before"); 3969| | declare_integer("not_after"); 3970| | end_struct_array("chain"); 3971| | end_struct_array("countersignatures") 3972| | 3973| | declare_function("valid_on", "i", "i", valid_on); 3974| | 3975| | end_struct_array("signatures") 3976| | 3977| | // If any of the signatures correctly signs the binary 3978| | declare_integer("is_signed"); 3979| | declare_integer("number_of_signatures"); 3980| |#endif 3981| | 3982| 147| declare_function("rva_to_offset", "i", "i", rva_to_offset); ------------------ | | 191| 147| { \ | | 192| 147| YR_OBJECT* function; \ | | 193| 147| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 147| { \ | | | | 135| 147| int __error = (x); \ | | | | 136| 147| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 147|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 147] | | | | ------------------ | | | | 137| 147| return __error; \ | | | | 138| 147| } | | ------------------ | | 194| 147| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 147| } ------------------ 3983| 147|end_declarations ------------------ | | 65| 147| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 147|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 147| } ------------------ pe__initialize: 3986| 2|{ 3987| |#if defined(HAVE_LIBCRYPTO) && !defined(BORINGSSL) 3988| | // Initialize OpenSSL global objects for the auth library before any 3989| | // multithreaded environment as it is not thread-safe. This can 3990| | // only be called once per process. 3991| | static bool s_initialized = false; 3992| | 3993| | if (!s_initialized) 3994| | { 3995| | s_initialized = true; 3996| | initialize_authenticode_parser(); 3997| | } 3998| |#endif 3999| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 4000| 2|} string__initialize: 103| 2|{ 104| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 105| 2|} tests__declarations: 104| 6|begin_declarations ------------------ | | 59| 6| { \ | | 60| 6| YR_OBJECT* stack[64]; \ | | 61| 6| int stack_top = 0; \ | | 62| 6| stack[stack_top] = module; ------------------ 105| 12| begin_struct("constants") ------------------ | | 69| 6| { \ | | 70| 6| YR_OBJECT* structure; \ | | 71| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 72| 6| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 74| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 6| "too many nested structures"); \ | | 76| 6| stack[++stack_top] = structure; \ | | 77| 6| } ------------------ 106| 6| declare_integer("one"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 107| 6| declare_integer("two"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 108| 6| declare_string("foo"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 109| 6| declare_string("empty"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 110| 12| end_struct("constants") ------------------ | | 108| 6| { \ | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | 113| 6| stack_top--; \ | | 114| 6| } ------------------ 111| | 112| 12| begin_struct("undefined") ------------------ | | 69| 6| { \ | | 70| 6| YR_OBJECT* structure; \ | | 71| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 72| 6| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 74| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 6| "too many nested structures"); \ | | 76| 6| stack[++stack_top] = structure; \ | | 77| 6| } ------------------ 113| 6| declare_integer("i"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 114| 6| declare_float("f"); ------------------ | | 147| 6| { \ | | 148| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 149| 6| yr_object_create(OBJECT_TYPE_FLOAT, name, stack[stack_top], NULL)); \ | | 150| 6| } ------------------ 115| 12| end_struct("undefined") ------------------ | | 108| 6| { \ | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | 113| 6| stack_top--; \ | | 114| 6| } ------------------ 116| | 117| 6| declare_string("module_data"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 118| 12| declare_integer_array("integer_array"); ------------------ | | 131| 6| { \ | | 132| 6| YR_OBJECT* array; \ | | 133| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 134| 6| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 135| 6| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_INTEGER, name, array, NULL)); \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 136| 6| } ------------------ 119| 12| declare_string_array("string_array"); ------------------ | | 175| 6| { \ | | 176| 6| YR_OBJECT* array; \ | | 177| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 178| 6| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 179| 6| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_STRING, name, array, NULL)); \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 180| 6| } ------------------ 120| | 121| 12| declare_integer_dictionary("integer_dict"); ------------------ | | 139| 6| { \ | | 140| 6| YR_OBJECT* dict; \ | | 141| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 142| 6| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &dict)); \ | | 143| 6| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_INTEGER, name, dict, NULL)); \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 144| 6| } ------------------ 122| 12| declare_string_dictionary("string_dict"); ------------------ | | 183| 6| { \ | | 184| 6| YR_OBJECT* dict; \ | | 185| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 186| 6| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &dict)); \ | | 187| 6| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_STRING, name, dict, NULL)); \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 188| 6| } ------------------ 123| | 124| 18| begin_struct_array("struct_array") ------------------ | | 80| 6| { \ | | 81| 6| YR_OBJECT* structure; \ | | 82| 6| YR_OBJECT* array; \ | | 83| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 84| 6| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 86| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 88| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 6| "too many nested structures"); \ | | 90| 6| stack[++stack_top] = structure; \ | | 91| 6| } ------------------ 125| 6| declare_integer("i"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 126| 6| declare_string("s"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 127| 12| end_struct_array("struct_array") ------------------ | | 117| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 118| 6| (name) ------------------ 128| | 129| 18| begin_struct_dictionary("struct_dict") ------------------ | | 94| 6| { \ | | 95| 6| YR_OBJECT* structure; \ | | 96| 6| YR_OBJECT* array; \ | | 97| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 98| 6| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &array)); \ | | 99| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 100| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 101| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 102| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 103| 6| "too many nested structures"); \ | | 104| 6| stack[++stack_top] = structure; \ | | 105| 6| } ------------------ 130| 6| declare_integer("i"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 131| 6| declare_string("s"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 132| 12| end_struct_dictionary("struct_dict"); ------------------ | | 121| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 122| 6| (name) ------------------ 133| | 134| 18| begin_struct_dictionary("empty_struct_dict") ------------------ | | 94| 6| { \ | | 95| 6| YR_OBJECT* structure; \ | | 96| 6| YR_OBJECT* array; \ | | 97| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 98| 6| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &array)); \ | | 99| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 100| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 101| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 102| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 103| 6| "too many nested structures"); \ | | 104| 6| stack[++stack_top] = structure; \ | | 105| 6| } ------------------ 135| 6| declare_integer("unused"); ------------------ | | 125| 6| { \ | | 126| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 127| 6| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 6| } ------------------ 136| 12| end_struct_dictionary("empty_struct_dict") ------------------ | | 121| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 122| 6| (name) ------------------ 137| | 138| 18| begin_struct_array("empty_struct_array") ------------------ | | 80| 6| { \ | | 81| 6| YR_OBJECT* structure; \ | | 82| 6| YR_OBJECT* array; \ | | 83| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 84| 6| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 86| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 88| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 6| "too many nested structures"); \ | | 90| 6| stack[++stack_top] = structure; \ | | 91| 6| } ------------------ 139| 18| begin_struct_array("struct_array") ------------------ | | 80| 6| { \ | | 81| 6| YR_OBJECT* structure; \ | | 82| 6| YR_OBJECT* array; \ | | 83| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 84| 6| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 86| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 88| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 6| "too many nested structures"); \ | | 90| 6| stack[++stack_top] = structure; \ | | 91| 6| } ------------------ 140| 6| declare_string("unused"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 141| 12| end_struct_array("struct_array"); ------------------ | | 117| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 118| 6| (name) ------------------ 142| 18| begin_struct_dictionary("struct_dict") ------------------ | | 94| 6| { \ | | 95| 6| YR_OBJECT* structure; \ | | 96| 6| YR_OBJECT* array; \ | | 97| 6| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 98| 6| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &array)); \ | | 99| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 100| 6| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 101| 6| assertf( \ | | ------------------ | | | | 127| 6| if (!(expr)) \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 6] | | | | ------------------ | | | | 128| 6| { \ | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 130| 0| abort(); \ | | | | 131| 0| } | | ------------------ | | 102| 6| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 103| 6| "too many nested structures"); \ | | 104| 6| stack[++stack_top] = structure; \ | | 105| 6| } ------------------ 143| 6| declare_string("unused"); ------------------ | | 169| 6| { \ | | 170| 6| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 171| 6| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 6| } ------------------ 144| 12| end_struct_dictionary("struct_dict"); ------------------ | | 121| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 122| 6| (name) ------------------ 145| 12| end_struct_array("empty_struct_array"); ------------------ | | 117| 6| end_struct \ | | ------------------ | | | | 108| 6| { \ | | | | 109| 6| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 6| assertf( \ | | | | ------------------ | | | | | | 127| 6| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (127:7): [True: 0, False: 6] | | | | | | ------------------ | | | | | | 128| 6| { \ | | | | | | 129| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 130| 0| abort(); \ | | | | | | 131| 0| } | | | | ------------------ | | | | 111| 6| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 6| "unbalanced begin_struct/end_struct"); \ | | | | 113| 6| stack_top--; \ | | | | 114| 6| } | | ------------------ | | 118| 6| (name) ------------------ 146| | 147| 12| declare_function("match", "rs", "i", match); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 148| 6| declare_function("isum", "ii", "i", isum_2); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 149| 6| declare_function("isum", "iii", "i", isum_3); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 150| 6| declare_function("fsum", "ff", "f", fsum_2); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 151| 6| declare_function("fsum", "fff", "f", fsum_3); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 152| 6| declare_function("length", "s", "i", length); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 153| 6| declare_function("empty", "", "s", empty); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 154| 6| declare_function("foobar", "i", "s", foobar); ------------------ | | 191| 6| { \ | | 192| 6| YR_OBJECT* function; \ | | 193| 6| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 6| { \ | | | | 135| 6| int __error = (x); \ | | | | 136| 6| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 6|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 6] | | | | ------------------ | | | | 137| 6| return __error; \ | | | | 138| 6| } | | ------------------ | | 194| 6| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 6| } ------------------ 155| 6|end_declarations ------------------ | | 65| 6| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 6|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 6| } ------------------ tests__initialize: 158| 2|{ 159| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 160| 2|} time__initialize: 51| 2|{ 52| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 53| 2|} yr_object_create: 56| 52.9k|{ 57| 52.9k| YR_OBJECT* obj; 58| 52.9k| size_t object_size = 0; 59| | 60| 52.9k| assert(parent != NULL || object != NULL); 61| 52.9k| assert(identifier != NULL); 62| | 63| 52.9k| switch (type) 64| 52.9k| { 65| 2.90k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 2.90k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (65:3): [True: 2.90k, False: 50.0k] ------------------ 66| 2.90k| object_size = sizeof(YR_OBJECT_STRUCTURE); 67| 2.90k| break; 68| 1.49k| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 1.49k|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (68:3): [True: 1.49k, False: 51.4k] ------------------ 69| 1.49k| object_size = sizeof(YR_OBJECT_ARRAY); 70| 1.49k| break; 71| 177| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 177|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (71:3): [True: 177, False: 52.7k] ------------------ 72| 177| object_size = sizeof(YR_OBJECT_DICTIONARY); 73| 177| break; 74| 42.9k| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 42.9k|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (74:3): [True: 42.9k, False: 9.97k] ------------------ 75| 42.9k| object_size = sizeof(YR_OBJECT); 76| 42.9k| break; 77| 54| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 54|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (77:3): [True: 54, False: 52.9k] ------------------ 78| 54| object_size = sizeof(YR_OBJECT); 79| 54| break; 80| 2.99k| case OBJECT_TYPE_STRING: ------------------ | | 59| 2.99k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (80:3): [True: 2.99k, False: 49.9k] ------------------ 81| 2.99k| object_size = sizeof(YR_OBJECT); 82| 2.99k| break; 83| 2.35k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2.35k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (83:3): [True: 2.35k, False: 50.6k] ------------------ 84| 2.35k| object_size = sizeof(YR_OBJECT_FUNCTION); 85| 2.35k| break; 86| 0| default: ------------------ | Branch (86:3): [True: 0, False: 52.9k] ------------------ 87| 0| assert(false); 88| 52.9k| } 89| | 90| 52.9k| obj = (YR_OBJECT*) yr_malloc(object_size); 91| | 92| 52.9k| if (obj == NULL) ------------------ | Branch (92:7): [True: 0, False: 52.9k] ------------------ 93| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 94| | 95| 52.9k| obj->type = type; 96| 52.9k| obj->identifier = yr_strdup(identifier); 97| 52.9k| obj->parent = parent; 98| 52.9k| obj->data = NULL; 99| | 100| 52.9k| switch (type) ------------------ | Branch (100:11): [True: 0, False: 52.9k] ------------------ 101| 52.9k| { 102| 42.9k| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 42.9k|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (102:3): [True: 42.9k, False: 9.97k] ------------------ 103| 42.9k| obj->value.i = YR_UNDEFINED; ------------------ | | 38| 42.9k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 104| 42.9k| break; 105| 54| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 54|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (105:3): [True: 54, False: 52.9k] ------------------ 106| 54| obj->value.d = NAN; 107| 54| break; 108| 2.99k| case OBJECT_TYPE_STRING: ------------------ | | 59| 2.99k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (108:3): [True: 2.99k, False: 49.9k] ------------------ 109| 2.99k| obj->value.ss = NULL; 110| 2.99k| break; 111| 2.90k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 2.90k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (111:3): [True: 2.90k, False: 50.0k] ------------------ 112| 2.90k| object_as_structure(obj)->members = NULL; ------------------ | | 909| 2.90k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 113| 2.90k| break; 114| 1.49k| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 1.49k|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (114:3): [True: 1.49k, False: 51.4k] ------------------ 115| 1.49k| object_as_array(obj)->items = NULL; ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 116| 1.49k| object_as_array(obj)->prototype_item = NULL; ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 117| 1.49k| break; 118| 177| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 177|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (118:3): [True: 177, False: 52.7k] ------------------ 119| 177| object_as_dictionary(obj)->items = NULL; ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 120| 177| object_as_dictionary(obj)->prototype_item = NULL; ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 121| 177| break; 122| 2.35k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2.35k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (122:3): [True: 2.35k, False: 50.6k] ------------------ 123| 2.35k| object_as_function(obj)->return_obj = NULL; ------------------ | | 912| 2.35k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 124| 25.9k| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 135| 25.9k|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (124:21): [True: 23.5k, False: 2.35k] ------------------ 125| 23.5k| { 126| 23.5k| object_as_function(obj)->prototypes[i].arguments_fmt = NULL; ------------------ | | 912| 23.5k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 127| 23.5k| object_as_function(obj)->prototypes[i].code = NULL; ------------------ | | 912| 23.5k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 128| 23.5k| } 129| 2.35k| break; 130| 52.9k| } 131| | 132| 52.9k| if (obj->identifier == NULL) ------------------ | Branch (132:7): [True: 0, False: 52.9k] ------------------ 133| 0| { 134| 0| yr_free(obj); 135| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 136| 0| } 137| | 138| 52.9k| if (parent != NULL) ------------------ | Branch (138:7): [True: 52.6k, False: 360] ------------------ 139| 52.6k| { 140| 52.6k| assert( 141| 52.6k| parent->type == OBJECT_TYPE_STRUCTURE || 142| 52.6k| parent->type == OBJECT_TYPE_ARRAY || 143| 52.6k| parent->type == OBJECT_TYPE_DICTIONARY || 144| 52.6k| parent->type == OBJECT_TYPE_FUNCTION); 145| | 146| | // Objects with a parent take the canary from it. 147| 52.6k| obj->canary = parent->canary; 148| | 149| 52.6k| switch (parent->type) ------------------ | Branch (149:13): [True: 0, False: 52.6k] ------------------ 150| 52.6k| { 151| 48.5k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 48.5k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (151:5): [True: 48.5k, False: 4.02k] ------------------ 152| 48.5k| FAIL_ON_ERROR_WITH_CLEANUP(yr_object_structure_set_member(parent, obj), { ------------------ | | 142| 48.5k| { \ | | 143| 48.5k| int __error = (x); \ | | 144| 48.5k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 48.5k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 48.5k] | | ------------------ | | 145| 48.5k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 48.5k| } ------------------ 153| 48.5k| yr_free((void*) obj->identifier); 154| 48.5k| yr_free(obj); 155| 48.5k| }); 156| 48.5k| break; 157| | 158| 1.49k| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 1.49k|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (158:5): [True: 1.49k, False: 51.1k] ------------------ 159| 1.49k| object_as_array(parent)->prototype_item = obj; ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 160| 1.49k| break; 161| | 162| 177| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 177|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (162:5): [True: 177, False: 52.4k] ------------------ 163| 177| object_as_dictionary(parent)->prototype_item = obj; ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 164| 177| break; 165| | 166| 2.35k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2.35k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (166:5): [True: 2.35k, False: 50.2k] ------------------ 167| 2.35k| object_as_function(parent)->return_obj = obj; ------------------ | | 912| 2.35k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 168| 2.35k| break; 169| 52.6k| } 170| 52.6k| } 171| | 172| 52.9k| if (object != NULL) ------------------ | Branch (172:7): [True: 9.28k, False: 43.6k] ------------------ 173| 9.28k| *object = obj; 174| | 175| 52.9k| return ERROR_SUCCESS; ------------------ | | 40| 52.9k|#define ERROR_SUCCESS 0 ------------------ 176| 52.9k|} yr_object_function_create: 190| 4.79k|{ 191| 4.79k| YR_OBJECT* return_obj; 192| 4.79k| YR_OBJECT* o = NULL; 193| 4.79k| YR_OBJECT_FUNCTION* f = NULL; 194| | 195| 4.79k| int8_t return_type; 196| | 197| | // The parent of a function must be a structure. 198| 4.79k| assert(parent != NULL && parent->type == OBJECT_TYPE_STRUCTURE); 199| | 200| 4.79k| switch (*return_fmt) 201| 4.79k| { 202| 4.67k| case 'i': ------------------ | Branch (202:3): [True: 4.67k, False: 123] ------------------ 203| 4.67k| return_type = OBJECT_TYPE_INTEGER; ------------------ | | 58| 4.67k|#define OBJECT_TYPE_INTEGER 1 ------------------ 204| 4.67k| break; 205| 39| case 's': ------------------ | Branch (205:3): [True: 39, False: 4.75k] ------------------ 206| 39| return_type = OBJECT_TYPE_STRING; ------------------ | | 59| 39|#define OBJECT_TYPE_STRING 2 ------------------ 207| 39| break; 208| 84| case 'f': ------------------ | Branch (208:3): [True: 84, False: 4.71k] ------------------ 209| 84| return_type = OBJECT_TYPE_FLOAT; ------------------ | | 64| 84|#define OBJECT_TYPE_FLOAT 7 ------------------ 210| 84| break; 211| 0| default: ------------------ | Branch (211:3): [True: 0, False: 4.79k] ------------------ 212| 0| return ERROR_INVALID_FORMAT; ------------------ | | 85| 0|#define ERROR_INVALID_FORMAT 38 ------------------ 213| 4.79k| } 214| | 215| | // Try to find if the structure already has a function 216| | // with that name. In that case this is a function overload. 217| 4.79k| f = object_as_function(yr_object_lookup_field(parent, identifier)); ------------------ | | 912| 4.79k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 218| | 219| | // Overloaded functions must have the same return type. 220| 4.79k| if (f != NULL && return_type != f->return_obj->type) ------------------ | Branch (220:7): [True: 2.44k, False: 2.35k] | Branch (220:20): [True: 0, False: 2.44k] ------------------ 221| 0| return ERROR_WRONG_RETURN_TYPE; ------------------ | | 88| 0|#define ERROR_WRONG_RETURN_TYPE 41 ------------------ 222| | 223| 4.79k| if (f == NULL) // Function doesn't exist yet ------------------ | Branch (223:7): [True: 2.35k, False: 2.44k] ------------------ 224| 2.35k| { 225| 2.35k| FAIL_ON_ERROR( ------------------ | | 134| 2.35k| { \ | | 135| 2.35k| int __error = (x); \ | | 136| 2.35k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.35k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2.35k] | | ------------------ | | 137| 2.35k| return __error; \ | | 138| 2.35k| } ------------------ 226| 2.35k| yr_object_create(OBJECT_TYPE_FUNCTION, identifier, parent, &o)); 227| | 228| | // In case of failure while creating return_obj we don't need to free the 229| | // previously created "o" object, as it is already associated with its 230| | // parent and will be destroyed when the parent is destroyed. 231| 2.35k| FAIL_ON_ERROR(yr_object_create(return_type, "result", o, &return_obj)); ------------------ | | 134| 2.35k| { \ | | 135| 2.35k| int __error = (x); \ | | 136| 2.35k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.35k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2.35k] | | ------------------ | | 137| 2.35k| return __error; \ | | 138| 2.35k| } ------------------ 232| | 233| 2.35k| f = object_as_function(o); ------------------ | | 912| 2.35k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 234| 2.35k| } 235| | 236| 10.6k| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 135| 10.6k|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (236:19): [True: 10.6k, False: 0] ------------------ 237| 10.6k| { 238| 10.6k| if (f->prototypes[i].arguments_fmt == NULL) ------------------ | Branch (238:9): [True: 4.79k, False: 5.82k] ------------------ 239| 4.79k| { 240| 4.79k| f->prototypes[i].arguments_fmt = arguments_fmt; 241| 4.79k| f->prototypes[i].code = code; 242| | 243| 4.79k| break; 244| 4.79k| } 245| 10.6k| } 246| | 247| 4.79k| if (function != NULL) ------------------ | Branch (247:7): [True: 4.79k, False: 0] ------------------ 248| 4.79k| *function = (YR_OBJECT*) f; 249| | 250| 4.79k| return ERROR_SUCCESS; ------------------ | | 40| 4.79k|#define ERROR_SUCCESS 0 ------------------ 251| 4.79k|} yr_object_destroy: 321| 52.9k|{ 322| 52.9k| YR_STRUCTURE_MEMBER* member; 323| 52.9k| YR_STRUCTURE_MEMBER* next_member; 324| 52.9k| YR_ARRAY_ITEMS* array_items; 325| 52.9k| YR_DICTIONARY_ITEMS* dict_items; 326| | 327| 52.9k| if (object == NULL) ------------------ | Branch (327:7): [True: 0, False: 52.9k] ------------------ 328| 0| return; 329| | 330| 52.9k| switch (object->type) ------------------ | Branch (330:11): [True: 43.0k, False: 9.92k] ------------------ 331| 52.9k| { 332| 2.90k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 2.90k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (332:3): [True: 2.90k, False: 50.0k] ------------------ 333| 2.90k| member = object_as_structure(object)->members; ------------------ | | 909| 2.90k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 334| | 335| 51.4k| while (member != NULL) ------------------ | Branch (335:12): [True: 48.5k, False: 2.90k] ------------------ 336| 48.5k| { 337| 48.5k| next_member = member->next; 338| 48.5k| yr_object_destroy(member->object); 339| 48.5k| yr_free(member); 340| 48.5k| member = next_member; 341| 48.5k| } 342| 2.90k| break; 343| | 344| 2.99k| case OBJECT_TYPE_STRING: ------------------ | | 59| 2.99k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (344:3): [True: 2.99k, False: 49.9k] ------------------ 345| 2.99k| if (object->value.ss != NULL) ------------------ | Branch (345:9): [True: 0, False: 2.99k] ------------------ 346| 0| yr_free(object->value.ss); 347| 2.99k| break; 348| | 349| 1.49k| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 1.49k|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (349:3): [True: 1.49k, False: 51.4k] ------------------ 350| 1.49k| if (object_as_array(object)->prototype_item != NULL) ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ | Branch (350:9): [True: 1.49k, False: 0] ------------------ 351| 1.49k| yr_object_destroy(object_as_array(object)->prototype_item); ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 352| | 353| 1.49k| array_items = object_as_array(object)->items; ------------------ | | 910| 1.49k|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 354| | 355| 1.49k| if (array_items != NULL) ------------------ | Branch (355:9): [True: 0, False: 1.49k] ------------------ 356| 0| { 357| 0| for (int i = 0; i < array_items->length; i++) ------------------ | Branch (357:23): [True: 0, False: 0] ------------------ 358| 0| if (array_items->objects[i] != NULL) ------------------ | Branch (358:13): [True: 0, False: 0] ------------------ 359| 0| yr_object_destroy(array_items->objects[i]); 360| 0| } 361| | 362| 1.49k| yr_free(array_items); 363| 1.49k| break; 364| | 365| 177| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 177|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (365:3): [True: 177, False: 52.7k] ------------------ 366| 177| if (object_as_dictionary(object)->prototype_item != NULL) ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ | Branch (366:9): [True: 177, False: 0] ------------------ 367| 177| yr_object_destroy(object_as_dictionary(object)->prototype_item); ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 368| | 369| 177| dict_items = object_as_dictionary(object)->items; ------------------ | | 911| 177|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 370| | 371| 177| if (dict_items != NULL) ------------------ | Branch (371:9): [True: 0, False: 177] ------------------ 372| 0| { 373| 0| for (int i = 0; i < dict_items->used; i++) ------------------ | Branch (373:23): [True: 0, False: 0] ------------------ 374| 0| { 375| 0| if (dict_items->objects[i].key != NULL) ------------------ | Branch (375:13): [True: 0, False: 0] ------------------ 376| 0| yr_free(dict_items->objects[i].key); 377| | 378| 0| if (dict_items->objects[i].obj != NULL) ------------------ | Branch (378:13): [True: 0, False: 0] ------------------ 379| 0| yr_object_destroy(dict_items->objects[i].obj); 380| 0| } 381| 0| } 382| | 383| 177| yr_free(dict_items); 384| 177| break; 385| | 386| 2.35k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2.35k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (386:3): [True: 2.35k, False: 50.6k] ------------------ 387| 2.35k| yr_object_destroy(object_as_function(object)->return_obj); ------------------ | | 912| 2.35k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 388| 2.35k| break; 389| 52.9k| } 390| | 391| 52.9k| yr_free((void*) object->identifier); 392| 52.9k| yr_free(object); 393| 52.9k|} yr_object_lookup_field: 396| 53.8k|{ 397| 53.8k| YR_STRUCTURE_MEMBER* member; 398| | 399| 53.8k| assert(object != NULL); 400| 53.8k| assert(object->type == OBJECT_TYPE_STRUCTURE); 401| | 402| 53.8k| member = object_as_structure(object)->members; ------------------ | | 909| 53.8k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 403| | 404| 4.97M| while (member != NULL) ------------------ | Branch (404:10): [True: 4.91M, False: 50.9k] ------------------ 405| 4.91M| { 406| 4.91M| if (strcmp(member->object->identifier, field_name) == 0) ------------------ | Branch (406:9): [True: 2.92k, False: 4.91M] ------------------ 407| 2.92k| return member->object; 408| | 409| 4.91M| member = member->next; 410| 4.91M| } 411| | 412| 50.9k| return NULL; 413| 53.8k|} yr_object_structure_set_member: 634| 48.5k|{ 635| 48.5k| YR_STRUCTURE_MEMBER* sm; 636| | 637| 48.5k| assert(object->type == OBJECT_TYPE_STRUCTURE); 638| | 639| | // Check if the object already have a member with the same identifier 640| | 641| 48.5k| if (yr_object_lookup_field(object, member->identifier) != NULL) ------------------ | Branch (641:7): [True: 0, False: 48.5k] ------------------ 642| 0| return ERROR_DUPLICATED_STRUCTURE_MEMBER; ------------------ | | 89| 0|#define ERROR_DUPLICATED_STRUCTURE_MEMBER 42 ------------------ 643| | 644| 48.5k| sm = (YR_STRUCTURE_MEMBER*) yr_malloc(sizeof(YR_STRUCTURE_MEMBER)); 645| | 646| 48.5k| if (sm == NULL) ------------------ | Branch (646:7): [True: 0, False: 48.5k] ------------------ 647| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 648| | 649| 48.5k| member->parent = object; 650| 48.5k| sm->object = member; 651| 48.5k| sm->next = object_as_structure(object)->members; ------------------ | | 909| 48.5k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 652| | 653| 48.5k| object_as_structure(object)->members = sm; ------------------ | | 909| 48.5k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 654| | 655| 48.5k| return ERROR_SUCCESS; ------------------ | | 40| 48.5k|#define ERROR_SUCCESS 0 ------------------ 656| 48.5k|} yr_parser_emit: 55| 100k|{ 56| 100k| return yr_arena_write_data( 57| 100k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 100k|#define yyget_extra yara_yyget_extra ------------------ 58| 100k| YR_CODE_SECTION, ------------------ | | 63| 100k|#define YR_CODE_SECTION 6 ------------------ 59| 100k| &instruction, 60| 100k| sizeof(uint8_t), 61| 100k| instruction_ref); 62| 100k|} yr_parser_emit_with_arg_double: 70| 3.75k|{ 71| 3.75k| int result = yr_arena_write_data( 72| 3.75k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 3.75k|#define yyget_extra yara_yyget_extra ------------------ 73| 3.75k| YR_CODE_SECTION, ------------------ | | 63| 3.75k|#define YR_CODE_SECTION 6 ------------------ 74| 3.75k| &instruction, 75| 3.75k| sizeof(uint8_t), 76| 3.75k| instruction_ref); 77| | 78| 3.75k| if (result == ERROR_SUCCESS) ------------------ | | 40| 3.75k|#define ERROR_SUCCESS 0 ------------------ | Branch (78:7): [True: 3.75k, False: 0] ------------------ 79| 3.75k| result = yr_arena_write_data( 80| 3.75k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 3.75k|#define yyget_extra yara_yyget_extra ------------------ 81| 3.75k| YR_CODE_SECTION, ------------------ | | 63| 3.75k|#define YR_CODE_SECTION 6 ------------------ 82| 3.75k| &argument, 83| 3.75k| sizeof(double), 84| 3.75k| argument_ref); 85| | 86| 3.75k| return result; 87| 3.75k|} yr_parser_emit_with_arg_int32: 95| 22.6k|{ 96| 22.6k| int result = yr_arena_write_data( 97| 22.6k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 22.6k|#define yyget_extra yara_yyget_extra ------------------ 98| 22.6k| YR_CODE_SECTION, ------------------ | | 63| 22.6k|#define YR_CODE_SECTION 6 ------------------ 99| 22.6k| &instruction, 100| 22.6k| sizeof(uint8_t), 101| 22.6k| instruction_ref); 102| | 103| 22.6k| if (result == ERROR_SUCCESS) ------------------ | | 40| 22.6k|#define ERROR_SUCCESS 0 ------------------ | Branch (103:7): [True: 22.6k, False: 0] ------------------ 104| 22.6k| result = yr_arena_write_data( 105| 22.6k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 22.6k|#define yyget_extra yara_yyget_extra ------------------ 106| 22.6k| YR_CODE_SECTION, ------------------ | | 63| 22.6k|#define YR_CODE_SECTION 6 ------------------ 107| 22.6k| &argument, 108| 22.6k| sizeof(int32_t), 109| 22.6k| argument_ref); 110| | 111| 22.6k| return result; 112| 22.6k|} yr_parser_emit_with_arg: 120| 46.2k|{ 121| 46.2k| int result = yr_arena_write_data( 122| 46.2k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 46.2k|#define yyget_extra yara_yyget_extra ------------------ 123| 46.2k| YR_CODE_SECTION, ------------------ | | 63| 46.2k|#define YR_CODE_SECTION 6 ------------------ 124| 46.2k| &instruction, 125| 46.2k| sizeof(uint8_t), 126| 46.2k| instruction_ref); 127| | 128| 46.2k| if (result == ERROR_SUCCESS) ------------------ | | 40| 46.2k|#define ERROR_SUCCESS 0 ------------------ | Branch (128:7): [True: 46.2k, False: 0] ------------------ 129| 46.2k| result = yr_arena_write_data( 130| 46.2k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 46.2k|#define yyget_extra yara_yyget_extra ------------------ 131| 46.2k| YR_CODE_SECTION, ------------------ | | 63| 46.2k|#define YR_CODE_SECTION 6 ------------------ 132| 46.2k| &argument, 133| 46.2k| sizeof(int64_t), 134| 46.2k| argument_ref); 135| | 136| 46.2k| return result; 137| 46.2k|} yr_parser_emit_with_arg_reloc: 145| 749k|{ 146| 749k| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 749k| (YR_ARENA_REF) \ | | 44| 749k| { \ | | 45| 749k| UINT32_MAX, UINT32_MAX \ | | 46| 749k| } ------------------ 147| | 148| 749k| DECLARE_REFERENCE(void*, ptr) arg; ------------------ | | 45| 749k| union \ | | 46| 749k| { \ | | 47| 749k| type name; \ | | 48| 749k| YR_ARENA_REF name##_; \ | | 49| 749k| } YR_ALIGN(8) ------------------ 149| | 150| 749k| memset(&arg, 0, sizeof(arg)); 151| 749k| arg.ptr = argument; 152| | 153| 749k| int result = yr_arena_write_data( 154| 749k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 749k|#define yyget_extra yara_yyget_extra ------------------ 155| 749k| YR_CODE_SECTION, ------------------ | | 63| 749k|#define YR_CODE_SECTION 6 ------------------ 156| 749k| &instruction, 157| 749k| sizeof(uint8_t), 158| 749k| instruction_ref); 159| | 160| 749k| if (result == ERROR_SUCCESS) ------------------ | | 40| 749k|#define ERROR_SUCCESS 0 ------------------ | Branch (160:7): [True: 749k, False: 0] ------------------ 161| 749k| result = yr_arena_write_data( 162| 749k| yyget_extra(yyscanner)->arena, ------------------ | | 54| 749k|#define yyget_extra yara_yyget_extra ------------------ 163| 749k| YR_CODE_SECTION, ------------------ | | 63| 749k|#define YR_CODE_SECTION 6 ------------------ 164| 749k| &arg, 165| 749k| sizeof(arg), 166| 749k| &ref); 167| | 168| 749k| if (result == ERROR_SUCCESS) ------------------ | | 40| 749k|#define ERROR_SUCCESS 0 ------------------ | Branch (168:7): [True: 749k, False: 0] ------------------ 169| 749k| result = yr_arena_make_ptr_relocatable( 170| 749k| yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 54| 749k|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 63| 749k|#define YR_CODE_SECTION 6 ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 38| 749k|#define EOL ((size_t) -1) ------------------ 171| | 172| 749k| if (argument_ref != NULL) ------------------ | Branch (172:7): [True: 0, False: 749k] ------------------ 173| 0| *argument_ref = ref; 174| | 175| 749k| return result; 176| 749k|} yr_parser_emit_pushes_for_strings: 182| 11.3k|{ 183| 11.3k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 11.3k|#define yyget_extra yara_yyget_extra ------------------ 184| | 185| 11.3k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 186| 11.3k| compiler, compiler->current_rule_idx); 187| | 188| 11.3k| YR_STRING* string; 189| | 190| 11.3k| const char* string_identifier; 191| 11.3k| const char* target_identifier; 192| | 193| 11.3k| int matching = 0; 194| | 195| 11.3k| yr_rule_strings_foreach(current_rule, string) ------------------ | | 60| 760k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 749k, False: 11.3k] | | ------------------ | | 61| 749k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 749k|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 749k|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 11.3k, False: 737k] | | | | ------------------ | | ------------------ ------------------ 196| 749k| { 197| | // Don't generate pushes for strings chained to another one, we are 198| | // only interested in non-chained strings or the head of the chain. 199| | 200| 749k| if (string->chained_to == NULL) ------------------ | Branch (200:9): [True: 745k, False: 3.77k] ------------------ 201| 745k| { 202| 745k| string_identifier = string->identifier; 203| 745k| target_identifier = identifier; 204| | 205| 1.49M| while (*target_identifier != '\0' && *string_identifier != '\0' && ------------------ | Branch (205:14): [True: 748k, False: 742k] | Branch (205:44): [True: 745k, False: 2.62k] ------------------ 206| 1.49M| *target_identifier == *string_identifier) ------------------ | Branch (206:14): [True: 745k, False: 318] ------------------ 207| 745k| { 208| 745k| target_identifier++; 209| 745k| string_identifier++; 210| 745k| } 211| | 212| 745k| if ((*target_identifier == '\0' && *string_identifier == '\0') || ------------------ | Branch (212:12): [True: 742k, False: 2.93k] | Branch (212:42): [True: 737k, False: 5.44k] ------------------ 213| 745k| *target_identifier == '*') ------------------ | Branch (213:11): [True: 2.69k, False: 5.69k] ------------------ 214| 739k| { 215| 739k| yr_parser_emit_with_arg_reloc(yyscanner, OP_PUSH, string, NULL, NULL); ------------------ | | 61| 739k|#define OP_PUSH 13 ------------------ 216| | 217| 739k| string->flags |= STRING_FLAGS_REFERENCED; ------------------ | | 66| 739k|#define STRING_FLAGS_REFERENCED 0x01 ------------------ 218| 739k| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 739k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 219| 739k| string->flags &= ~STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 739k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 220| 739k| matching++; 221| 739k| } 222| 745k| } 223| 749k| } 224| | 225| 11.3k| if (count != NULL) ------------------ | Branch (225:7): [True: 11.3k, False: 0] ------------------ 226| 11.3k| { 227| 11.3k| *count = matching; 228| 11.3k| } 229| | 230| 11.3k| if (matching == 0) ------------------ | Branch (230:7): [True: 18, False: 11.3k] ------------------ 231| 18| { 232| 18| yr_compiler_set_error_extra_info( ------------------ | | 306| 18| strlcpy( \ | | 307| 18| compiler->last_error_extra_info, \ | | 308| 18| info, \ | | 309| 18| sizeof(compiler->last_error_extra_info)); ------------------ 233| 18| compiler, identifier) return ERROR_UNDEFINED_STRING; ------------------ | | 64| 18|#define ERROR_UNDEFINED_STRING 19 ------------------ 234| 18| } 235| | 236| 11.3k| return ERROR_SUCCESS; ------------------ | | 40| 11.3k|#define ERROR_SUCCESS 0 ------------------ 237| 11.3k|} yr_parser_emit_pushes_for_rules: 245| 1.17k|{ 246| 1.17k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 1.17k|#define yyget_extra yara_yyget_extra ------------------ 247| | 248| | // Make sure the compiler is parsing a rule 249| 1.17k| assert(compiler->current_rule_idx != UINT32_MAX); 250| | 251| 1.17k| YR_RULE* rule; 252| 1.17k| int matching = 0; 253| | 254| 1.17k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 255| 1.17k| compiler->arena, 256| 1.17k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.17k|#define YR_NAMESPACES_TABLE 0 ------------------ 257| 1.17k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 258| | 259| | // Can't use yr_rules_foreach here as that requires the rules to have been 260| | // finalized (inserting a NULL rule at the end). This is done when 261| | // yr_compiler_get_rules() is called, which also inserts a HALT instruction 262| | // into the current position in the code arena. Obviously we aren't done 263| | // compiling the rules yet so inserting a HALT is a bad idea. To deal with 264| | // this I'm manually walking all the currently compiled rules (up to the 265| | // current rule index) and comparing identifiers to see if it is one we should 266| | // use. 267| | // 268| | // Further, we have to get compiler->current_rule_idx before we start because 269| | // if we emit an OP_PUSH_RULE 270| 1.17k| rule = yr_arena_get_ptr(compiler->arena, YR_RULES_TABLE, 0); ------------------ | | 58| 1.17k|#define YR_RULES_TABLE 1 ------------------ 271| | 272| 3.95k| for (uint32_t i = 0; i <= compiler->current_rule_idx; i++) ------------------ | Branch (272:24): [True: 2.78k, False: 1.17k] ------------------ 273| 2.78k| { 274| | // Is rule->identifier prefixed by prefix? 275| 2.78k| if (strncmp(prefix, rule->identifier, strlen(prefix)) == 0) ------------------ | Branch (275:9): [True: 1.25k, False: 1.52k] ------------------ 276| 1.25k| { 277| 1.25k| uint32_t rule_idx = yr_hash_table_lookup_uint32( 278| 1.25k| compiler->rules_table, rule->identifier, ns->name); 279| | 280| 1.25k| if (rule_idx != UINT32_MAX) ------------------ | Branch (280:11): [True: 1.25k, False: 0] ------------------ 281| 1.25k| { 282| 1.25k| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 134| 1.25k| { \ | | 135| 1.25k| int __error = (x); \ | | 136| 1.25k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.25k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.25k] | | ------------------ | | 137| 1.25k| return __error; \ | | 138| 1.25k| } ------------------ 283| 1.25k| yyscanner, OP_PUSH_RULE, rule_idx, NULL, NULL)); 284| 1.25k| matching++; 285| 1.25k| } 286| 1.25k| } 287| | 288| 2.78k| rule++; 289| 2.78k| } 290| | 291| 1.17k| if (count != NULL) ------------------ | Branch (291:7): [True: 1.17k, False: 0] ------------------ 292| 1.17k| { 293| 1.17k| *count = matching; 294| 1.17k| } 295| | 296| 1.17k| if (matching == 0) ------------------ | Branch (296:7): [True: 84, False: 1.08k] ------------------ 297| 84| { 298| 84| yr_compiler_set_error_extra_info(compiler, prefix); ------------------ | | 306| 84| strlcpy( \ | | 307| 84| compiler->last_error_extra_info, \ | | 308| 84| info, \ | | 309| 84| sizeof(compiler->last_error_extra_info)); ------------------ 299| 84| return ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 84|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 300| 84| } 301| | 302| 1.08k| return ERROR_SUCCESS; ------------------ | | 40| 1.08k|#define ERROR_SUCCESS 0 ------------------ 303| 1.17k|} yr_parser_emit_push_const: 306| 68.2k|{ 307| 68.2k| uint8_t opcode[9]; 308| 68.2k| int opcode_len = 1; 309| | 310| 68.2k| if (argument == YR_UNDEFINED) ------------------ | | 38| 68.2k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (310:7): [True: 12.7k, False: 55.4k] ------------------ 311| 12.7k| { 312| 12.7k| opcode[0] = OP_PUSH_U; ------------------ | | 114| 12.7k|#define OP_PUSH_U 66 ------------------ 313| 12.7k| } 314| 55.4k| else if (argument <= 0xff) ------------------ | Branch (314:12): [True: 51.4k, False: 4.04k] ------------------ 315| 51.4k| { 316| 51.4k| opcode[0] = OP_PUSH_8; ------------------ | | 111| 51.4k|#define OP_PUSH_8 63 ------------------ 317| 51.4k| opcode[1] = (uint8_t) argument; 318| 51.4k| opcode_len += sizeof(uint8_t); 319| 51.4k| } 320| 4.04k| else if (argument <= 0xffff) ------------------ | Branch (320:12): [True: 2.11k, False: 1.93k] ------------------ 321| 2.11k| { 322| 2.11k| opcode[0] = OP_PUSH_16; ------------------ | | 112| 2.11k|#define OP_PUSH_16 64 ------------------ 323| 2.11k| uint16_t u = (uint16_t) argument; 324| 2.11k| memcpy(opcode + 1, &u, sizeof(uint16_t)); 325| 2.11k| opcode_len += sizeof(uint16_t); 326| 2.11k| } 327| 1.93k| else if (argument <= 0xffffffff) ------------------ | Branch (327:12): [True: 1.25k, False: 675] ------------------ 328| 1.25k| { 329| 1.25k| opcode[0] = OP_PUSH_32; ------------------ | | 113| 1.25k|#define OP_PUSH_32 65 ------------------ 330| 1.25k| uint32_t u = (uint32_t) argument; 331| 1.25k| memcpy(opcode + 1, &u, sizeof(uint32_t)); 332| 1.25k| opcode_len += sizeof(uint32_t); 333| 1.25k| } 334| 675| else 335| 675| { 336| 675| opcode[0] = OP_PUSH; ------------------ | | 61| 675|#define OP_PUSH 13 ------------------ 337| 675| memcpy(opcode + 1, &argument, sizeof(uint64_t)); 338| 675| opcode_len += sizeof(uint64_t); 339| 675| } 340| | 341| 68.2k| return yr_arena_write_data( 342| 68.2k| yyget_extra(yyscanner)->arena, YR_CODE_SECTION, opcode, opcode_len, NULL); ------------------ | | 54| 68.2k|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, opcode, opcode_len, NULL); ------------------ | | 63| 68.2k|#define YR_CODE_SECTION 6 ------------------ 343| 68.2k|} yr_parser_check_types: 349| 11|{ 350| 11| int i; 351| | 352| 50| for (i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 135| 50|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (352:15): [True: 50, False: 0] ------------------ 353| 50| { 354| 50| if (function->prototypes[i].arguments_fmt == NULL) ------------------ | Branch (354:9): [True: 5, False: 45] ------------------ 355| 5| break; 356| | 357| 45| if (strcmp(function->prototypes[i].arguments_fmt, actual_args_fmt) == 0) ------------------ | Branch (357:9): [True: 6, False: 39] ------------------ 358| 6| return ERROR_SUCCESS; ------------------ | | 40| 6|#define ERROR_SUCCESS 0 ------------------ 359| 45| } 360| | 361| 5| yr_compiler_set_error_extra_info(compiler, function->identifier) ------------------ | | 306| 5| strlcpy( \ | | 307| 5| compiler->last_error_extra_info, \ | | 308| 5| info, \ | | 309| 5| sizeof(compiler->last_error_extra_info)); ------------------ 362| | 363| 5| return ERROR_WRONG_ARGUMENTS; ------------------ | | 87| 5|#define ERROR_WRONG_ARGUMENTS 40 ------------------ 364| 11|} yr_parser_lookup_string: 370| 2.20k|{ 371| 2.20k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 2.20k|#define yyget_extra yara_yyget_extra ------------------ 372| | 373| 2.20k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 374| 2.20k| compiler, compiler->current_rule_idx); 375| | 376| 2.20k| yr_rule_strings_foreach(current_rule, *string) ------------------ | | 60| 3.13k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 3.09k, False: 40] | | ------------------ | | 61| 2.20k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 928|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 928|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 30, False: 898] | | | | ------------------ | | ------------------ ------------------ 377| 3.09k| { 378| | // If some string $a gets fragmented into multiple chained 379| | // strings, all those fragments have the same $a identifier 380| | // but we are interested in the heading fragment, which is 381| | // that with chained_to == NULL 382| | 383| 3.09k| if ((*string)->chained_to == NULL && ------------------ | Branch (383:9): [True: 2.92k, False: 164] ------------------ 384| 3.09k| strcmp((*string)->identifier, identifier) == 0) ------------------ | Branch (384:9): [True: 2.16k, False: 764] ------------------ 385| 2.16k| { 386| 2.16k| return ERROR_SUCCESS; ------------------ | | 40| 2.16k|#define ERROR_SUCCESS 0 ------------------ 387| 2.16k| } 388| 3.09k| } 389| | 390| 40| yr_compiler_set_error_extra_info(compiler, identifier) ------------------ | | 306| 40| strlcpy( \ | | 307| 40| compiler->last_error_extra_info, \ | | 308| 40| info, \ | | 309| 40| sizeof(compiler->last_error_extra_info)); ------------------ 391| | 392| 40| * string = NULL; 393| | 394| 40| return ERROR_UNDEFINED_STRING; ------------------ | | 64| 40|#define ERROR_UNDEFINED_STRING 19 ------------------ 395| 2.20k|} yr_parser_lookup_loop_variable: 416| 17.7k|{ 417| 17.7k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 17.7k|#define yyget_extra yara_yyget_extra ------------------ 418| 17.7k| int i, j; 419| 17.7k| int var_offset = 0; 420| | 421| 22.1k| for (i = 0; i <= compiler->loop_index; i++) ------------------ | Branch (421:15): [True: 12.3k, False: 9.73k] ------------------ 422| 12.3k| { 423| 12.3k| var_offset += compiler->loop[i].vars_internal_count; 424| | 425| 20.3k| for (j = 0; j < compiler->loop[i].vars_count; j++) ------------------ | Branch (425:17): [True: 16.0k, False: 4.33k] ------------------ 426| 16.0k| { 427| 16.0k| if (compiler->loop[i].vars[j].identifier.ptr != NULL && ------------------ | Branch (427:11): [True: 15.5k, False: 495] ------------------ 428| 16.0k| strcmp(identifier, compiler->loop[i].vars[j].identifier.ptr) == 0) ------------------ | Branch (428:11): [True: 8.03k, False: 7.50k] ------------------ 429| 8.03k| { 430| 8.03k| if (expr != NULL) ------------------ | Branch (430:13): [True: 8.00k, False: 23] ------------------ 431| 8.00k| *expr = compiler->loop[i].vars[j]; 432| | 433| 8.03k| return var_offset + j; 434| 8.03k| } 435| 16.0k| } 436| | 437| 4.33k| var_offset += compiler->loop[i].vars_count; 438| 4.33k| } 439| | 440| 9.73k| return -1; 441| 17.7k|} yr_parser_reduce_string_declaration: 687| 18.1k|{ 688| 18.1k| int result = ERROR_SUCCESS; ------------------ | | 40| 18.1k|#define ERROR_SUCCESS 0 ------------------ 689| 18.1k| int min_atom_quality = YR_MAX_ATOM_QUALITY; ------------------ | | 71| 18.1k|#define YR_MAX_ATOM_QUALITY 255 ------------------ 690| 18.1k| int atom_quality; 691| | 692| 18.1k| char message[512]; 693| | 694| 18.1k| int32_t min_gap = 0; 695| 18.1k| int32_t max_gap = 0; 696| | 697| 18.1k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 18.1k|#define yyget_extra yara_yyget_extra ------------------ 698| | 699| 18.1k| RE_AST* re_ast = NULL; 700| 18.1k| RE_AST* remainder_re_ast = NULL; 701| 18.1k| RE_ERROR re_error; 702| | 703| 18.1k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 704| 18.1k| compiler, compiler->current_rule_idx); 705| | 706| | // Determine if a string with the same identifier was already defined 707| | // by searching for the identifier in strings_table. 708| 18.1k| uint32_t string_idx = yr_hash_table_lookup_uint32( 709| 18.1k| compiler->strings_table, identifier, NULL); 710| | 711| | // The string was already defined, return an error. 712| 18.1k| if (string_idx != UINT32_MAX) ------------------ | Branch (712:7): [True: 13, False: 18.1k] ------------------ 713| 13| { 714| 13| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 306| 13| strlcpy( \ | | 307| 13| compiler->last_error_extra_info, \ | | 308| 13| info, \ | | 309| 13| sizeof(compiler->last_error_extra_info)); ------------------ 715| 13| return ERROR_DUPLICATED_STRING_IDENTIFIER; ------------------ | | 62| 13|#define ERROR_DUPLICATED_STRING_IDENTIFIER 17 ------------------ 716| 13| } 717| | 718| | // Empty strings are not allowed. 719| 18.1k| if (str->length == 0) ------------------ | Branch (719:7): [True: 0, False: 18.1k] ------------------ 720| 0| { 721| 0| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 722| 0| return ERROR_EMPTY_STRING; ------------------ | | 90| 0|#define ERROR_EMPTY_STRING 43 ------------------ 723| 0| } 724| | 725| 18.1k| if (str->flags & SIZED_STRING_FLAGS_NO_CASE) ------------------ | | 39| 18.1k|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ | Branch (725:7): [True: 2.08k, False: 16.0k] ------------------ 726| 2.08k| modifier.flags |= STRING_FLAGS_NO_CASE; ------------------ | | 68| 2.08k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 727| | 728| 18.1k| if (str->flags & SIZED_STRING_FLAGS_DOT_ALL) ------------------ | | 43| 18.1k|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ | Branch (728:7): [True: 302, False: 17.8k] ------------------ 729| 302| modifier.flags |= STRING_FLAGS_DOT_ALL; ------------------ | | 83| 302|#define STRING_FLAGS_DOT_ALL 0x20000 ------------------ 730| | 731| | // Hex strings are always handled as DOT_ALL regexps. 732| 18.1k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL) ------------------ | | 67| 18.1k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (732:7): [True: 1.27k, False: 16.9k] ------------------ 733| 1.27k| modifier.flags |= STRING_FLAGS_DOT_ALL; ------------------ | | 83| 1.27k|#define STRING_FLAGS_DOT_ALL 0x20000 ------------------ 734| | 735| 18.1k| if (!(modifier.flags & STRING_FLAGS_WIDE) && ------------------ | | 70| 18.1k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (735:7): [True: 16.7k, False: 1.39k] ------------------ 736| 18.1k| !(modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 33.5k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (736:9): [True: 1.18k, False: 15.6k] ------------------ 737| 16.7k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 15.6k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (737:9): [True: 382, False: 15.2k] ------------------ 738| 15.2k| { 739| 15.2k| modifier.flags |= STRING_FLAGS_ASCII; ------------------ | | 69| 15.2k|#define STRING_FLAGS_ASCII 0x08 ------------------ 740| 15.2k| } 741| | 742| | // The STRING_FLAGS_SINGLE_MATCH flag indicates that finding 743| | // a single match for the string is enough. This is true in 744| | // most cases, except when the string count (#) and string offset (@) 745| | // operators are used. All strings are marked STRING_FLAGS_SINGLE_MATCH 746| | // initially, and unmarked later if required. 747| 18.1k| modifier.flags |= STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 18.1k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 748| | 749| | // The STRING_FLAGS_FIXED_OFFSET indicates that the string doesn't 750| | // need to be searched all over the file because the user is using the 751| | // "at" operator. The string must be searched at a fixed offset in the 752| | // file. All strings are marked STRING_FLAGS_FIXED_OFFSET initially, 753| | // and unmarked later if required. 754| 18.1k| modifier.flags |= STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 18.1k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 755| | 756| | // If string identifier is $ this is an anonymous string, if not add the 757| | // identifier to strings_table. 758| 18.1k| if (strcmp(identifier, "$") == 0) ------------------ | Branch (758:7): [True: 17.0k, False: 1.12k] ------------------ 759| 17.0k| { 760| 17.0k| modifier.flags |= STRING_FLAGS_ANONYMOUS; ------------------ | | 74| 17.0k|#define STRING_FLAGS_ANONYMOUS 0x100 ------------------ 761| 17.0k| } 762| 1.12k| else 763| 1.12k| { 764| 1.12k| FAIL_ON_ERROR(yr_hash_table_add_uint32( ------------------ | | 134| 1.12k| { \ | | 135| 1.12k| int __error = (x); \ | | 136| 1.12k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.12k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.12k] | | ------------------ | | 137| 1.12k| return __error; \ | | 138| 1.12k| } ------------------ 765| 1.12k| compiler->strings_table, 766| 1.12k| identifier, 767| 1.12k| NULL, 768| 1.12k| compiler->current_string_idx)); 769| 1.12k| } 770| | 771| | // Make sure that the the string does not have an invalid combination of 772| | // modifiers. 773| 18.1k| FAIL_ON_ERROR(_yr_parser_check_string_modifiers(yyscanner, modifier)); ------------------ | | 134| 18.1k| { \ | | 135| 18.1k| int __error = (x); \ | | 136| 18.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 18.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 8, False: 18.1k] | | ------------------ | | 137| 18.1k| return __error; \ | | 138| 18.1k| } ------------------ 774| | 775| 18.1k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL || ------------------ | | 67| 36.3k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (775:7): [True: 1.27k, False: 16.9k] ------------------ 776| 18.1k| modifier.flags & STRING_FLAGS_REGEXP || ------------------ | | 71| 35.0k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (776:7): [True: 12.2k, False: 4.62k] ------------------ 777| 18.1k| modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 22.8k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (777:7): [True: 1.25k, False: 3.37k] ------------------ 778| 18.1k| modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 3.37k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (778:7): [True: 699, False: 2.67k] ------------------ 779| 15.5k| { 780| 15.5k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL) ------------------ | | 67| 15.5k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (780:9): [True: 1.27k, False: 14.2k] ------------------ 781| 1.27k| result = yr_re_parse_hex(str->c_string, &re_ast, &re_error); 782| 14.2k| else if (modifier.flags & STRING_FLAGS_REGEXP) ------------------ | | 71| 14.2k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (782:14): [True: 12.2k, False: 1.95k] ------------------ 783| 12.2k| { 784| 12.2k| int flags = RE_PARSER_FLAG_NONE; 785| 12.2k| if (compiler->strict_escape) ------------------ | Branch (785:11): [True: 0, False: 12.2k] ------------------ 786| 0| flags |= RE_PARSER_FLAG_ENABLE_STRICT_ESCAPE_SEQUENCES; 787| 12.2k| result = yr_re_parse(str->c_string, &re_ast, &re_error, flags); 788| 12.2k| } 789| 1.95k| else 790| 1.95k| result = yr_base64_ast_from_string(str, modifier, &re_ast, &re_error); 791| | 792| 15.5k| if (result != ERROR_SUCCESS) ------------------ | | 40| 15.5k|#define ERROR_SUCCESS 0 ------------------ | Branch (792:9): [True: 756, False: 14.7k] ------------------ 793| 756| { 794| 756| if (result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 756|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (794:11): [True: 0, False: 756] ------------------ 795| 0| { 796| 0| yywarning(yyscanner, "unknown escape sequence"); ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 797| 0| } 798| 756| else 799| 756| { 800| 756| snprintf( 801| 756| message, 802| 756| sizeof(message), 803| 756| "invalid %s \"%s\": %s", 804| 756| (modifier.flags & STRING_FLAGS_HEXADECIMAL) ? "hex string" ------------------ | | 67| 756|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (804:13): [True: 243, False: 513] ------------------ 805| 756| : "regular expression", 806| 756| identifier, 807| 756| re_error.message); 808| | 809| 756| yr_compiler_set_error_extra_info(compiler, message); ------------------ | | 306| 756| strlcpy( \ | | 307| 756| compiler->last_error_extra_info, \ | | 308| 756| info, \ | | 309| 756| sizeof(compiler->last_error_extra_info)); ------------------ 810| 756| goto _exit; 811| 756| } 812| 756| } 813| | 814| 14.7k| if (re_ast->flags & RE_FLAGS_FAST_REGEXP) ------------------ | | 94| 14.7k|#define RE_FLAGS_FAST_REGEXP 0x02 ------------------ | Branch (814:9): [True: 997, False: 13.7k] ------------------ 815| 997| modifier.flags |= STRING_FLAGS_FAST_REGEXP; ------------------ | | 72| 997|#define STRING_FLAGS_FAST_REGEXP 0x40 ------------------ 816| | 817| 14.7k| if (re_ast->flags & RE_FLAGS_GREEDY) ------------------ | | 101| 14.7k|#define RE_FLAGS_GREEDY 0x400 ------------------ | Branch (817:9): [True: 897, False: 13.8k] ------------------ 818| 897| modifier.flags |= STRING_FLAGS_GREEDY_REGEXP; ------------------ | | 82| 897|#define STRING_FLAGS_GREEDY_REGEXP 0x10000 ------------------ 819| | 820| | // Regular expressions in the strings section can't mix greedy and 821| | // ungreedy quantifiers like .* and .*?. That's because these regular 822| | // expressions can be matched forwards and/or backwards depending on the 823| | // atom found, and we need the regexp to be all-greedy or all-ungreedy to 824| | // be able to properly calculate the length of the match. 825| | 826| 14.7k| if ((re_ast->flags & RE_FLAGS_GREEDY) && ------------------ | | 101| 14.7k|#define RE_FLAGS_GREEDY 0x400 ------------------ | Branch (826:9): [True: 897, False: 13.8k] ------------------ 827| 14.7k| (re_ast->flags & RE_FLAGS_UNGREEDY)) ------------------ | | 102| 897|#define RE_FLAGS_UNGREEDY 0x800 ------------------ | Branch (827:9): [True: 11, False: 886] ------------------ 828| 11| { 829| 11| result = ERROR_INVALID_REGULAR_EXPRESSION; ------------------ | | 54| 11|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ 830| | 831| 11| yr_compiler_set_error_extra_info( ------------------ | | 306| 11| strlcpy( \ | | 307| 11| compiler->last_error_extra_info, \ | | 308| 11| info, \ | | 309| 11| sizeof(compiler->last_error_extra_info)); ------------------ 832| 11| compiler, 833| 11| "greedy and ungreedy quantifiers can't be mixed in a regular " 834| 11| "expression"); 835| | 836| 11| goto _exit; 837| 11| } 838| | 839| 14.7k| if (yr_re_ast_has_unbounded_quantifier_for_dot(re_ast)) ------------------ | Branch (839:9): [True: 972, False: 13.7k] ------------------ 840| 972| { 841| 972| yywarning( ------------------ | | 50| 972|#define yywarning yara_yywarning ------------------ 842| 972| yyscanner, 843| 972| "%s contains .*, .+ or .{x,} consider using .{,N}, .{1,N} or {x,N} " 844| 972| "with a reasonable value for N", 845| 972| identifier); 846| 972| } 847| | 848| 14.7k| if (compiler->re_ast_callback != NULL) ------------------ | Branch (848:9): [True: 0, False: 14.7k] ------------------ 849| 0| { 850| 0| compiler->re_ast_callback( 851| 0| current_rule, identifier, re_ast, compiler->re_ast_clbk_user_data); 852| 0| } 853| | 854| 14.7k| *string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 14.7k| (YR_ARENA_REF) \ | | 44| 14.7k| { \ | | 45| 14.7k| UINT32_MAX, UINT32_MAX \ | | 46| 14.7k| } ------------------ 855| | 856| 34.3k| while (re_ast != NULL) ------------------ | Branch (856:12): [True: 19.7k, False: 14.6k] ------------------ 857| 19.7k| { 858| 19.7k| YR_ARENA_REF ref; 859| | 860| 19.7k| uint32_t prev_string_idx = compiler->current_string_idx - 1; 861| | 862| 19.7k| int32_t prev_min_gap = min_gap; 863| 19.7k| int32_t prev_max_gap = max_gap; 864| | 865| 19.7k| result = yr_re_ast_split_at_chaining_point( 866| 19.7k| re_ast, &remainder_re_ast, &min_gap, &max_gap); 867| | 868| 19.7k| if (result != ERROR_SUCCESS) ------------------ | | 40| 19.7k|#define ERROR_SUCCESS 0 ------------------ | Branch (868:11): [True: 0, False: 19.7k] ------------------ 869| 0| goto _exit; 870| | 871| 19.7k| result = _yr_parser_write_string( 872| 19.7k| identifier, 873| 19.7k| modifier, 874| 19.7k| compiler, 875| 19.7k| NULL, 876| 19.7k| re_ast, 877| 19.7k| &ref, 878| 19.7k| &atom_quality, 879| 19.7k| ¤t_rule->num_atoms); 880| | 881| 19.7k| if (result != ERROR_SUCCESS) ------------------ | | 40| 19.7k|#define ERROR_SUCCESS 0 ------------------ | Branch (881:11): [True: 118, False: 19.6k] ------------------ 882| 118| goto _exit; 883| | 884| 19.6k| if (atom_quality < min_atom_quality) ------------------ | Branch (884:11): [True: 13.8k, False: 5.73k] ------------------ 885| 13.8k| min_atom_quality = atom_quality; 886| | 887| 19.6k| if (YR_ARENA_IS_NULL_REF(*string_ref)) ------------------ | | 49| 19.6k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 19.6k| (YR_ARENA_REF) \ | | | | 44| 19.6k| { \ | | | | 45| 19.6k| UINT32_MAX, UINT32_MAX \ | | | | 46| 19.6k| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 19.6k| (YR_ARENA_REF) \ | | | | 44| 19.6k| { \ | | | | 45| 19.6k| UINT32_MAX, UINT32_MAX \ | | | | 46| 19.6k| } | | ------------------ | | | Branch (49:3): [True: 14.6k, False: 5.00k] | | ------------------ ------------------ 888| 14.6k| { 889| | // This is the first string in the chain, the string reference 890| | // returned by this function must point to this string. 891| 14.6k| *string_ref = ref; 892| 14.6k| } 893| 5.00k| else 894| 5.00k| { 895| | // This is not the first string in the chain, set the appropriate 896| | // flags and fill the chained_to, chain_gap_min and chain_gap_max 897| | // fields. 898| 5.00k| YR_STRING* prev_string = (YR_STRING*) yr_arena_get_ptr( 899| 5.00k| compiler->arena, 900| 5.00k| YR_STRINGS_TABLE, ------------------ | | 60| 5.00k|#define YR_STRINGS_TABLE 3 ------------------ 901| 5.00k| prev_string_idx * sizeof(YR_STRING)); 902| | 903| 5.00k| YR_STRING* new_string = (YR_STRING*) yr_arena_ref_to_ptr( 904| 5.00k| compiler->arena, &ref); 905| | 906| 5.00k| new_string->chained_to = prev_string; 907| 5.00k| new_string->chain_gap_min = prev_min_gap; 908| 5.00k| new_string->chain_gap_max = prev_max_gap; 909| | 910| | // A string chained to another one can't have a fixed offset, only the 911| | // head of the string chain can have a fixed offset. 912| 5.00k| new_string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 5.00k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 913| | 914| | // There is a previous string, but that string wasn't marked as part 915| | // of a chain because we can't do that until knowing there will be 916| | // another string, let's flag it now the we know. 917| 5.00k| prev_string->flags |= STRING_FLAGS_CHAIN_PART; ------------------ | | 79| 5.00k|#define STRING_FLAGS_CHAIN_PART 0x2000 ------------------ 918| | 919| | // There is a previous string, so this string is part of a chain, but 920| | // there will be no more strings because there are no more AST to 921| | // split, which means that this is the chain's tail. 922| 5.00k| if (remainder_re_ast == NULL) ------------------ | Branch (922:13): [True: 582, False: 4.42k] ------------------ 923| 582| new_string->flags |= STRING_FLAGS_CHAIN_PART | ------------------ | | 79| 582|#define STRING_FLAGS_CHAIN_PART 0x2000 ------------------ 924| 582| STRING_FLAGS_CHAIN_TAIL; ------------------ | | 80| 582|#define STRING_FLAGS_CHAIN_TAIL 0x4000 ------------------ 925| 5.00k| } 926| | 927| 19.6k| yr_re_ast_destroy(re_ast); 928| 19.6k| re_ast = remainder_re_ast; 929| 19.6k| } 930| 14.7k| } 931| 2.67k| else // not a STRING_FLAGS_HEXADECIMAL or STRING_FLAGS_REGEXP or 932| | // STRING_FLAGS_BASE64 or STRING_FLAGS_BASE64_WIDE 933| 2.67k| { 934| 2.67k| result = _yr_parser_write_string( 935| 2.67k| identifier, 936| 2.67k| modifier, 937| 2.67k| compiler, 938| 2.67k| str, 939| 2.67k| NULL, 940| 2.67k| string_ref, 941| 2.67k| &min_atom_quality, 942| 2.67k| ¤t_rule->num_atoms); 943| | 944| 2.67k| if (result != ERROR_SUCCESS) ------------------ | | 40| 2.67k|#define ERROR_SUCCESS 0 ------------------ | Branch (944:9): [True: 0, False: 2.67k] ------------------ 945| 0| goto _exit; 946| 2.67k| } 947| | 948| 17.2k| if (min_atom_quality < compiler->atoms_config.quality_warning_threshold) ------------------ | Branch (948:7): [True: 7.20k, False: 10.0k] ------------------ 949| 7.20k| { 950| 7.20k| yywarning(yyscanner, "string \"%s\" may slow down scanning", identifier); ------------------ | | 50| 7.20k|#define yywarning yara_yywarning ------------------ 951| 7.20k| } 952| | 953| 18.1k|_exit: 954| | 955| 18.1k| if (re_ast != NULL) ------------------ | Branch (955:7): [True: 372, False: 17.8k] ------------------ 956| 372| yr_re_ast_destroy(re_ast); 957| | 958| 18.1k| if (remainder_re_ast != NULL) ------------------ | Branch (958:7): [True: 1, False: 18.1k] ------------------ 959| 1| yr_re_ast_destroy(remainder_re_ast); 960| | 961| 18.1k| return result; 962| 17.2k|} yr_parser_reduce_rule_declaration_phase_1: 984| 25.6k|{ 985| 25.6k| int result; 986| 25.6k| YR_FIXUP* fixup; 987| 25.6k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 25.6k|#define yyget_extra yara_yyget_extra ------------------ 988| | 989| 25.6k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 990| 25.6k| compiler->arena, 991| 25.6k| YR_NAMESPACES_TABLE, ------------------ | | 57| 25.6k|#define YR_NAMESPACES_TABLE 0 ------------------ 992| 25.6k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 993| | 994| 25.6k| if (yr_hash_table_lookup_uint32( ------------------ | Branch (994:7): [True: 15.5k, False: 10.0k] ------------------ 995| 25.6k| compiler->rules_table, identifier, ns->name) != UINT32_MAX || 996| 25.6k| yr_hash_table_lookup(compiler->objects_table, identifier, NULL) != NULL) ------------------ | Branch (996:7): [True: 0, False: 10.0k] ------------------ 997| 15.5k| { 998| | // A rule or variable with the same identifier already exists, return the 999| | // appropriate error. 1000| | 1001| 15.5k| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 306| 15.5k| strlcpy( \ | | 307| 15.5k| compiler->last_error_extra_info, \ | | 308| 15.5k| info, \ | | 309| 15.5k| sizeof(compiler->last_error_extra_info)); ------------------ 1002| 15.5k| return ERROR_DUPLICATED_IDENTIFIER; ------------------ | | 59| 15.5k|#define ERROR_DUPLICATED_IDENTIFIER 14 ------------------ 1003| 15.5k| } 1004| | 1005| | // Iterate over all identifiers in wildcard_identifiers_table, and check if 1006| | // any of them are a prefix of the identifier being declared. If so, return 1007| | // ERROR_IDENTIFIER_MATCHES_WILDCARD. 1008| 10.0k| result = yr_hash_table_iterate( 1009| 10.0k| compiler->wildcard_identifiers_table, 1010| 10.0k| ns->name, 1011| 10.0k| wildcard_iterator, 1012| 10.0k| (void*) identifier); 1013| | 1014| 10.0k| if (result == ERROR_IDENTIFIER_MATCHES_WILDCARD) ------------------ | | 110| 10.0k|#define ERROR_IDENTIFIER_MATCHES_WILDCARD 63 ------------------ | Branch (1014:7): [True: 180, False: 9.88k] ------------------ 1015| 180| { 1016| | // This rule matches an existing wildcard rule set. 1017| 180| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 306| 180| strlcpy( \ | | 307| 180| compiler->last_error_extra_info, \ | | 308| 180| info, \ | | 309| 180| sizeof(compiler->last_error_extra_info)); ------------------ 1018| 180| } 1019| | 1020| 10.0k| FAIL_ON_ERROR(result); ------------------ | | 134| 10.0k| { \ | | 135| 10.0k| int __error = (x); \ | | 136| 10.0k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 10.0k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 180, False: 9.88k] | | ------------------ | | 137| 10.0k| return __error; \ | | 138| 10.0k| } ------------------ 1021| | 1022| 9.88k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 9.88k| { \ | | 135| 9.88k| int __error = (x); \ | | 136| 9.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 9.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 9.88k] | | ------------------ | | 137| 9.88k| return __error; \ | | 138| 9.88k| } ------------------ 1023| 9.88k| compiler->arena, 1024| 9.88k| YR_RULES_TABLE, 1025| 9.88k| sizeof(YR_RULE), 1026| 9.88k| rule_ref, 1027| 9.88k| offsetof(YR_RULE, identifier), 1028| 9.88k| offsetof(YR_RULE, tags), 1029| 9.88k| offsetof(YR_RULE, strings), 1030| 9.88k| offsetof(YR_RULE, metas), 1031| 9.88k| offsetof(YR_RULE, ns), 1032| 9.88k| EOL)); 1033| | 1034| 9.88k| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr(compiler->arena, rule_ref); 1035| | 1036| 9.88k| YR_ARENA_REF ref; 1037| | 1038| 9.88k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 134| 9.88k| { \ | | 135| 9.88k| int __error = (x); \ | | 136| 9.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 9.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 9.88k] | | ------------------ | | 137| 9.88k| return __error; \ | | 138| 9.88k| } ------------------ 1039| | 1040| 9.88k| rule->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 1041| 9.88k| rule->flags = flags; 1042| 9.88k| rule->ns = ns; 1043| 9.88k| rule->num_atoms = 0; 1044| | 1045| 9.88k| YR_ARENA_REF jmp_offset_ref; 1046| | 1047| | // We are starting to parse a new rule, set current_rule_idx accordingly. 1048| 9.88k| compiler->current_rule_idx = compiler->next_rule_idx; 1049| 9.88k| compiler->next_rule_idx++; 1050| | 1051| | // The OP_INIT_RULE instruction behaves like a jump. When the rule is 1052| | // disabled it skips over the rule's code and go straight to the next rule's 1053| | // code. The jmp_offset_ref variable points to the jump's offset. The offset 1054| | // is set to 0 as we don't know the jump target yet. When we finish 1055| | // generating the rule's code in yr_parser_reduce_rule_declaration_phase_2 1056| | // the jump offset is set to its final value. 1057| | 1058| 9.88k| FAIL_ON_ERROR(yr_parser_emit_with_arg_int32( ------------------ | | 134| 9.88k| { \ | | 135| 9.88k| int __error = (x); \ | | 136| 9.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 9.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 9.88k] | | ------------------ | | 137| 9.88k| return __error; \ | | 138| 9.88k| } ------------------ 1059| 9.88k| yyscanner, OP_INIT_RULE, 0, NULL, &jmp_offset_ref)); 1060| | 1061| 9.88k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 9.88k| { \ | | 135| 9.88k| int __error = (x); \ | | 136| 9.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 9.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 9.88k] | | ------------------ | | 137| 9.88k| return __error; \ | | 138| 9.88k| } ------------------ 1062| 9.88k| compiler->arena, 1063| 9.88k| YR_CODE_SECTION, 1064| 9.88k| &compiler->current_rule_idx, 1065| 9.88k| sizeof(compiler->current_rule_idx), 1066| 9.88k| NULL)); 1067| | 1068| | // Create a fixup entry for the jump and push it in the stack 1069| 9.88k| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 1070| | 1071| 9.88k| if (fixup == NULL) ------------------ | Branch (1071:7): [True: 0, False: 9.88k] ------------------ 1072| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1073| | 1074| 9.88k| fixup->ref = jmp_offset_ref; 1075| 9.88k| fixup->next = compiler->fixup_stack_head; 1076| 9.88k| compiler->fixup_stack_head = fixup; 1077| | 1078| | // Clean strings_table as we are starting to parse a new rule. 1079| 9.88k| yr_hash_table_clean(compiler->strings_table, NULL); 1080| | 1081| 9.88k| FAIL_ON_ERROR(yr_hash_table_add_uint32( ------------------ | | 134| 9.88k| { \ | | 135| 9.88k| int __error = (x); \ | | 136| 9.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 9.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 9.88k] | | ------------------ | | 137| 9.88k| return __error; \ | | 138| 9.88k| } ------------------ 1082| 9.88k| compiler->rules_table, identifier, ns->name, compiler->current_rule_idx)); 1083| | 1084| 9.88k| return ERROR_SUCCESS; ------------------ | | 40| 9.88k|#define ERROR_SUCCESS 0 ------------------ 1085| 9.88k|} yr_parser_reduce_rule_declaration_phase_2: 1090| 388|{ 1091| 388| uint32_t max_strings_per_rule; 1092| 388| uint32_t strings_in_rule = 0; 1093| | 1094| 388| YR_FIXUP* fixup; 1095| 388| YR_STRING* string; 1096| 388| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 388|#define yyget_extra yara_yyget_extra ------------------ 1097| | 1098| 388| yr_get_configuration_uint32( 1099| 388| YR_CONFIG_MAX_STRINGS_PER_RULE, &max_strings_per_rule); 1100| | 1101| 388| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr(compiler->arena, rule_ref); 1102| | 1103| | // Show warning if the rule is generating too many atoms. The warning is 1104| | // shown if the number of atoms is greater than 20 times the maximum number 1105| | // of strings allowed for a rule, as 20 is minimum number of atoms generated 1106| | // for a string using *nocase*, *ascii* and *wide* modifiers simultaneously. 1107| | 1108| 388| if (rule->num_atoms > YR_ATOMS_PER_RULE_WARNING_THRESHOLD) ------------------ | | 89| 388|#define YR_ATOMS_PER_RULE_WARNING_THRESHOLD 12000 ------------------ | Branch (1108:7): [True: 20, False: 368] ------------------ 1109| 20| { 1110| 20| yywarning(yyscanner, "rule is slowing down scanning"); ------------------ | | 50| 20|#define yywarning yara_yywarning ------------------ 1111| 20| } 1112| | 1113| 388| yr_rule_strings_foreach(rule, string) ------------------ | | 60| 1.92k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 1.55k, False: 368] | | ------------------ | | 61| 1.53k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 1.53k|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 1.53k|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 250, False: 1.28k] | | | | ------------------ | | ------------------ ------------------ 1114| 1.55k| { 1115| | // Only the heading fragment in a chain of strings (the one with 1116| | // chained_to == NULL) must be referenced. All other fragments 1117| | // are never marked as referenced. 1118| | // 1119| | // Any string identifier that starts with '_' can be unreferenced. Anonymous 1120| | // strings must always be referenced. 1121| | 1122| 1.55k| if (!STRING_IS_REFERENCED(string) && string->chained_to == NULL && ------------------ | | 108| 3.11k|#define STRING_IS_REFERENCED(x) (((x)->flags) & STRING_FLAGS_REFERENCED) | | ------------------ | | | | 66| 1.55k|#define STRING_FLAGS_REFERENCED 0x01 | | ------------------ ------------------ | Branch (1122:9): [True: 523, False: 1.03k] | Branch (1122:42): [True: 301, False: 222] ------------------ 1123| 1.55k| (STRING_IS_ANONYMOUS(string) || ------------------ | | 106| 602|#define STRING_IS_ANONYMOUS(x) (((x)->flags) & STRING_FLAGS_ANONYMOUS) | | ------------------ | | | | 74| 301|#define STRING_FLAGS_ANONYMOUS 0x100 | | ------------------ | | | Branch (106:32): [True: 4, False: 297] | | ------------------ ------------------ 1124| 301| (!STRING_IS_ANONYMOUS(string) && string->identifier[1] != '_'))) ------------------ | | 106| 594|#define STRING_IS_ANONYMOUS(x) (((x)->flags) & STRING_FLAGS_ANONYMOUS) | | ------------------ | | | | 74| 297|#define STRING_FLAGS_ANONYMOUS 0x100 | | ------------------ ------------------ | Branch (1124:11): [True: 297, False: 0] | Branch (1124:43): [True: 16, False: 281] ------------------ 1125| 20| { 1126| 20| yr_compiler_set_error_extra_info( ------------------ | | 306| 20| strlcpy( \ | | 307| 20| compiler->last_error_extra_info, \ | | 308| 20| info, \ | | 309| 20| sizeof(compiler->last_error_extra_info)); ------------------ 1127| 20| compiler, string->identifier) return ERROR_UNREFERENCED_STRING; ------------------ | | 63| 20|#define ERROR_UNREFERENCED_STRING 18 ------------------ 1128| 20| } 1129| | 1130| | // If a string is unreferenced we need to unset the FIXED_OFFSET flag so 1131| | // that it will match anywhere. 1132| 1.53k| if (!STRING_IS_REFERENCED(string) && string->chained_to == NULL && ------------------ | | 108| 3.07k|#define STRING_IS_REFERENCED(x) (((x)->flags) & STRING_FLAGS_REFERENCED) | | ------------------ | | | | 66| 1.53k|#define STRING_FLAGS_REFERENCED 0x01 | | ------------------ ------------------ | Branch (1132:9): [True: 503, False: 1.03k] | Branch (1132:42): [True: 281, False: 222] ------------------ 1133| 1.53k| STRING_IS_FIXED_OFFSET(string)) ------------------ | | 112| 281|#define STRING_IS_FIXED_OFFSET(x) (((x)->flags) & STRING_FLAGS_FIXED_OFFSET) | | ------------------ | | | | 81| 281|#define STRING_FLAGS_FIXED_OFFSET 0x8000 | | ------------------ | | | Branch (112:35): [True: 186, False: 95] | | ------------------ ------------------ 1134| 186| { 1135| 186| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 186|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1136| 186| } 1137| | 1138| 1.53k| strings_in_rule++; 1139| | 1140| 1.53k| if (strings_in_rule > max_strings_per_rule) ------------------ | Branch (1140:9): [True: 0, False: 1.53k] ------------------ 1141| 0| { 1142| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1143| 0| compiler, rule->identifier) return ERROR_TOO_MANY_STRINGS; ------------------ | | 98| 0|#define ERROR_TOO_MANY_STRINGS 51 ------------------ 1144| 0| } 1145| 1.53k| } 1146| | 1147| 368| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 134| 368| { \ | | 135| 368| int __error = (x); \ | | 136| 368| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 368|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 368] | | ------------------ | | 137| 368| return __error; \ | | 138| 368| } ------------------ 1148| 368| yyscanner, OP_MATCH_RULE, compiler->current_rule_idx, NULL, NULL)); 1149| | 1150| 368| fixup = compiler->fixup_stack_head; 1151| | 1152| 368| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 1153| 368| compiler->arena, &fixup->ref); 1154| | 1155| 368| int32_t jmp_offset = yr_arena_get_current_offset( 1156| 368| compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 368|#define YR_CODE_SECTION 6 ------------------ 1157| 368| fixup->ref.offset + 1; 1158| | 1159| 368| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 1160| | 1161| | // Remove fixup from the stack. 1162| 368| compiler->fixup_stack_head = fixup->next; 1163| 368| yr_free(fixup); 1164| | 1165| | // We have finished parsing the current rule set current_rule_idx to 1166| | // UINT32_MAX indicating that we are not currently parsing a rule. 1167| 368| compiler->current_rule_idx = UINT32_MAX; 1168| | 1169| 368| return ERROR_SUCCESS; ------------------ | | 40| 368|#define ERROR_SUCCESS 0 ------------------ 1170| 368|} yr_parser_reduce_string_identifier: 1177| 18.8k|{ 1178| 18.8k| YR_STRING* string; 1179| 18.8k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 18.8k|#define yyget_extra yara_yyget_extra ------------------ 1180| | 1181| 18.8k| if (strcmp(identifier, "$") == 0) // is an anonymous string ? ------------------ | Branch (1181:7): [True: 16.6k, False: 2.20k] ------------------ 1182| 16.6k| { 1183| 16.6k| if (compiler->loop_for_of_var_index >= 0) // inside a loop ? ------------------ | Branch (1183:9): [True: 16.5k, False: 130] ------------------ 1184| 16.5k| { 1185| 16.5k| yr_parser_emit_with_arg( 1186| 16.5k| yyscanner, OP_PUSH_M, compiler->loop_for_of_var_index, NULL, NULL); ------------------ | | 82| 16.5k|#define OP_PUSH_M 34 ------------------ 1187| | 1188| 16.5k| yr_parser_emit(yyscanner, instruction, NULL); 1189| | 1190| 16.5k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 1191| 16.5k| compiler, compiler->current_rule_idx); 1192| | 1193| 16.5k| yr_rule_strings_foreach(current_rule, string) ------------------ | | 60| 766k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 750k, False: 16.5k] | | ------------------ | | 61| 750k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 750k|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 750k|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 15.2k, False: 734k] | | | | ------------------ | | ------------------ ------------------ 1194| 750k| { 1195| 750k| if (instruction != OP_FOUND) ------------------ | | 70| 750k|#define OP_FOUND 22 ------------------ | Branch (1195:13): [True: 749k, False: 239] ------------------ 1196| 749k| string->flags &= ~STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 749k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 1197| | 1198| 750k| if (instruction == OP_FOUND_AT) ------------------ | | 71| 750k|#define OP_FOUND_AT 23 ------------------ | Branch (1198:13): [True: 539, False: 749k] ------------------ 1199| 539| { 1200| | // Avoid overwriting any previous fixed offset 1201| 539| if (string->fixed_offset == YR_UNDEFINED) ------------------ | | 38| 539|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1201:15): [True: 281, False: 258] ------------------ 1202| 281| string->fixed_offset = at_offset; 1203| | 1204| | // If a previous fixed offset was different, disable 1205| | // the STRING_GFLAGS_FIXED_OFFSET flag because we only 1206| | // have room to store a single fixed offset value 1207| 539| if (string->fixed_offset != at_offset) ------------------ | Branch (1207:15): [True: 258, False: 281] ------------------ 1208| 258| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 258|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1209| 539| } 1210| 749k| else 1211| 749k| { 1212| 749k| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 749k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1213| 749k| } 1214| 750k| } 1215| 16.5k| } 1216| 130| else 1217| 130| { 1218| | // Anonymous strings not allowed outside of a loop 1219| 130| return ERROR_MISPLACED_ANONYMOUS_STRING; ------------------ | | 66| 130|#define ERROR_MISPLACED_ANONYMOUS_STRING 21 ------------------ 1220| 130| } 1221| 16.6k| } 1222| 2.20k| else 1223| 2.20k| { 1224| 2.20k| FAIL_ON_ERROR(yr_parser_lookup_string(yyscanner, identifier, &string)); ------------------ | | 134| 2.20k| { \ | | 135| 2.20k| int __error = (x); \ | | 136| 2.20k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.20k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 40, False: 2.16k] | | ------------------ | | 137| 2.20k| return __error; \ | | 138| 2.20k| } ------------------ 1225| | 1226| 2.16k| FAIL_ON_ERROR( ------------------ | | 134| 2.16k| { \ | | 135| 2.16k| int __error = (x); \ | | 136| 2.16k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.16k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2.16k] | | ------------------ | | 137| 2.16k| return __error; \ | | 138| 2.16k| } ------------------ 1227| 2.16k| yr_parser_emit_with_arg_reloc(yyscanner, OP_PUSH, string, NULL, NULL)); 1228| | 1229| 2.16k| if (instruction != OP_FOUND) ------------------ | | 70| 2.16k|#define OP_FOUND 22 ------------------ | Branch (1229:9): [True: 1.94k, False: 220] ------------------ 1230| 1.94k| string->flags &= ~STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 1.94k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 1231| | 1232| 2.16k| if (instruction == OP_FOUND_AT) ------------------ | | 71| 2.16k|#define OP_FOUND_AT 23 ------------------ | Branch (1232:9): [True: 532, False: 1.63k] ------------------ 1233| 532| { 1234| | // Avoid overwriting any previous fixed offset 1235| | 1236| 532| if (string->fixed_offset == YR_UNDEFINED) ------------------ | | 38| 532|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1236:11): [True: 209, False: 323] ------------------ 1237| 209| string->fixed_offset = at_offset; 1238| | 1239| | // If a previous fixed offset was different, disable 1240| | // the STRING_GFLAGS_FIXED_OFFSET flag because we only 1241| | // have room to store a single fixed offset value 1242| | 1243| 532| if (string->fixed_offset == YR_UNDEFINED || ------------------ | | 38| 1.06k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1243:11): [True: 204, False: 328] ------------------ 1244| 532| string->fixed_offset != at_offset) ------------------ | Branch (1244:11): [True: 164, False: 164] ------------------ 1245| 368| { 1246| 368| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 368|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1247| 368| } 1248| 532| } 1249| 1.63k| else 1250| 1.63k| { 1251| 1.63k| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 1.63k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1252| 1.63k| } 1253| | 1254| 2.16k| FAIL_ON_ERROR(yr_parser_emit(yyscanner, instruction, NULL)); ------------------ | | 134| 2.16k| { \ | | 135| 2.16k| int __error = (x); \ | | 136| 2.16k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.16k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2.16k] | | ------------------ | | 137| 2.16k| return __error; \ | | 138| 2.16k| } ------------------ 1255| | 1256| 2.16k| string->flags |= STRING_FLAGS_REFERENCED; ------------------ | | 66| 2.16k|#define STRING_FLAGS_REFERENCED 0x01 ------------------ 1257| 2.16k| } 1258| | 1259| 18.7k| return ERROR_SUCCESS; ------------------ | | 40| 18.7k|#define ERROR_SUCCESS 0 ------------------ 1260| 18.8k|} yr_parser_reduce_meta_declaration: 1269| 1.06k|{ 1270| 1.06k| YR_ARENA_REF ref; 1271| 1.06k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 1.06k|#define yyget_extra yara_yyget_extra ------------------ 1272| | 1273| 1.06k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 1.06k| { \ | | 135| 1.06k| int __error = (x); \ | | 136| 1.06k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.06k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.06k] | | ------------------ | | 137| 1.06k| return __error; \ | | 138| 1.06k| } ------------------ 1274| 1.06k| compiler->arena, 1275| 1.06k| YR_METAS_TABLE, 1276| 1.06k| sizeof(YR_META), 1277| 1.06k| meta_ref, 1278| 1.06k| offsetof(YR_META, identifier), 1279| 1.06k| offsetof(YR_META, string), 1280| 1.06k| EOL)); 1281| | 1282| 1.06k| YR_META* meta = (YR_META*) yr_arena_ref_to_ptr(compiler->arena, meta_ref); 1283| | 1284| 1.06k| meta->type = type; 1285| 1.06k| meta->integer = integer; 1286| | 1287| 1.06k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 134| 1.06k| { \ | | 135| 1.06k| int __error = (x); \ | | 136| 1.06k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.06k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.06k] | | ------------------ | | 137| 1.06k| return __error; \ | | 138| 1.06k| } ------------------ 1288| | 1289| 1.06k| meta->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 1290| | 1291| 1.06k| if (string != NULL) ------------------ | Branch (1291:7): [True: 326, False: 738] ------------------ 1292| 326| { 1293| 326| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, string, &ref)); ------------------ | | 134| 326| { \ | | 135| 326| int __error = (x); \ | | 136| 326| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 326|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 326] | | ------------------ | | 137| 326| return __error; \ | | 138| 326| } ------------------ 1294| | 1295| 326| meta->string = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 1296| 326| } 1297| 738| else 1298| 738| { 1299| 738| meta->string = NULL; 1300| 738| } 1301| | 1302| 1.06k| compiler->current_meta_idx++; 1303| | 1304| 1.06k| return ERROR_SUCCESS; ------------------ | | 40| 1.06k|#define ERROR_SUCCESS 0 ------------------ 1305| 1.06k|} yr_parser_reduce_import: 1319| 1.91k|{ 1320| 1.91k| int result; 1321| | 1322| 1.91k| YR_ARENA_REF ref; 1323| 1.91k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 1.91k|#define yyget_extra yara_yyget_extra ------------------ 1324| 1.91k| YR_OBJECT* module_structure; 1325| | 1326| 1.91k| if (!_yr_parser_valid_module_name(module_name)) ------------------ | Branch (1326:7): [True: 453, False: 1.46k] ------------------ 1327| 453| { 1328| 453| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 306| 453| strlcpy( \ | | 307| 453| compiler->last_error_extra_info, \ | | 308| 453| info, \ | | 309| 453| sizeof(compiler->last_error_extra_info)); ------------------ 1329| | 1330| 453| return ERROR_INVALID_MODULE_NAME; ------------------ | | 97| 453|#define ERROR_INVALID_MODULE_NAME 50 ------------------ 1331| 453| } 1332| | 1333| 1.46k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1334| 1.46k| compiler->arena, 1335| 1.46k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.46k|#define YR_NAMESPACES_TABLE 0 ------------------ 1336| 1.46k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1337| | 1338| 1.46k| module_structure = (YR_OBJECT*) yr_hash_table_lookup( 1339| 1.46k| compiler->objects_table, module_name->c_string, ns->name); 1340| | 1341| | // if module already imported, do nothing 1342| | 1343| 1.46k| if (module_structure != NULL) ------------------ | Branch (1343:7): [True: 1.10k, False: 360] ------------------ 1344| 1.10k| return ERROR_SUCCESS; ------------------ | | 40| 1.10k|#define ERROR_SUCCESS 0 ------------------ 1345| | 1346| 360| FAIL_ON_ERROR(yr_object_create( ------------------ | | 134| 360| { \ | | 135| 360| int __error = (x); \ | | 136| 360| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 360|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 360] | | ------------------ | | 137| 360| return __error; \ | | 138| 360| } ------------------ 1347| 360| OBJECT_TYPE_STRUCTURE, module_name->c_string, NULL, &module_structure)); 1348| | 1349| 360| FAIL_ON_ERROR(yr_hash_table_add( ------------------ | | 134| 360| { \ | | 135| 360| int __error = (x); \ | | 136| 360| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 360|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 360] | | ------------------ | | 137| 360| return __error; \ | | 138| 360| } ------------------ 1350| 360| compiler->objects_table, 1351| 360| module_name->c_string, 1352| 360| ns->name, 1353| 360| module_structure)); 1354| | 1355| 360| result = yr_modules_do_declarations(module_name->c_string, module_structure); 1356| | 1357| 360| if (result == ERROR_UNKNOWN_MODULE) ------------------ | | 81| 360|#define ERROR_UNKNOWN_MODULE 34 ------------------ | Branch (1357:7): [True: 177, False: 183] ------------------ 1358| 177| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 306| 177| strlcpy( \ | | 307| 177| compiler->last_error_extra_info, \ | | 308| 177| info, \ | | 309| 177| sizeof(compiler->last_error_extra_info)); ------------------ 1359| | 1360| 360| if (result != ERROR_SUCCESS) ------------------ | | 40| 360|#define ERROR_SUCCESS 0 ------------------ | Branch (1360:7): [True: 177, False: 183] ------------------ 1361| 177| return result; 1362| | 1363| 183| FAIL_ON_ERROR( ------------------ | | 134| 183| { \ | | 135| 183| int __error = (x); \ | | 136| 183| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 183|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 183] | | ------------------ | | 137| 183| return __error; \ | | 138| 183| } ------------------ 1364| 183| _yr_compiler_store_string(compiler, module_name->c_string, &ref)); 1365| | 1366| 183| FAIL_ON_ERROR(yr_parser_emit_with_arg_reloc( ------------------ | | 134| 183| { \ | | 135| 183| int __error = (x); \ | | 136| 183| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 183|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 183] | | ------------------ | | 137| 183| return __error; \ | | 138| 183| } ------------------ 1367| 183| yyscanner, 1368| 183| OP_IMPORT, 1369| 183| yr_arena_ref_to_ptr(compiler->arena, &ref), 1370| 183| NULL, 1371| 183| NULL)); 1372| | 1373| 183| return ERROR_SUCCESS; ------------------ | | 40| 183|#define ERROR_SUCCESS 0 ------------------ 1374| 183|} yr_parser_reduce_operation: 1446| 23.6k|{ 1447| 23.6k| int expression_type; 1448| | 1449| 23.6k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 23.6k|#define yyget_extra yara_yyget_extra ------------------ 1450| | 1451| 23.6k| if ((left_operand.type == EXPRESSION_TYPE_INTEGER || ------------------ | | 47| 47.3k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1451:8): [True: 17.6k, False: 6.03k] ------------------ 1452| 23.6k| left_operand.type == EXPRESSION_TYPE_FLOAT) && ------------------ | | 51| 6.03k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1452:8): [True: 2.47k, False: 3.56k] ------------------ 1453| 23.6k| (right_operand.type == EXPRESSION_TYPE_INTEGER || ------------------ | | 47| 40.2k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1453:8): [True: 16.5k, False: 3.62k] ------------------ 1454| 20.1k| right_operand.type == EXPRESSION_TYPE_FLOAT)) ------------------ | | 51| 3.62k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1454:8): [True: 3.62k, False: 2] ------------------ 1455| 20.1k| { 1456| 20.1k| if (left_operand.type != right_operand.type) ------------------ | Branch (1456:9): [True: 4.08k, False: 16.0k] ------------------ 1457| 4.08k| { 1458| | // One operand is double and the other is integer, 1459| | // cast the integer to double 1460| | 1461| 4.08k| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 134| 4.08k| { \ | | 135| 8.16k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 2.61k, False: 1.46k] | | ------------------ | | 136| 4.08k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.08k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 4.08k] | | ------------------ | | 137| 4.08k| return __error; \ | | 138| 4.08k| } ------------------ 1462| 4.08k| yyscanner, 1463| 4.08k| OP_INT_TO_DBL, 1464| 4.08k| (left_operand.type == EXPRESSION_TYPE_INTEGER) ? 2 : 1, 1465| 4.08k| NULL, 1466| 4.08k| NULL)); 1467| 4.08k| } 1468| | 1469| 20.1k| expression_type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 20.1k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 1470| | 1471| 20.1k| if (left_operand.type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 40.2k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1471:9): [True: 17.6k, False: 2.47k] ------------------ 1472| 20.1k| right_operand.type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 17.6k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1472:9): [True: 15.0k, False: 2.61k] ------------------ 1473| 15.0k| { 1474| 15.0k| expression_type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 15.0k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 1475| 15.0k| } 1476| | 1477| 20.1k| FAIL_ON_ERROR(yr_parser_emit( ------------------ | | 134| 20.1k| { \ | | 135| 20.1k| int __error = (x); \ | | 136| 20.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 20.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 20.1k] | | ------------------ | | 137| 20.1k| return __error; \ | | 138| 20.1k| } ------------------ 1478| 20.1k| yyscanner, _yr_parser_operator_to_opcode(op, expression_type), NULL)); 1479| 20.1k| } 1480| 3.56k| else if ( 1481| 3.56k| left_operand.type == EXPRESSION_TYPE_STRING && ------------------ | | 48| 7.12k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1481:7): [True: 3.35k, False: 207] ------------------ 1482| 3.56k| right_operand.type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 3.35k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1482:7): [True: 3.28k, False: 70] ------------------ 1483| 3.28k| { 1484| 3.28k| int opcode = _yr_parser_operator_to_opcode(op, EXPRESSION_TYPE_STRING); ------------------ | | 48| 3.28k|#define EXPRESSION_TYPE_STRING 4 ------------------ 1485| | 1486| 3.28k| if (opcode != OP_ERROR) ------------------ | | 45| 3.28k|#define OP_ERROR 0 ------------------ | Branch (1486:9): [True: 3.28k, False: 1] ------------------ 1487| 3.28k| { 1488| 3.28k| FAIL_ON_ERROR(yr_parser_emit(yyscanner, opcode, NULL)); ------------------ | | 134| 3.28k| { \ | | 135| 3.28k| int __error = (x); \ | | 136| 3.28k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.28k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 3.28k] | | ------------------ | | 137| 3.28k| return __error; \ | | 138| 3.28k| } ------------------ 1489| 3.28k| } 1490| 1| else 1491| 1| { 1492| 1| yr_compiler_set_error_extra_info_fmt( ------------------ | | 312| 1| snprintf( \ | | 313| 1| compiler->last_error_extra_info, \ | | 314| 1| sizeof(compiler->last_error_extra_info), \ | | 315| 1| fmt, \ | | 316| 1| __VA_ARGS__); ------------------ 1493| 1| compiler, "strings don't support \"%s\" operation", op); 1494| | 1495| 1| return ERROR_WRONG_TYPE; ------------------ | | 69| 1|#define ERROR_WRONG_TYPE 24 ------------------ 1496| 1| } 1497| 3.28k| } 1498| 277| else 1499| 277| { 1500| 277| yr_compiler_set_error_extra_info(compiler, "type mismatch"); ------------------ | | 306| 277| strlcpy( \ | | 307| 277| compiler->last_error_extra_info, \ | | 308| 277| info, \ | | 309| 277| sizeof(compiler->last_error_extra_info)); ------------------ 1501| | 1502| 277| return ERROR_WRONG_TYPE; ------------------ | | 69| 277|#define ERROR_WRONG_TYPE 24 ------------------ 1503| 277| } 1504| | 1505| 23.4k| return ERROR_SUCCESS; ------------------ | | 40| 23.4k|#define ERROR_SUCCESS 0 ------------------ 1506| 23.6k|} parser.c:_yr_parser_check_string_modifiers: 627| 18.1k|{ 628| 18.1k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 18.1k|#define yyget_extra yara_yyget_extra ------------------ 629| | 630| | // xor and nocase together is not implemented. 631| 18.1k| if (modifier.flags & STRING_FLAGS_XOR && ------------------ | | 85| 36.3k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (631:7): [True: 1.51k, False: 16.6k] ------------------ 632| 18.1k| modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 1.51k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (632:7): [True: 0, False: 1.51k] ------------------ 633| 0| { 634| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 635| 0| compiler, "invalid modifier combination: xor nocase"); 636| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 637| 0| } 638| | 639| | // base64 and nocase together is not implemented. 640| 18.1k| if (modifier.flags & STRING_FLAGS_NO_CASE && ------------------ | | 68| 36.3k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (640:7): [True: 2.48k, False: 15.7k] ------------------ 641| 18.1k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 4.96k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (641:8): [True: 0, False: 2.48k] ------------------ 642| 2.48k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 2.48k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (642:8): [True: 0, False: 2.48k] ------------------ 643| 0| { 644| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | ------------------ | | | Branch (308:7): [True: 0, False: 0] | | ------------------ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 645| 0| compiler, 646| 0| modifier.flags & STRING_FLAGS_BASE64 647| 0| ? "invalid modifier combination: base64 nocase" 648| 0| : "invalid modifier combination: base64wide nocase"); 649| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 650| 0| } 651| | 652| | // base64 and fullword together is not implemented. 653| 18.1k| if (modifier.flags & STRING_FLAGS_FULL_WORD && ------------------ | | 73| 36.3k|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ | Branch (653:7): [True: 270, False: 17.9k] ------------------ 654| 18.1k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 540|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (654:8): [True: 0, False: 270] ------------------ 655| 270| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 270|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (655:8): [True: 0, False: 270] ------------------ 656| 0| { 657| 0| yr_compiler_set_error_extra_info( ------------------ | | 306| 0| strlcpy( \ | | 307| 0| compiler->last_error_extra_info, \ | | 308| 0| info, \ | | ------------------ | | | Branch (308:7): [True: 0, False: 0] | | ------------------ | | 309| 0| sizeof(compiler->last_error_extra_info)); ------------------ 658| 0| compiler, 659| 0| modifier.flags & STRING_FLAGS_BASE64 660| 0| ? "invalid modifier combination: base64 fullword" 661| 0| : "invalid modifier combination: base64wide fullword"); 662| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 663| 0| } 664| | 665| | // base64 and xor together is not implemented. 666| 18.1k| if (modifier.flags & STRING_FLAGS_XOR && ------------------ | | 85| 36.3k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (666:7): [True: 1.51k, False: 16.6k] ------------------ 667| 18.1k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 3.02k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (667:8): [True: 1, False: 1.50k] ------------------ 668| 1.51k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 1.50k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (668:8): [True: 7, False: 1.50k] ------------------ 669| 8| { 670| 8| yr_compiler_set_error_extra_info( ------------------ | | 306| 8| strlcpy( \ | | 307| 8| compiler->last_error_extra_info, \ | | 308| 16| info, \ | | ------------------ | | | Branch (308:7): [True: 1, False: 7] | | ------------------ | | 309| 8| sizeof(compiler->last_error_extra_info)); ------------------ 671| 8| compiler, 672| 8| modifier.flags & STRING_FLAGS_BASE64 673| 8| ? "invalid modifier combination: base64 xor" 674| 8| : "invalid modifier combination: base64wide xor"); 675| 8| return ERROR_INVALID_MODIFIER; ------------------ | | 106| 8|#define ERROR_INVALID_MODIFIER 59 ------------------ 676| 8| } 677| | 678| 18.1k| return ERROR_SUCCESS; ------------------ | | 40| 18.1k|#define ERROR_SUCCESS 0 ------------------ 679| 18.1k|} parser.c:_yr_parser_write_string: 452| 22.4k|{ 453| 22.4k| SIZED_STRING* literal_string; 454| 22.4k| YR_ATOM_LIST_ITEM* atom; 455| 22.4k| YR_ATOM_LIST_ITEM* atom_list = NULL; 456| | 457| 22.4k| int c, result; 458| 22.4k| int max_string_len; 459| 22.4k| bool free_literal = false; 460| | 461| 22.4k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 22.4k| { \ | | 135| 22.4k| int __error = (x); \ | | 136| 22.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 22.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 22.4k] | | ------------------ | | 137| 22.4k| return __error; \ | | 138| 22.4k| } ------------------ 462| 22.4k| compiler->arena, 463| 22.4k| YR_STRINGS_TABLE, 464| 22.4k| sizeof(YR_STRING), 465| 22.4k| string_ref, 466| 22.4k| offsetof(YR_STRING, identifier), 467| 22.4k| offsetof(YR_STRING, string), 468| 22.4k| offsetof(YR_STRING, chained_to), 469| 22.4k| EOL)); 470| | 471| 22.4k| YR_STRING* string = (YR_STRING*) yr_arena_ref_to_ptr( 472| 22.4k| compiler->arena, string_ref); 473| | 474| 22.4k| YR_ARENA_REF ref; 475| | 476| 22.4k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 134| 22.4k| { \ | | 135| 22.4k| int __error = (x); \ | | 136| 22.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 22.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 22.4k] | | ------------------ | | 137| 22.4k| return __error; \ | | 138| 22.4k| } ------------------ 477| | 478| 22.4k| string->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 479| 22.4k| string->rule_idx = compiler->current_rule_idx; 480| 22.4k| string->idx = compiler->current_string_idx; 481| 22.4k| string->fixed_offset = YR_UNDEFINED; ------------------ | | 38| 22.4k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 482| | 483| 22.4k| compiler->current_string_idx++; 484| | 485| 22.4k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL || ------------------ | | 67| 44.8k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (485:7): [True: 2.85k, False: 19.5k] ------------------ 486| 22.4k| modifier.flags & STRING_FLAGS_REGEXP || ------------------ | | 71| 41.9k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (486:7): [True: 14.9k, False: 4.62k] ------------------ 487| 22.4k| modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 27.0k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (487:7): [True: 1.25k, False: 3.37k] ------------------ 488| 22.4k| modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 3.37k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (488:7): [True: 699, False: 2.67k] ------------------ 489| 19.7k| { 490| 19.7k| literal_string = yr_re_ast_extract_literal(re_ast); 491| | 492| 19.7k| if (literal_string != NULL) ------------------ | Branch (492:9): [True: 10.8k, False: 8.90k] ------------------ 493| 10.8k| free_literal = true; 494| 19.7k| } 495| 2.67k| else 496| 2.67k| { 497| 2.67k| literal_string = str; 498| 2.67k| } 499| | 500| 22.4k| if (literal_string != NULL) ------------------ | Branch (500:7): [True: 13.5k, False: 8.90k] ------------------ 501| 13.5k| { 502| 13.5k| modifier.flags |= STRING_FLAGS_LITERAL; ------------------ | | 76| 13.5k|#define STRING_FLAGS_LITERAL 0x400 ------------------ 503| | 504| 13.5k| result = _yr_compiler_store_data( 505| 13.5k| compiler, 506| 13.5k| literal_string->c_string, 507| 13.5k| literal_string->length + 1, // +1 to include terminating NULL 508| 13.5k| &ref); 509| | 510| 13.5k| if (result != ERROR_SUCCESS) ------------------ | | 40| 13.5k|#define ERROR_SUCCESS 0 ------------------ | Branch (510:9): [True: 0, False: 13.5k] ------------------ 511| 0| goto cleanup; 512| | 513| 13.5k| string->length = (uint32_t) literal_string->length; 514| 13.5k| string->string = (uint8_t*) yr_arena_ref_to_ptr(compiler->arena, &ref); 515| | 516| 13.5k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 13.5k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (516:9): [True: 1.49k, False: 12.0k] ------------------ 517| 1.49k| max_string_len = string->length * 2; 518| 12.0k| else 519| 12.0k| max_string_len = string->length; 520| | 521| 13.5k| if (max_string_len <= YR_MAX_ATOM_LENGTH) ------------------ | | 67| 13.5k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (521:9): [True: 9.81k, False: 3.69k] ------------------ 522| 9.81k| modifier.flags |= STRING_FLAGS_FITS_IN_ATOM; ------------------ | | 77| 9.81k|#define STRING_FLAGS_FITS_IN_ATOM 0x800 ------------------ 523| | 524| 13.5k| result = yr_atoms_extract_from_string( 525| 13.5k| &compiler->atoms_config, 526| 13.5k| (uint8_t*) literal_string->c_string, 527| 13.5k| (int32_t) literal_string->length, 528| 13.5k| modifier, 529| 13.5k| &atom_list, 530| 13.5k| min_atom_quality); 531| | 532| 13.5k| if (result != ERROR_SUCCESS) ------------------ | | 40| 13.5k|#define ERROR_SUCCESS 0 ------------------ | Branch (532:9): [True: 0, False: 13.5k] ------------------ 533| 0| goto cleanup; 534| 13.5k| } 535| 8.90k| else 536| 8.90k| { 537| | // Non-literal strings can't be marked as fixed offset because once we 538| | // find a string atom in the scanned data we don't know the offset where 539| | // the string should start, as the non-literal strings can contain 540| | // variable-length portions. 541| 8.90k| modifier.flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 8.90k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 542| | 543| | // Save the position where the RE forward code starts for later reference. 544| 8.90k| yr_arena_off_t forward_code_start = yr_arena_get_current_offset( 545| 8.90k| compiler->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 8.90k|#define YR_RE_CODE_SECTION 7 ------------------ 546| | 547| | // Emit forwards code 548| 8.90k| result = yr_re_ast_emit_code(re_ast, compiler->arena, false); 549| | 550| 8.90k| if (result != ERROR_SUCCESS) ------------------ | | 40| 8.90k|#define ERROR_SUCCESS 0 ------------------ | Branch (550:9): [True: 115, False: 8.78k] ------------------ 551| 115| goto cleanup; 552| | 553| | // Emit backwards code 554| 8.78k| result = yr_re_ast_emit_code(re_ast, compiler->arena, true); 555| | 556| 8.78k| if (result != ERROR_SUCCESS) ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ | Branch (556:9): [True: 3, False: 8.78k] ------------------ 557| 3| goto cleanup; 558| | 559| | // Extract atoms from the regular expression. 560| 8.78k| result = yr_atoms_extract_from_re( 561| 8.78k| &compiler->atoms_config, 562| 8.78k| re_ast, 563| 8.78k| modifier, 564| 8.78k| &atom_list, 565| 8.78k| min_atom_quality); 566| | 567| 8.78k| if (result != ERROR_SUCCESS) ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ | Branch (567:9): [True: 0, False: 8.78k] ------------------ 568| 0| goto cleanup; 569| | 570| | // If no atom was extracted let's add a zero-length atom. 571| 8.78k| if (atom_list == NULL) ------------------ | Branch (571:9): [True: 3.46k, False: 5.31k] ------------------ 572| 3.46k| { 573| 3.46k| atom_list = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 574| | 575| 3.46k| if (atom_list == NULL) ------------------ | Branch (575:11): [True: 0, False: 3.46k] ------------------ 576| 0| { 577| 0| result = ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 578| 0| goto cleanup; 579| 0| } 580| | 581| 3.46k| atom_list->atom.length = 0; 582| 3.46k| atom_list->backtrack = 0; 583| 3.46k| atom_list->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 3.46k| (YR_ARENA_REF) \ | | 44| 3.46k| { \ | | 45| 3.46k| UINT32_MAX, UINT32_MAX \ | | 46| 3.46k| } ------------------ 584| 3.46k| atom_list->next = NULL; 585| | 586| 3.46k| yr_arena_ptr_to_ref( 587| 3.46k| compiler->arena, 588| 3.46k| yr_arena_get_ptr( 589| 3.46k| compiler->arena, YR_RE_CODE_SECTION, forward_code_start), ------------------ | | 64| 3.46k|#define YR_RE_CODE_SECTION 7 ------------------ 590| 3.46k| &(atom_list->forward_code_ref)); 591| 3.46k| } 592| 8.78k| } 593| | 594| 22.2k| string->flags = modifier.flags; 595| | 596| | // Add the string to Aho-Corasick automaton. 597| 22.2k| result = yr_ac_add_string( 598| 22.2k| compiler->automaton, string, string->idx, atom_list, compiler->arena); 599| | 600| 22.2k| if (result != ERROR_SUCCESS) ------------------ | | 40| 22.2k|#define ERROR_SUCCESS 0 ------------------ | Branch (600:7): [True: 0, False: 22.2k] ------------------ 601| 0| goto cleanup; 602| | 603| 22.2k| atom = atom_list; 604| 22.2k| c = 0; 605| | 606| 4.84M| while (atom != NULL) ------------------ | Branch (606:10): [True: 4.82M, False: 22.2k] ------------------ 607| 4.82M| { 608| 4.82M| atom = atom->next; 609| 4.82M| c++; 610| 4.82M| } 611| | 612| 22.2k| (*num_atom) += c; 613| | 614| 22.4k|cleanup: 615| 22.4k| if (free_literal) ------------------ | Branch (615:7): [True: 10.8k, False: 11.5k] ------------------ 616| 10.8k| yr_free(literal_string); 617| | 618| 22.4k| if (atom_list != NULL) ------------------ | Branch (618:7): [True: 22.2k, False: 118] ------------------ 619| 22.2k| yr_atoms_list_destroy(atom_list); 620| | 621| 22.4k| return result; 622| 22.2k|} parser.c:wildcard_iterator: 969| 1.27k|{ 970| 1.27k| const char* identifier = (const char*) data; 971| | 972| | // If the identifier is prefixed by prefix, then it matches the wildcard. 973| 1.27k| if (!strncmp(prefix, identifier, prefix_len)) ------------------ | Branch (973:7): [True: 180, False: 1.09k] ------------------ 974| 180| return ERROR_IDENTIFIER_MATCHES_WILDCARD; ------------------ | | 110| 180|#define ERROR_IDENTIFIER_MATCHES_WILDCARD 63 ------------------ 975| | 976| 1.09k| return ERROR_SUCCESS; ------------------ | | 40| 1.09k|#define ERROR_SUCCESS 0 ------------------ 977| 1.27k|} parser.c:_yr_parser_valid_module_name: 1308| 1.91k|{ 1309| 1.91k| if (module_name->length == 0) ------------------ | Branch (1309:7): [True: 164, False: 1.75k] ------------------ 1310| 164| return false; 1311| | 1312| 1.75k| if (strlen(module_name->c_string) != module_name->length) ------------------ | Branch (1312:7): [True: 289, False: 1.46k] ------------------ 1313| 289| return false; 1314| | 1315| 1.46k| return true; 1316| 1.75k|} parser.c:_yr_parser_operator_to_opcode: 1377| 23.4k|{ 1378| 23.4k| int opcode = 0; 1379| | 1380| 23.4k| switch (expression_type) 1381| 23.4k| { 1382| 15.0k| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 15.0k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1382:3): [True: 15.0k, False: 8.37k] ------------------ 1383| 15.0k| opcode = OP_INT_BEGIN; ------------------ | | 141| 15.0k|#define OP_INT_BEGIN 100 ------------------ 1384| 15.0k| break; 1385| 5.09k| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 5.09k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1385:3): [True: 5.09k, False: 18.3k] ------------------ 1386| 5.09k| opcode = OP_DBL_BEGIN; ------------------ | | 155| 5.09k|#define OP_DBL_BEGIN 120 ------------------ 1387| 5.09k| break; 1388| 3.28k| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 3.28k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1388:3): [True: 3.28k, False: 20.1k] ------------------ 1389| 3.28k| opcode = OP_STR_BEGIN; ------------------ | | 169| 3.28k|#define OP_STR_BEGIN 140 ------------------ 1390| 3.28k| break; 1391| 0| default: ------------------ | Branch (1391:3): [True: 0, False: 23.4k] ------------------ 1392| 0| assert(false); 1393| 23.4k| } 1394| | 1395| 23.4k| if (op[0] == '<') ------------------ | Branch (1395:7): [True: 5.05k, False: 18.3k] ------------------ 1396| 5.05k| { 1397| 5.05k| if (op[1] == '=') ------------------ | Branch (1397:9): [True: 3.77k, False: 1.27k] ------------------ 1398| 3.77k| opcode += _OP_LE; ------------------ | | 133| 3.77k|#define _OP_LE 4 ------------------ 1399| 1.27k| else 1400| 1.27k| opcode += _OP_LT; ------------------ | | 131| 1.27k|#define _OP_LT 2 ------------------ 1401| 5.05k| } 1402| 18.3k| else if (op[0] == '>') ------------------ | Branch (1402:12): [True: 1.67k, False: 16.6k] ------------------ 1403| 1.67k| { 1404| 1.67k| if (op[1] == '=') ------------------ | Branch (1404:9): [True: 660, False: 1.01k] ------------------ 1405| 660| opcode += _OP_GE; ------------------ | | 134| 660|#define _OP_GE 5 ------------------ 1406| 1.01k| else 1407| 1.01k| opcode += _OP_GT; ------------------ | | 132| 1.01k|#define _OP_GT 3 ------------------ 1408| 1.67k| } 1409| 16.6k| else if (op[1] == '=') ------------------ | Branch (1409:12): [True: 1.46k, False: 15.2k] ------------------ 1410| 1.46k| { 1411| 1.46k| if (op[0] == '=') ------------------ | Branch (1411:9): [True: 798, False: 670] ------------------ 1412| 798| opcode += _OP_EQ; ------------------ | | 129| 798|#define _OP_EQ 0 ------------------ 1413| 670| else 1414| 670| opcode += _OP_NEQ; ------------------ | | 130| 670|#define _OP_NEQ 1 ------------------ 1415| 1.46k| } 1416| 15.2k| else if (op[0] == '+') ------------------ | Branch (1416:12): [True: 4.84k, False: 10.3k] ------------------ 1417| 4.84k| { 1418| 4.84k| opcode += _OP_ADD; ------------------ | | 135| 4.84k|#define _OP_ADD 6 ------------------ 1419| 4.84k| } 1420| 10.3k| else if (op[0] == '-') ------------------ | Branch (1420:12): [True: 5.69k, False: 4.66k] ------------------ 1421| 5.69k| { 1422| 5.69k| opcode += _OP_SUB; ------------------ | | 136| 5.69k|#define _OP_SUB 7 ------------------ 1423| 5.69k| } 1424| 4.66k| else if (op[0] == '*') ------------------ | Branch (1424:12): [True: 2.78k, False: 1.88k] ------------------ 1425| 2.78k| { 1426| 2.78k| opcode += _OP_MUL; ------------------ | | 137| 2.78k|#define _OP_MUL 8 ------------------ 1427| 2.78k| } 1428| 1.88k| else if (op[0] == '\\') ------------------ | Branch (1428:12): [True: 1.88k, False: 0] ------------------ 1429| 1.88k| { 1430| 1.88k| opcode += _OP_DIV; ------------------ | | 138| 1.88k|#define _OP_DIV 9 ------------------ 1431| 1.88k| } 1432| | 1433| 23.4k| if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 178| 46.8k|#define IS_INT_OP(x) ((x) >= OP_INT_BEGIN && (x) <= OP_INT_END) | | ------------------ | | | | 141| 46.8k|#define OP_INT_BEGIN 100 | | ------------------ | | #define IS_INT_OP(x) ((x) >= OP_INT_BEGIN && (x) <= OP_INT_END) | | ------------------ | | | | 153| 23.4k|#define OP_INT_END OP_INT_MINUS | | | | ------------------ | | | | | | 152| 23.4k|#define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 141| 23.4k|#define OP_INT_BEGIN 100 | | | | | | ------------------ | | | | | | #define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 139| 23.4k|#define _OP_MINUS 10 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (178:23): [True: 23.4k, False: 0] | | | Branch (178:46): [True: 15.0k, False: 8.37k] | | ------------------ ------------------ if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 179| 31.7k|#define IS_DBL_OP(x) ((x) >= OP_DBL_BEGIN && (x) <= OP_DBL_END) | | ------------------ | | | | 155| 16.7k|#define OP_DBL_BEGIN 120 | | ------------------ | | #define IS_DBL_OP(x) ((x) >= OP_DBL_BEGIN && (x) <= OP_DBL_END) | | ------------------ | | | | 167| 8.37k|#define OP_DBL_END OP_DBL_MINUS | | | | ------------------ | | | | | | 166| 8.37k|#define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 155| 8.37k|#define OP_DBL_BEGIN 120 | | | | | | ------------------ | | | | | | #define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 139| 8.37k|#define _OP_MINUS 10 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (179:23): [True: 8.37k, False: 0] | | | Branch (179:46): [True: 5.09k, False: 3.28k] | | ------------------ ------------------ if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 180| 3.28k|#define IS_STR_OP(x) ((x) >= OP_STR_BEGIN && (x) <= OP_STR_END) | | ------------------ | | | | 169| 6.57k|#define OP_STR_BEGIN 140 | | ------------------ | | #define IS_STR_OP(x) ((x) >= OP_STR_BEGIN && (x) <= OP_STR_END) | | ------------------ | | | | 176| 3.28k|#define OP_STR_END OP_STR_GE | | | | ------------------ | | | | | | 175| 3.28k|#define OP_STR_GE (OP_STR_BEGIN + _OP_GE) | | | | | | ------------------ | | | | | | | | 169| 3.28k|#define OP_STR_BEGIN 140 | | | | | | ------------------ | | | | | | #define OP_STR_GE (OP_STR_BEGIN + _OP_GE) | | | | | | ------------------ | | | | | | | | 134| 3.28k|#define _OP_GE 5 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (180:23): [True: 3.28k, False: 0] | | | Branch (180:46): [True: 3.28k, False: 1] | | ------------------ ------------------ 1434| 23.4k| { 1435| 23.4k| return opcode; 1436| 23.4k| } 1437| | 1438| 1| return OP_ERROR; ------------------ | | 45| 1|#define OP_ERROR 0 ------------------ 1439| 23.4k|} yr_re_node_create: 125| 2.65M|{ 126| 2.65M| RE_NODE* result = (RE_NODE*) yr_malloc(sizeof(RE_NODE)); 127| | 128| 2.65M| if (result != NULL) ------------------ | Branch (128:7): [True: 2.65M, False: 0] ------------------ 129| 2.65M| { 130| 2.65M| result->type = type; 131| 2.65M| result->children_head = NULL; 132| 2.65M| result->children_tail = NULL; 133| 2.65M| result->prev_sibling = NULL; 134| 2.65M| result->next_sibling = NULL; 135| 2.65M| result->greedy = true; 136| 2.65M| result->forward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 2.65M| (YR_ARENA_REF) \ | | 44| 2.65M| { \ | | 45| 2.65M| UINT32_MAX, UINT32_MAX \ | | 46| 2.65M| } ------------------ 137| 2.65M| result->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 2.65M| (YR_ARENA_REF) \ | | 44| 2.65M| { \ | | 45| 2.65M| UINT32_MAX, UINT32_MAX \ | | 46| 2.65M| } ------------------ 138| 2.65M| } 139| | 140| 2.65M| return result; 141| 2.65M|} yr_re_node_destroy: 144| 2.65M|{ 145| 2.65M| RE_NODE* child = node->children_head; 146| 2.65M| RE_NODE* next_child; 147| | 148| 5.28M| while (child != NULL) ------------------ | Branch (148:10): [True: 2.62M, False: 2.65M] ------------------ 149| 2.62M| { 150| 2.62M| next_child = child->next_sibling; 151| 2.62M| yr_re_node_destroy(child); 152| 2.62M| child = next_child; 153| 2.62M| } 154| | 155| 2.65M| if (node->type == RE_NODE_CLASS) ------------------ | | 49| 2.65M|#define RE_NODE_CLASS 9 ------------------ | Branch (155:7): [True: 944, False: 2.65M] ------------------ 156| 944| yr_free(node->re_class); 157| | 158| 2.65M| yr_free(node); 159| 2.65M|} yr_re_node_append_child: 165| 2.62M|{ 166| 2.62M| if (node->children_head == NULL) ------------------ | Branch (166:7): [True: 116k, False: 2.51M] ------------------ 167| 116k| node->children_head = child; 168| | 169| 2.62M| if (node->children_tail != NULL) ------------------ | Branch (169:7): [True: 2.51M, False: 116k] ------------------ 170| 2.51M| node->children_tail->next_sibling = child; 171| | 172| 2.62M| child->prev_sibling = node->children_tail; 173| 2.62M| node->children_tail = child; 174| 2.62M|} yr_re_node_prepend_child: 180| 2.04k|{ 181| 2.04k| child->next_sibling = node->children_head; 182| | 183| 2.04k| if (node->children_head != NULL) ------------------ | Branch (183:7): [True: 2.04k, False: 0] ------------------ 184| 2.04k| node->children_head->prev_sibling = child; 185| | 186| 2.04k| node->children_head = child; 187| | 188| 2.04k| if (node->children_tail == NULL) ------------------ | Branch (188:7): [True: 0, False: 2.04k] ------------------ 189| 0| node->children_tail = child; 190| 2.04k|} yr_re_ast_create: 193| 22.2k|{ 194| 22.2k| *re_ast = (RE_AST*) yr_malloc(sizeof(RE_AST)); 195| | 196| 22.2k| if (*re_ast == NULL) ------------------ | Branch (196:7): [True: 0, False: 22.2k] ------------------ 197| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 198| | 199| 22.2k| (*re_ast)->flags = 0; 200| 22.2k| (*re_ast)->root_node = NULL; 201| | 202| 22.2k| return ERROR_SUCCESS; ------------------ | | 40| 22.2k|#define ERROR_SUCCESS 0 ------------------ 203| 22.2k|} yr_re_ast_destroy: 206| 22.2k|{ 207| 22.2k| if (re_ast->root_node != NULL) ------------------ | Branch (207:7): [True: 21.6k, False: 595] ------------------ 208| 21.6k| yr_re_node_destroy(re_ast->root_node); 209| | 210| 22.2k| yr_free(re_ast); 211| 22.2k|} yr_re_parse: 222| 15.9k|{ 223| 15.9k| return yr_parse_re_string(re_string, re_ast, error, flags); 224| 15.9k|} yr_re_parse_hex: 231| 1.27k|{ 232| 1.27k| return yr_parse_hex_string(hex_string, re_ast, error); 233| 1.27k|} yr_re_compile: 246| 1.76k|{ 247| 1.76k| RE_AST* re_ast; 248| 1.76k| RE _re; 249| 1.76k| int result; 250| | 251| 1.76k| result = yr_re_parse(re_string, &re_ast, error, parser_flags); 252| 1.76k| if (result != ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 1.76k|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (252:7): [True: 1.76k, False: 0] ------------------ 253| 1.76k| FAIL_ON_ERROR(result); ------------------ | | 134| 1.76k| { \ | | 135| 1.76k| int __error = (x); \ | | 136| 1.76k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.76k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 182, False: 1.57k] | | ------------------ | | 137| 1.76k| return __error; \ | | 138| 1.76k| } ------------------ 254| | 255| 1.57k| _re.flags = flags; 256| | 257| 1.57k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.57k| { \ | | 143| 1.57k| int __error = (x); \ | | 144| 1.57k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.57k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 1.57k] | | ------------------ | | 145| 1.57k| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 1.57k| } ------------------ 258| 1.57k| yr_arena_write_data(arena, YR_RE_CODE_SECTION, &_re, sizeof(_re), ref), 259| 1.57k| yr_re_ast_destroy(re_ast)); 260| | 261| 1.57k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 142| 1.57k| { \ | | 143| 1.57k| int __error = (x); \ | | 144| 1.57k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.57k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 22, False: 1.55k] | | ------------------ | | 145| 1.57k| { \ | | 146| 22| cleanup; \ | | 147| 22| return __error; \ | | 148| 22| } \ | | 149| 1.57k| } ------------------ 262| 1.57k| yr_re_ast_emit_code(re_ast, arena, false), yr_re_ast_destroy(re_ast)); 263| | 264| 1.55k| yr_re_ast_destroy(re_ast); 265| | 266| 1.55k| return result; 267| 1.57k|} yr_re_ast_extract_literal: 307| 19.7k|{ 308| 19.7k| SIZED_STRING* string; 309| 19.7k| RE_NODE* child; 310| | 311| 19.7k| int length = 0; 312| | 313| 19.7k| if (re_ast->root_node->type == RE_NODE_LITERAL) ------------------ | | 41| 19.7k|#define RE_NODE_LITERAL 1 ------------------ | Branch (313:7): [True: 242, False: 19.4k] ------------------ 314| 242| { 315| 242| length = 1; 316| 242| } 317| 19.4k| else if (re_ast->root_node->type == RE_NODE_CONCAT) ------------------ | | 44| 19.4k|#define RE_NODE_CONCAT 4 ------------------ | Branch (317:12): [True: 18.4k, False: 1.03k] ------------------ 318| 18.4k| { 319| 18.4k| child = re_ast->root_node->children_tail; 320| | 321| 78.5k| while (child != NULL && child->type == RE_NODE_LITERAL) ------------------ | | 41| 67.9k|#define RE_NODE_LITERAL 1 ------------------ | Branch (321:12): [True: 67.9k, False: 10.5k] | Branch (321:29): [True: 60.1k, False: 7.86k] ------------------ 322| 60.1k| { 323| 60.1k| length++; 324| 60.1k| child = child->prev_sibling; 325| 60.1k| } 326| | 327| 18.4k| if (child != NULL) ------------------ | Branch (327:9): [True: 7.86k, False: 10.5k] ------------------ 328| 7.86k| return NULL; 329| 18.4k| } 330| 1.03k| else 331| 1.03k| { 332| 1.03k| return NULL; 333| 1.03k| } 334| | 335| 10.8k| string = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 336| | 337| 10.8k| if (string == NULL) ------------------ | Branch (337:7): [True: 0, False: 10.8k] ------------------ 338| 0| return NULL; 339| | 340| 10.8k| string->length = length; 341| 10.8k| string->flags = 0; 342| | 343| 10.8k| if (re_ast->root_node->type == RE_NODE_LITERAL) ------------------ | | 41| 10.8k|#define RE_NODE_LITERAL 1 ------------------ | Branch (343:7): [True: 242, False: 10.5k] ------------------ 344| 242| { 345| 242| string->c_string[0] = re_ast->root_node->value; 346| 242| } 347| 10.5k| else 348| 10.5k| { 349| 10.5k| child = re_ast->root_node->children_tail; 350| | 351| 65.2k| while (child != NULL) ------------------ | Branch (351:12): [True: 54.6k, False: 10.5k] ------------------ 352| 54.6k| { 353| 54.6k| string->c_string[--length] = child->value; 354| 54.6k| child = child->prev_sibling; 355| 54.6k| } 356| 10.5k| } 357| | 358| 10.8k| string->c_string[string->length] = '\0'; 359| | 360| 10.8k| return string; 361| 10.8k|} _yr_re_node_has_unbounded_quantifier_for_dot: 364| 93.5k|{ 365| 93.5k| RE_NODE* child; 366| | 367| 93.5k| if ((re_node->type == RE_NODE_STAR || re_node->type == RE_NODE_PLUS) && ------------------ | | 47| 187k|#define RE_NODE_STAR 7 ------------------ if ((re_node->type == RE_NODE_STAR || re_node->type == RE_NODE_PLUS) && ------------------ | | 48| 93.1k|#define RE_NODE_PLUS 8 ------------------ | Branch (367:8): [True: 364, False: 93.1k] | Branch (367:41): [True: 624, False: 92.5k] ------------------ 368| 93.5k| re_node->children_head->type == RE_NODE_ANY) ------------------ | | 43| 988|#define RE_NODE_ANY 3 ------------------ | Branch (368:7): [True: 399, False: 589] ------------------ 369| 399| return true; 370| | 371| 93.1k| if (re_node->type == RE_NODE_RANGE_ANY && re_node->end == RE_MAX_RANGE) ------------------ | | 61| 186k|#define RE_NODE_RANGE_ANY 21 ------------------ if (re_node->type == RE_NODE_RANGE_ANY && re_node->end == RE_MAX_RANGE) ------------------ | | 39| 5.80k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (371:7): [True: 5.80k, False: 87.3k] | Branch (371:45): [True: 573, False: 5.23k] ------------------ 372| 573| return true; 373| | 374| 92.5k| if (re_node->type == RE_NODE_CONCAT) ------------------ | | 44| 92.5k|#define RE_NODE_CONCAT 4 ------------------ | Branch (374:7): [True: 14.4k, False: 78.0k] ------------------ 375| 14.4k| { 376| 14.4k| child = re_node->children_tail; 377| | 378| 92.1k| while (child != NULL) ------------------ | Branch (378:12): [True: 78.7k, False: 13.3k] ------------------ 379| 78.7k| { 380| 78.7k| if (_yr_re_node_has_unbounded_quantifier_for_dot(child)) ------------------ | Branch (380:11): [True: 1.09k, False: 77.6k] ------------------ 381| 1.09k| return true; 382| | 383| 77.6k| child = child->prev_sibling; 384| 77.6k| } 385| 14.4k| } 386| | 387| 91.4k| return false; 388| 92.5k|} yr_re_ast_has_unbounded_quantifier_for_dot: 397| 14.7k|{ 398| 14.7k| return _yr_re_node_has_unbounded_quantifier_for_dot(re_ast->root_node); 399| 14.7k|} yr_re_ast_split_at_chaining_point: 465| 19.7k|{ 466| 19.7k| RE_NODE* child; 467| 19.7k| RE_NODE* concat; 468| | 469| 19.7k| int result; 470| | 471| 19.7k| *remainder_re_ast = NULL; 472| 19.7k| *min_gap = 0; 473| 19.7k| *max_gap = 0; 474| | 475| 19.7k| if (re_ast->root_node->type != RE_NODE_CONCAT) ------------------ | | 44| 19.7k|#define RE_NODE_CONCAT 4 ------------------ | Branch (475:7): [True: 1.28k, False: 18.4k] ------------------ 476| 1.28k| return ERROR_SUCCESS; ------------------ | | 40| 1.28k|#define ERROR_SUCCESS 0 ------------------ 477| | 478| 18.4k| child = re_ast->root_node->children_head; 479| | 480| 105k| while (child != NULL) ------------------ | Branch (480:10): [True: 91.8k, False: 13.4k] ------------------ 481| 91.8k| { 482| 91.8k| if (!child->greedy && child->type == RE_NODE_RANGE_ANY && ------------------ | | 61| 100k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (482:9): [True: 8.82k, False: 83.0k] | Branch (482:27): [True: 8.26k, False: 554] ------------------ 483| 91.8k| child->prev_sibling != NULL && child->next_sibling != NULL && ------------------ | Branch (483:9): [True: 6.44k, False: 1.82k] | Branch (483:40): [True: 5.91k, False: 527] ------------------ 484| 91.8k| (child->start > YR_STRING_CHAINING_THRESHOLD || ------------------ | | 142| 11.8k|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (484:10): [True: 1.65k, False: 4.25k] ------------------ 485| 5.91k| child->end > YR_STRING_CHAINING_THRESHOLD)) ------------------ | | 142| 4.25k|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (485:10): [True: 3.34k, False: 909] ------------------ 486| 5.00k| { 487| 5.00k| result = yr_re_ast_create(remainder_re_ast); 488| | 489| 5.00k| if (result != ERROR_SUCCESS) ------------------ | | 40| 5.00k|#define ERROR_SUCCESS 0 ------------------ | Branch (489:11): [True: 0, False: 5.00k] ------------------ 490| 0| return result; 491| | 492| 5.00k| concat = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 5.00k|#define RE_NODE_CONCAT 4 ------------------ 493| | 494| 5.00k| if (concat == NULL) ------------------ | Branch (494:11): [True: 0, False: 5.00k] ------------------ 495| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 496| | 497| 5.00k| concat->children_head = child->next_sibling; 498| 5.00k| concat->children_tail = re_ast->root_node->children_tail; 499| | 500| 5.00k| re_ast->root_node->children_tail = child->prev_sibling; 501| | 502| 5.00k| child->prev_sibling->next_sibling = NULL; 503| 5.00k| child->next_sibling->prev_sibling = NULL; 504| | 505| 5.00k| *min_gap = child->start; 506| 5.00k| *max_gap = child->end; 507| | 508| 5.00k| (*remainder_re_ast)->root_node = concat; 509| 5.00k| (*remainder_re_ast)->flags = re_ast->flags; 510| | 511| 5.00k| yr_re_node_destroy(child); 512| | 513| 5.00k| return ERROR_SUCCESS; ------------------ | | 40| 5.00k|#define ERROR_SUCCESS 0 ------------------ 514| 5.00k| } 515| | 516| 86.8k| child = child->next_sibling; 517| 86.8k| } 518| | 519| 13.4k| return ERROR_SUCCESS; ------------------ | | 40| 13.4k|#define ERROR_SUCCESS 0 ------------------ 520| 18.4k|} _yr_emit_inst: 526| 54.5M|{ 527| 54.5M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 54.5M| { \ | | 135| 54.5M| int __error = (x); \ | | 136| 54.5M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 54.5M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 54.5M] | | ------------------ | | 137| 54.5M| return __error; \ | | 138| 54.5M| } ------------------ 528| 54.5M| emit_context->arena, 529| 54.5M| YR_RE_CODE_SECTION, 530| 54.5M| &opcode, 531| 54.5M| sizeof(uint8_t), 532| 54.5M| instruction_ref)); 533| | 534| 54.5M| return ERROR_SUCCESS; ------------------ | | 40| 54.5M|#define ERROR_SUCCESS 0 ------------------ 535| 54.5M|} _yr_emit_inst_arg_uint8: 543| 77.8M|{ 544| 77.8M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 77.8M| { \ | | 135| 77.8M| int __error = (x); \ | | 136| 77.8M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 77.8M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 77.8M] | | ------------------ | | 137| 77.8M| return __error; \ | | 138| 77.8M| } ------------------ 545| 77.8M| emit_context->arena, 546| 77.8M| YR_RE_CODE_SECTION, 547| 77.8M| &opcode, 548| 77.8M| sizeof(uint8_t), 549| 77.8M| instruction_ref)); 550| | 551| 77.8M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 77.8M| { \ | | 135| 77.8M| int __error = (x); \ | | 136| 77.8M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 77.8M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 77.8M] | | ------------------ | | 137| 77.8M| return __error; \ | | 138| 77.8M| } ------------------ 552| 77.8M| emit_context->arena, 553| 77.8M| YR_RE_CODE_SECTION, 554| 77.8M| &argument, 555| 77.8M| sizeof(uint8_t), 556| 77.8M| argument_ref)); 557| | 558| 77.8M| return ERROR_SUCCESS; ------------------ | | 40| 77.8M|#define ERROR_SUCCESS 0 ------------------ 559| 77.8M|} _yr_emit_inst_arg_uint16: 567| 7.41k|{ 568| 7.41k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 7.41k| { \ | | 135| 7.41k| int __error = (x); \ | | 136| 7.41k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.41k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 7.41k] | | ------------------ | | 137| 7.41k| return __error; \ | | 138| 7.41k| } ------------------ 569| 7.41k| emit_context->arena, 570| 7.41k| YR_RE_CODE_SECTION, 571| 7.41k| &opcode, 572| 7.41k| sizeof(uint8_t), 573| 7.41k| instruction_ref)); 574| | 575| 7.41k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 7.41k| { \ | | 135| 7.41k| int __error = (x); \ | | 136| 7.41k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.41k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 7.41k] | | ------------------ | | 137| 7.41k| return __error; \ | | 138| 7.41k| } ------------------ 576| 7.41k| emit_context->arena, 577| 7.41k| YR_RE_CODE_SECTION, 578| 7.41k| &argument, 579| 7.41k| sizeof(uint16_t), 580| 7.41k| argument_ref)); 581| | 582| 7.41k| return ERROR_SUCCESS; ------------------ | | 40| 7.41k|#define ERROR_SUCCESS 0 ------------------ 583| 7.41k|} _yr_emit_inst_arg_int16: 615| 31.7k|{ 616| 31.7k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 31.7k| { \ | | 135| 31.7k| int __error = (x); \ | | 136| 31.7k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 31.7k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 31.7k] | | ------------------ | | 137| 31.7k| return __error; \ | | 138| 31.7k| } ------------------ 617| 31.7k| emit_context->arena, 618| 31.7k| YR_RE_CODE_SECTION, 619| 31.7k| &opcode, 620| 31.7k| sizeof(uint8_t), 621| 31.7k| instruction_ref)); 622| | 623| 31.7k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 31.7k| { \ | | 135| 31.7k| int __error = (x); \ | | 136| 31.7k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 31.7k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 31.7k] | | ------------------ | | 137| 31.7k| return __error; \ | | 138| 31.7k| } ------------------ 624| 31.7k| emit_context->arena, 625| 31.7k| YR_RE_CODE_SECTION, 626| 31.7k| &argument, 627| 31.7k| sizeof(int16_t), 628| 31.7k| argument_ref)); 629| | 630| 31.7k| return ERROR_SUCCESS; ------------------ | | 40| 31.7k|#define ERROR_SUCCESS 0 ------------------ 631| 31.7k|} _yr_emit_inst_arg_struct: 640| 29.5M|{ 641| 29.5M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 29.5M| { \ | | 135| 29.5M| int __error = (x); \ | | 136| 29.5M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 29.5M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 29.5M] | | ------------------ | | 137| 29.5M| return __error; \ | | 138| 29.5M| } ------------------ 642| 29.5M| emit_context->arena, 643| 29.5M| YR_RE_CODE_SECTION, 644| 29.5M| &opcode, 645| 29.5M| sizeof(uint8_t), 646| 29.5M| instruction_ref)); 647| | 648| 29.5M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 29.5M| { \ | | 135| 29.5M| int __error = (x); \ | | 136| 29.5M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 29.5M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 29.5M] | | ------------------ | | 137| 29.5M| return __error; \ | | 138| 29.5M| } ------------------ 649| 29.5M| emit_context->arena, 650| 29.5M| YR_RE_CODE_SECTION, 651| 29.5M| structure, 652| 29.5M| structure_size, 653| 29.5M| argument_ref)); 654| | 655| 29.5M| return ERROR_SUCCESS; ------------------ | | 40| 29.5M|#define ERROR_SUCCESS 0 ------------------ 656| 29.5M|} _yr_emit_split: 664| 37.6k|{ 665| 37.6k| assert(opcode == RE_OPCODE_SPLIT_A || opcode == RE_OPCODE_SPLIT_B); 666| | 667| 37.6k| if (emit_context->next_split_id == RE_MAX_SPLIT_ID) ------------------ | | 164| 37.6k|#define RE_MAX_SPLIT_ID 128 ------------------ | Branch (667:7): [True: 81, False: 37.6k] ------------------ 668| 81| return ERROR_REGULAR_EXPRESSION_TOO_COMPLEX; ------------------ | | 96| 81|#define ERROR_REGULAR_EXPRESSION_TOO_COMPLEX 49 ------------------ 669| | 670| 37.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 37.6k| { \ | | 135| 37.6k| int __error = (x); \ | | 136| 37.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 37.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 37.6k] | | ------------------ | | 137| 37.6k| return __error; \ | | 138| 37.6k| } ------------------ 671| 37.6k| emit_context->arena, 672| 37.6k| YR_RE_CODE_SECTION, 673| 37.6k| &opcode, 674| 37.6k| sizeof(uint8_t), 675| 37.6k| instruction_ref)); 676| | 677| 37.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 37.6k| { \ | | 135| 37.6k| int __error = (x); \ | | 136| 37.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 37.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 37.6k] | | ------------------ | | 137| 37.6k| return __error; \ | | 138| 37.6k| } ------------------ 678| 37.6k| emit_context->arena, 679| 37.6k| YR_RE_CODE_SECTION, 680| 37.6k| &emit_context->next_split_id, 681| 37.6k| sizeof(RE_SPLIT_ID_TYPE), 682| 37.6k| NULL)); 683| | 684| 37.6k| emit_context->next_split_id++; 685| | 686| 37.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 37.6k| { \ | | 135| 37.6k| int __error = (x); \ | | 136| 37.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 37.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 37.6k] | | ------------------ | | 137| 37.6k| return __error; \ | | 138| 37.6k| } ------------------ 687| 37.6k| emit_context->arena, 688| 37.6k| YR_RE_CODE_SECTION, 689| 37.6k| &argument, 690| 37.6k| sizeof(int16_t), 691| 37.6k| argument_ref)); 692| | 693| 37.6k| return ERROR_SUCCESS; ------------------ | | 40| 37.6k|#define ERROR_SUCCESS 0 ------------------ 694| 37.6k|} yr_re_ast_emit_code: 1204| 19.2k|{ 1205| 19.2k| RE_EMIT_CONTEXT emit_context; 1206| | 1207| | // Emit code for matching the regular expressions forwards. 1208| 19.2k| emit_context.arena = arena; 1209| 19.2k| emit_context.next_split_id = 0; 1210| | 1211| 19.2k| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 19.2k| { \ | | 135| 38.5k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 8.78k, False: 10.4k] | | ------------------ | | 136| 19.2k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 19.2k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 140, False: 19.1k] | | ------------------ | | 137| 19.2k| return __error; \ | | 138| 19.2k| } ------------------ 1212| 19.2k| &emit_context, 1213| 19.2k| re_ast->root_node, 1214| 19.2k| backwards_code ? EMIT_BACKWARDS : 0, 1215| 19.2k| NULL)); 1216| | 1217| 19.1k| FAIL_ON_ERROR(_yr_emit_inst(&emit_context, RE_OPCODE_MATCH, NULL)); ------------------ | | 134| 19.1k| { \ | | 135| 19.1k| int __error = (x); \ | | 136| 19.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 19.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 19.1k] | | ------------------ | | 137| 19.1k| return __error; \ | | 138| 19.1k| } ------------------ 1218| | 1219| 19.1k| return ERROR_SUCCESS; ------------------ | | 40| 19.1k|#define ERROR_SUCCESS 0 ------------------ 1220| 19.1k|} re.c:_yr_re_emit: 701| 162M|{ 702| 162M| int16_t jmp_offset; 703| | 704| 162M| yr_arena_off_t bookmark_1 = 0; 705| 162M| yr_arena_off_t bookmark_2 = 0; 706| 162M| yr_arena_off_t bookmark_3 = 0; 707| 162M| yr_arena_off_t bookmark_4 = 0; 708| | 709| 162M| bool emit_split; 710| 162M| bool emit_repeat; 711| 162M| bool emit_prolog; 712| 162M| bool emit_epilog; 713| | 714| 162M| RE_REPEAT_ARGS repeat_args; 715| 162M| RE_REPEAT_ARGS* repeat_start_args_addr; 716| 162M| RE_REPEAT_ANY_ARGS repeat_any_args; 717| | 718| 162M| RE_NODE* child; 719| | 720| 162M| int16_t* split_offset_addr = NULL; 721| 162M| int16_t* jmp_offset_addr = NULL; 722| | 723| 162M| YR_ARENA_REF instruction_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 162M| (YR_ARENA_REF) \ | | 44| 162M| { \ | | 45| 162M| UINT32_MAX, UINT32_MAX \ | | 46| 162M| } ------------------ 724| 162M| YR_ARENA_REF split_offset_ref; 725| 162M| YR_ARENA_REF jmp_instruction_ref; 726| 162M| YR_ARENA_REF jmp_offset_ref; 727| 162M| YR_ARENA_REF repeat_start_args_ref; 728| | 729| 162M| switch (re_node->type) ------------------ | Branch (729:11): [True: 3.56k, False: 162M] ------------------ 730| 162M| { 731| 77.8M| case RE_NODE_LITERAL: ------------------ | | 41| 77.8M|#define RE_NODE_LITERAL 1 ------------------ | Branch (731:3): [True: 77.8M, False: 85.0M] ------------------ 732| 77.8M| FAIL_ON_ERROR(_yr_emit_inst_arg_uint8( ------------------ | | 134| 77.8M| { \ | | 135| 77.8M| int __error = (x); \ | | 136| 77.8M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 77.8M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 77.8M] | | ------------------ | | 137| 77.8M| return __error; \ | | 138| 77.8M| } ------------------ 733| 77.8M| emit_context, 734| 77.8M| RE_OPCODE_LITERAL, 735| 77.8M| re_node->value, 736| 77.8M| &instruction_ref, 737| 77.8M| NULL)); 738| 77.8M| break; 739| | 740| 576| case RE_NODE_NOT_LITERAL: ------------------ | | 62| 576|#define RE_NODE_NOT_LITERAL 22 ------------------ | Branch (740:3): [True: 576, False: 162M] ------------------ 741| 576| FAIL_ON_ERROR(_yr_emit_inst_arg_uint8( ------------------ | | 134| 576| { \ | | 135| 576| int __error = (x); \ | | 136| 576| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 576|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 576] | | ------------------ | | 137| 576| return __error; \ | | 138| 576| } ------------------ 742| 576| emit_context, 743| 576| RE_OPCODE_NOT_LITERAL, 744| 576| re_node->value, 745| 576| &instruction_ref, 746| 576| NULL)); 747| 576| break; 748| | 749| 6.40k| case RE_NODE_MASKED_LITERAL: ------------------ | | 42| 6.40k|#define RE_NODE_MASKED_LITERAL 2 ------------------ | Branch (749:3): [True: 6.40k, False: 162M] ------------------ 750| 6.40k| FAIL_ON_ERROR(_yr_emit_inst_arg_uint16( ------------------ | | 134| 6.40k| { \ | | 135| 6.40k| int __error = (x); \ | | 136| 6.40k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.40k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 6.40k] | | ------------------ | | 137| 6.40k| return __error; \ | | 138| 6.40k| } ------------------ 751| 6.40k| emit_context, 752| 6.40k| RE_OPCODE_MASKED_LITERAL, 753| 6.40k| re_node->mask << 8 | re_node->value, 754| 6.40k| &instruction_ref, 755| 6.40k| NULL)); 756| 6.40k| break; 757| | 758| 1.01k| case RE_NODE_MASKED_NOT_LITERAL: ------------------ | | 63| 1.01k|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ | Branch (758:3): [True: 1.01k, False: 162M] ------------------ 759| 1.01k| FAIL_ON_ERROR(_yr_emit_inst_arg_uint16( ------------------ | | 134| 1.01k| { \ | | 135| 1.01k| int __error = (x); \ | | 136| 1.01k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.01k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1.01k] | | ------------------ | | 137| 1.01k| return __error; \ | | 138| 1.01k| } ------------------ 760| 1.01k| emit_context, 761| 1.01k| RE_OPCODE_MASKED_NOT_LITERAL, 762| 1.01k| re_node->mask << 8 | re_node->value, 763| 1.01k| &instruction_ref, 764| 1.01k| NULL)); 765| 1.01k| break; 766| | 767| 266| case RE_NODE_WORD_CHAR: ------------------ | | 50| 266|#define RE_NODE_WORD_CHAR 10 ------------------ | Branch (767:3): [True: 266, False: 162M] ------------------ 768| 266| FAIL_ON_ERROR( ------------------ | | 134| 266| { \ | | 135| 266| int __error = (x); \ | | 136| 266| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 266|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 266] | | ------------------ | | 137| 266| return __error; \ | | 138| 266| } ------------------ 769| 266| _yr_emit_inst(emit_context, RE_OPCODE_WORD_CHAR, &instruction_ref)); 770| 266| break; 771| | 772| 406| case RE_NODE_NON_WORD_CHAR: ------------------ | | 51| 406|#define RE_NODE_NON_WORD_CHAR 11 ------------------ | Branch (772:3): [True: 406, False: 162M] ------------------ 773| 406| FAIL_ON_ERROR( ------------------ | | 134| 406| { \ | | 135| 406| int __error = (x); \ | | 136| 406| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 406|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 406] | | ------------------ | | 137| 406| return __error; \ | | 138| 406| } ------------------ 774| 406| _yr_emit_inst(emit_context, RE_OPCODE_NON_WORD_CHAR, &instruction_ref)); 775| 406| break; 776| | 777| 268| case RE_NODE_WORD_BOUNDARY: ------------------ | | 59| 268|#define RE_NODE_WORD_BOUNDARY 19 ------------------ | Branch (777:3): [True: 268, False: 162M] ------------------ 778| 268| FAIL_ON_ERROR( ------------------ | | 134| 268| { \ | | 135| 268| int __error = (x); \ | | 136| 268| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 268|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 268] | | ------------------ | | 137| 268| return __error; \ | | 138| 268| } ------------------ 779| 268| _yr_emit_inst(emit_context, RE_OPCODE_WORD_BOUNDARY, &instruction_ref)); 780| 268| break; 781| | 782| 262| case RE_NODE_NON_WORD_BOUNDARY: ------------------ | | 60| 262|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ | Branch (782:3): [True: 262, False: 162M] ------------------ 783| 262| FAIL_ON_ERROR(_yr_emit_inst( ------------------ | | 134| 262| { \ | | 135| 262| int __error = (x); \ | | 136| 262| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 262|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 262] | | ------------------ | | 137| 262| return __error; \ | | 138| 262| } ------------------ 784| 262| emit_context, RE_OPCODE_NON_WORD_BOUNDARY, &instruction_ref)); 785| 262| break; 786| | 787| 686| case RE_NODE_SPACE: ------------------ | | 52| 686|#define RE_NODE_SPACE 12 ------------------ | Branch (787:3): [True: 686, False: 162M] ------------------ 788| 686| FAIL_ON_ERROR( ------------------ | | 134| 686| { \ | | 135| 686| int __error = (x); \ | | 136| 686| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 686|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 686] | | ------------------ | | 137| 686| return __error; \ | | 138| 686| } ------------------ 789| 686| _yr_emit_inst(emit_context, RE_OPCODE_SPACE, &instruction_ref)); 790| 686| break; 791| | 792| 290| case RE_NODE_NON_SPACE: ------------------ | | 53| 290|#define RE_NODE_NON_SPACE 13 ------------------ | Branch (792:3): [True: 290, False: 162M] ------------------ 793| 290| FAIL_ON_ERROR( ------------------ | | 134| 290| { \ | | 135| 290| int __error = (x); \ | | 136| 290| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 290|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 290] | | ------------------ | | 137| 290| return __error; \ | | 138| 290| } ------------------ 794| 290| _yr_emit_inst(emit_context, RE_OPCODE_NON_SPACE, &instruction_ref)); 795| 290| break; 796| | 797| 295| case RE_NODE_DIGIT: ------------------ | | 54| 295|#define RE_NODE_DIGIT 14 ------------------ | Branch (797:3): [True: 295, False: 162M] ------------------ 798| 295| FAIL_ON_ERROR( ------------------ | | 134| 295| { \ | | 135| 295| int __error = (x); \ | | 136| 295| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 295|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 295] | | ------------------ | | 137| 295| return __error; \ | | 138| 295| } ------------------ 799| 295| _yr_emit_inst(emit_context, RE_OPCODE_DIGIT, &instruction_ref)); 800| 295| break; 801| | 802| 166| case RE_NODE_NON_DIGIT: ------------------ | | 55| 166|#define RE_NODE_NON_DIGIT 15 ------------------ | Branch (802:3): [True: 166, False: 162M] ------------------ 803| 166| FAIL_ON_ERROR( ------------------ | | 134| 166| { \ | | 135| 166| int __error = (x); \ | | 136| 166| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 166|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 166] | | ------------------ | | 137| 166| return __error; \ | | 138| 166| } ------------------ 804| 166| _yr_emit_inst(emit_context, RE_OPCODE_NON_DIGIT, &instruction_ref)); 805| 166| break; 806| | 807| 970k| case RE_NODE_ANY: ------------------ | | 43| 970k|#define RE_NODE_ANY 3 ------------------ | Branch (807:3): [True: 970k, False: 161M] ------------------ 808| 970k| FAIL_ON_ERROR(_yr_emit_inst(emit_context, RE_OPCODE_ANY, &instruction_ref)); ------------------ | | 134| 970k| { \ | | 135| 970k| int __error = (x); \ | | 136| 970k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 970k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 970k] | | ------------------ | | 137| 970k| return __error; \ | | 138| 970k| } ------------------ 809| 970k| break; 810| | 811| 53.2M| case RE_NODE_CLASS: ------------------ | | 49| 53.2M|#define RE_NODE_CLASS 9 ------------------ | Branch (811:3): [True: 53.2M, False: 109M] ------------------ 812| 53.2M| FAIL_ON_ERROR( ------------------ | | 134| 53.2M| { \ | | 135| 53.2M| int __error = (x); \ | | 136| 53.2M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 53.2M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 53.2M] | | ------------------ | | 137| 53.2M| return __error; \ | | 138| 53.2M| } ------------------ 813| 53.2M| _yr_emit_inst(emit_context, RE_OPCODE_CLASS, &instruction_ref)); 814| | 815| 53.2M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 53.2M| { \ | | 135| 53.2M| int __error = (x); \ | | 136| 53.2M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 53.2M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 53.2M] | | ------------------ | | 137| 53.2M| return __error; \ | | 138| 53.2M| } ------------------ 816| 53.2M| emit_context->arena, 817| 53.2M| YR_RE_CODE_SECTION, 818| 53.2M| re_node->re_class, 819| 53.2M| sizeof(*re_node->re_class), 820| 53.2M| NULL)); 821| 53.2M| break; 822| | 823| 266k| case RE_NODE_ANCHOR_START: ------------------ | | 57| 266k|#define RE_NODE_ANCHOR_START 17 ------------------ | Branch (823:3): [True: 266k, False: 162M] ------------------ 824| 266k| FAIL_ON_ERROR(_yr_emit_inst( ------------------ | | 134| 266k| { \ | | 135| 266k| int __error = (x); \ | | 136| 266k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 266k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 266k] | | ------------------ | | 137| 266k| return __error; \ | | 138| 266k| } ------------------ 825| 266k| emit_context, RE_OPCODE_MATCH_AT_START, &instruction_ref)); 826| 266k| break; 827| | 828| 92.3k| case RE_NODE_ANCHOR_END: ------------------ | | 58| 92.3k|#define RE_NODE_ANCHOR_END 18 ------------------ | Branch (828:3): [True: 92.3k, False: 162M] ------------------ 829| 92.3k| FAIL_ON_ERROR( ------------------ | | 134| 92.3k| { \ | | 135| 92.3k| int __error = (x); \ | | 136| 92.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 92.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 92.3k] | | ------------------ | | 137| 92.3k| return __error; \ | | 138| 92.3k| } ------------------ 830| 92.3k| _yr_emit_inst(emit_context, RE_OPCODE_MATCH_AT_END, &instruction_ref)); 831| 92.3k| break; 832| | 833| 15.4M| case RE_NODE_CONCAT: ------------------ | | 44| 15.4M|#define RE_NODE_CONCAT 4 ------------------ | Branch (833:3): [True: 15.4M, False: 147M] ------------------ 834| 15.4M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 15.4M| { \ | | 135| 30.9M| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 159k, False: 15.3M] | | ------------------ | | 136| 15.4M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.4M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 1.00k, False: 15.4M] | | ------------------ | | 137| 15.4M| return __error; \ | | 138| 15.4M| } ------------------ 835| 15.4M| emit_context, 836| 15.4M| (flags & EMIT_BACKWARDS) ? re_node->children_tail 837| 15.4M| : re_node->children_head, 838| 15.4M| flags, 839| 15.4M| &instruction_ref)); 840| | 841| 15.4M| if (flags & EMIT_BACKWARDS) ------------------ | | 55| 15.4M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (841:9): [True: 159k, False: 15.3M] ------------------ 842| 159k| child = re_node->children_tail->prev_sibling; 843| 15.3M| else 844| 15.3M| child = re_node->children_head->next_sibling; 845| | 846| 118M| while (child != NULL) ------------------ | Branch (846:12): [True: 102M, False: 15.4M] ------------------ 847| 102M| { 848| 102M| FAIL_ON_ERROR(_yr_re_emit(emit_context, child, flags, NULL)); ------------------ | | 134| 102M| { \ | | 135| 102M| int __error = (x); \ | | 136| 102M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 102M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 524, False: 102M] | | ------------------ | | 137| 102M| return __error; \ | | 138| 102M| } ------------------ 849| | 850| 102M| child = (flags & EMIT_BACKWARDS) ? child->prev_sibling ------------------ | | 55| 102M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (850:15): [True: 3.93M, False: 98.6M] ------------------ 851| 102M| : child->next_sibling; 852| 102M| } 853| 15.4M| break; 854| | 855| 15.4M| case RE_NODE_PLUS: ------------------ | | 48| 3.28k|#define RE_NODE_PLUS 8 ------------------ | Branch (855:3): [True: 3.28k, False: 162M] ------------------ 856| | // Code for e+ looks like: 857| | // 858| | // L1: code for e 859| | // split L1, L2 860| | // L2: 861| | // 862| 3.28k| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 3.28k| { \ | | 135| 3.28k| int __error = (x); \ | | 136| 3.28k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.28k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 87, False: 3.19k] | | ------------------ | | 137| 3.28k| return __error; \ | | 138| 3.28k| } ------------------ 863| 3.28k| emit_context, re_node->children_head, flags, &instruction_ref)); 864| | 865| 3.19k| bookmark_1 = yr_arena_get_current_offset( 866| 3.19k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 3.19k|#define YR_RE_CODE_SECTION 7 ------------------ 867| | 868| 3.19k| if (instruction_ref.offset - bookmark_1 < INT16_MIN) ------------------ | Branch (868:9): [True: 3, False: 3.19k] ------------------ 869| 3| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 3|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 870| | 871| 3.19k| jmp_offset = (int16_t) (instruction_ref.offset - bookmark_1); 872| | 873| 3.19k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 134| 3.19k| { \ | | 135| 6.39k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 3.17k, False: 23] | | ------------------ | | 136| 3.19k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.19k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 34, False: 3.16k] | | ------------------ | | 137| 3.19k| return __error; \ | | 138| 3.19k| } ------------------ 874| 3.19k| emit_context, 875| 3.19k| re_node->greedy ? RE_OPCODE_SPLIT_B : RE_OPCODE_SPLIT_A, 876| 3.19k| jmp_offset, 877| 3.19k| NULL, 878| 3.19k| NULL)); 879| | 880| 3.16k| break; 881| | 882| 2.97k| case RE_NODE_STAR: ------------------ | | 47| 2.97k|#define RE_NODE_STAR 7 ------------------ | Branch (882:3): [True: 2.97k, False: 162M] ------------------ 883| | // Code for e* looks like: 884| | // 885| | // L1: split L1, L2 886| | // code for e 887| | // jmp L1 888| | // L2: 889| 2.97k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 134| 2.97k| { \ | | 135| 5.95k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 1.88k, False: 1.09k] | | ------------------ | | 136| 2.97k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.97k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 11, False: 2.96k] | | ------------------ | | 137| 2.97k| return __error; \ | | 138| 2.97k| } ------------------ 890| 2.97k| emit_context, 891| 2.97k| re_node->greedy ? RE_OPCODE_SPLIT_A : RE_OPCODE_SPLIT_B, 892| 2.97k| 0, 893| 2.97k| &instruction_ref, 894| 2.97k| &split_offset_ref)); 895| | 896| 2.96k| FAIL_ON_ERROR( ------------------ | | 134| 2.96k| { \ | | 135| 2.96k| int __error = (x); \ | | 136| 2.96k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.96k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 153, False: 2.81k] | | ------------------ | | 137| 2.96k| return __error; \ | | 138| 2.96k| } ------------------ 897| 2.96k| _yr_re_emit(emit_context, re_node->children_head, flags, NULL)); 898| | 899| 2.81k| bookmark_1 = yr_arena_get_current_offset( 900| 2.81k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.81k|#define YR_RE_CODE_SECTION 7 ------------------ 901| | 902| 2.81k| if (instruction_ref.offset - bookmark_1 < INT16_MIN) ------------------ | Branch (902:9): [True: 8, False: 2.80k] ------------------ 903| 8| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 8|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 904| | 905| 2.80k| jmp_offset = (int16_t) (instruction_ref.offset - bookmark_1); 906| | 907| | // Emit jump with offset set to 0. 908| | 909| 2.80k| FAIL_ON_ERROR(_yr_emit_inst_arg_int16( ------------------ | | 134| 2.80k| { \ | | 135| 2.80k| int __error = (x); \ | | 136| 2.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2.80k] | | ------------------ | | 137| 2.80k| return __error; \ | | 138| 2.80k| } ------------------ 910| 2.80k| emit_context, RE_OPCODE_JUMP, jmp_offset, NULL, NULL)); 911| | 912| 2.80k| bookmark_1 = yr_arena_get_current_offset( 913| 2.80k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.80k|#define YR_RE_CODE_SECTION 7 ------------------ 914| | 915| 2.80k| if (bookmark_1 - instruction_ref.offset > INT16_MAX) ------------------ | Branch (915:9): [True: 0, False: 2.80k] ------------------ 916| 0| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 0|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 917| | 918| 2.80k| jmp_offset = (int16_t) (bookmark_1 - instruction_ref.offset); 919| | 920| | // Update split offset. 921| 2.80k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 922| 2.80k| emit_context->arena, &split_offset_ref); 923| | 924| 2.80k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 925| 2.80k| break; 926| | 927| 29.4k| case RE_NODE_ALT: ------------------ | | 45| 29.4k|#define RE_NODE_ALT 5 ------------------ | Branch (927:3): [True: 29.4k, False: 162M] ------------------ 928| | // Code for e1|e2 looks like: 929| | // 930| | // split L1, L2 931| | // L1: code for e1 932| | // jmp L3 933| | // L2: code for e2 934| | // L3: 935| | 936| | // Emit a split instruction with offset set to 0 temporarily. Offset 937| | // will be updated after we know the size of the code generated for 938| | // the left node (e1). 939| | 940| 29.4k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 134| 29.4k| { \ | | 135| 29.4k| int __error = (x); \ | | 136| 29.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 29.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 23, False: 29.4k] | | ------------------ | | 137| 29.4k| return __error; \ | | 138| 29.4k| } ------------------ 941| 29.4k| emit_context, 942| 29.4k| RE_OPCODE_SPLIT_A, 943| 29.4k| 0, 944| 29.4k| &instruction_ref, 945| 29.4k| &split_offset_ref)); 946| | 947| 29.4k| FAIL_ON_ERROR( ------------------ | | 134| 29.4k| { \ | | 135| 29.4k| int __error = (x); \ | | 136| 29.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 29.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 439, False: 28.9k] | | ------------------ | | 137| 29.4k| return __error; \ | | 138| 29.4k| } ------------------ 948| 29.4k| _yr_re_emit(emit_context, re_node->children_head, flags, NULL)); 949| | 950| | // Emit jump with offset set to 0. 951| | 952| 28.9k| FAIL_ON_ERROR(_yr_emit_inst_arg_int16( ------------------ | | 134| 28.9k| { \ | | 135| 28.9k| int __error = (x); \ | | 136| 28.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 28.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 28.9k] | | ------------------ | | 137| 28.9k| return __error; \ | | 138| 28.9k| } ------------------ 953| 28.9k| emit_context, 954| 28.9k| RE_OPCODE_JUMP, 955| 28.9k| 0, 956| 28.9k| &jmp_instruction_ref, 957| 28.9k| &jmp_offset_ref)); 958| | 959| 28.9k| bookmark_1 = yr_arena_get_current_offset( 960| 28.9k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 28.9k|#define YR_RE_CODE_SECTION 7 ------------------ 961| | 962| 28.9k| if (bookmark_1 - instruction_ref.offset > INT16_MAX) ------------------ | Branch (962:9): [True: 15, False: 28.9k] ------------------ 963| 15| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 15|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 964| | 965| 28.9k| jmp_offset = (int16_t) (bookmark_1 - instruction_ref.offset); 966| | 967| | // Update split offset. 968| 28.9k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 969| 28.9k| emit_context->arena, &split_offset_ref); 970| | 971| 28.9k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 972| | 973| 28.9k| FAIL_ON_ERROR( ------------------ | | 134| 28.9k| { \ | | 135| 28.9k| int __error = (x); \ | | 136| 28.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 28.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 289, False: 28.6k] | | ------------------ | | 137| 28.9k| return __error; \ | | 138| 28.9k| } ------------------ 974| 28.9k| _yr_re_emit(emit_context, re_node->children_tail, flags, NULL)); 975| | 976| 28.6k| bookmark_1 = yr_arena_get_current_offset( 977| 28.6k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 28.6k|#define YR_RE_CODE_SECTION 7 ------------------ 978| | 979| 28.6k| if (bookmark_1 - jmp_instruction_ref.offset > INT16_MAX) ------------------ | Branch (979:9): [True: 18, False: 28.6k] ------------------ 980| 18| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 18|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 981| | 982| 28.6k| jmp_offset = (int16_t) (bookmark_1 - jmp_instruction_ref.offset); 983| | 984| | // Update offset for jmp instruction. 985| 28.6k| jmp_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 986| 28.6k| emit_context->arena, &jmp_offset_ref); 987| | 988| 28.6k| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 989| 28.6k| break; 990| | 991| 7.16k| case RE_NODE_RANGE_ANY: ------------------ | | 61| 7.16k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (991:3): [True: 7.16k, False: 162M] ------------------ 992| 7.16k| repeat_any_args.min = re_node->start; 993| 7.16k| repeat_any_args.max = re_node->end; 994| | 995| 7.16k| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 134| 7.16k| { \ | | 135| 14.3k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 632, False: 6.53k] | | ------------------ | | 136| 7.16k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.16k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 7.16k] | | ------------------ | | 137| 7.16k| return __error; \ | | 138| 7.16k| } ------------------ 996| 7.16k| emit_context, 997| 7.16k| re_node->greedy ? RE_OPCODE_REPEAT_ANY_GREEDY 998| 7.16k| : RE_OPCODE_REPEAT_ANY_UNGREEDY, 999| 7.16k| &repeat_any_args, 1000| 7.16k| sizeof(repeat_any_args), 1001| 7.16k| &instruction_ref, 1002| 7.16k| NULL)); 1003| | 1004| 7.16k| break; 1005| | 1006| 14.9M| case RE_NODE_RANGE: ------------------ | | 46| 14.9M|#define RE_NODE_RANGE 6 ------------------ | Branch (1006:3): [True: 14.9M, False: 147M] ------------------ 1007| | // Code for e{n,m} looks like: 1008| | // 1009| | // code for e --- prolog 1010| | // repeat_start n, m, L1 --+ 1011| | // L0: code for e | repeat 1012| | // repeat_end n, m, L0 --+ 1013| | // L1: split L2, L3 --- split 1014| | // L2: code for e --- epilog 1015| | // L3: 1016| | // 1017| | // Not all sections (prolog, repeat, split and epilog) are generated in all 1018| | // cases, it depends on the values of n and m. The following table shows 1019| | // which sections are generated for the first few values of n and m. 1020| | // 1021| | // n,m prolog repeat split epilog 1022| | // (min,max) 1023| | // --------------------------------------- 1024| | // 0,0 - - - - 1025| | // 0,1 - - X X 1026| | // 0,2 - 0,1 X X 1027| | // 0,3 - 0,2 X X 1028| | // 0,M - 0,M-1 X X 1029| | // 1030| | // 1,1 X - - - 1031| | // 1,2 X - X X 1032| | // 1,3 X 0,1 X X 1033| | // 1,4 X 1,2 X X 1034| | // 1,M X 1,M-2 X X 1035| | // 1036| | // 2,2 X - - X 1037| | // 2,3 X 1,1 X X 1038| | // 2,4 X 1,2 X X 1039| | // 2,M X 1,M-2 X X 1040| | // 1041| | // 3,3 X 1,1 - X 1042| | // 3,4 X 2,2 X X 1043| | // 3,M X 2,M-2 X X 1044| | // 1045| | // 4,4 X 2,2 - X 1046| | // 4,5 X 3,3 X X 1047| | // 4,M X 3,M-2 X X 1048| | // 1049| | // The code can't consists simply in the repeat section, the prolog and 1050| | // epilog are required because we can't have atoms pointing to code inside 1051| | // the repeat loop. Atoms' forwards_code will point to code in the prolog 1052| | // and backwards_code will point to code in the epilog (or in prolog if 1053| | // epilog wasn't generated, like in n=1,m=1) 1054| | 1055| 14.9M| emit_prolog = re_node->start > 0; 1056| 14.9M| emit_repeat = re_node->end > re_node->start + 1 || re_node->end > 2; ------------------ | Branch (1056:19): [True: 765, False: 14.9M] | Branch (1056:56): [True: 14.7M, False: 162k] ------------------ 1057| 14.9M| emit_split = re_node->end > re_node->start; 1058| 14.9M| emit_epilog = re_node->end > re_node->start || re_node->end > 1; ------------------ | Branch (1058:19): [True: 2.23k, False: 14.9M] | Branch (1058:52): [True: 14.9M, False: 1.31k] ------------------ 1059| | 1060| 14.9M| if (emit_prolog) ------------------ | Branch (1060:9): [True: 14.9M, False: 2.23k] ------------------ 1061| 14.9M| { 1062| 14.9M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 14.9M| { \ | | 135| 14.9M| int __error = (x); \ | | 136| 14.9M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.9M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 71, False: 14.9M] | | ------------------ | | 137| 14.9M| return __error; \ | | 138| 14.9M| } ------------------ 1063| 14.9M| emit_context, re_node->children_head, flags, &instruction_ref)); 1064| 14.9M| } 1065| | 1066| 14.9M| if (emit_repeat) ------------------ | Branch (1066:9): [True: 14.7M, False: 162k] ------------------ 1067| 14.7M| { 1068| 14.7M| repeat_args.min = re_node->start; 1069| 14.7M| repeat_args.max = re_node->end; 1070| | 1071| 14.7M| if (emit_prolog) ------------------ | Branch (1071:11): [True: 14.7M, False: 723] ------------------ 1072| 14.7M| { 1073| 14.7M| repeat_args.max--; 1074| 14.7M| repeat_args.min--; 1075| 14.7M| } 1076| | 1077| 14.7M| if (emit_split) ------------------ | Branch (1077:11): [True: 765, False: 14.7M] ------------------ 1078| 765| { 1079| 765| repeat_args.max--; 1080| 765| } 1081| 14.7M| else 1082| 14.7M| { 1083| 14.7M| repeat_args.min--; 1084| 14.7M| repeat_args.max--; 1085| 14.7M| } 1086| | 1087| 14.7M| repeat_args.offset = 0; 1088| | 1089| 14.7M| bookmark_1 = yr_arena_get_current_offset( 1090| 14.7M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 14.7M|#define YR_RE_CODE_SECTION 7 ------------------ 1091| | 1092| 14.7M| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 134| 14.7M| { \ | | 135| 59.1M| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 14.7M, False: 254] | | | Branch (135:20): [True: 14.7M, False: 723] | | ------------------ | | 136| 14.7M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.7M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 14.7M] | | ------------------ | | 137| 14.7M| return __error; \ | | 138| 14.7M| } ------------------ 1093| 14.7M| emit_context, 1094| 14.7M| re_node->greedy ? RE_OPCODE_REPEAT_START_GREEDY 1095| 14.7M| : RE_OPCODE_REPEAT_START_UNGREEDY, 1096| 14.7M| &repeat_args, 1097| 14.7M| sizeof(repeat_args), 1098| 14.7M| emit_prolog ? NULL : &instruction_ref, 1099| 14.7M| &repeat_start_args_ref)); 1100| | 1101| 14.7M| bookmark_2 = yr_arena_get_current_offset( 1102| 14.7M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 14.7M|#define YR_RE_CODE_SECTION 7 ------------------ 1103| | 1104| 14.7M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 14.7M| { \ | | 135| 14.7M| int __error = (x); \ | | 136| 14.7M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.7M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 225, False: 14.7M] | | ------------------ | | 137| 14.7M| return __error; \ | | 138| 14.7M| } ------------------ 1105| 14.7M| emit_context, 1106| 14.7M| re_node->children_head, 1107| 14.7M| flags | EMIT_DONT_SET_FORWARDS_CODE | EMIT_DONT_SET_BACKWARDS_CODE, 1108| 14.7M| NULL)); 1109| | 1110| 14.7M| bookmark_3 = yr_arena_get_current_offset( 1111| 14.7M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 14.7M|#define YR_RE_CODE_SECTION 7 ------------------ 1112| | 1113| 14.7M| if (bookmark_2 - bookmark_3 < INT32_MIN) ------------------ | Branch (1113:11): [True: 7, False: 14.7M] ------------------ 1114| 7| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 7|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1115| | 1116| 14.7M| repeat_args.offset = (int32_t) (bookmark_2 - bookmark_3); 1117| | 1118| 14.7M| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 134| 14.7M| { \ | | 135| 29.5M| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 14.7M, False: 254] | | ------------------ | | 136| 14.7M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.7M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 14.7M] | | ------------------ | | 137| 14.7M| return __error; \ | | 138| 14.7M| } ------------------ 1119| 14.7M| emit_context, 1120| 14.7M| re_node->greedy ? RE_OPCODE_REPEAT_END_GREEDY 1121| 14.7M| : RE_OPCODE_REPEAT_END_UNGREEDY, 1122| 14.7M| &repeat_args, 1123| 14.7M| sizeof(repeat_args), 1124| 14.7M| NULL, 1125| 14.7M| NULL)); 1126| | 1127| 14.7M| bookmark_4 = yr_arena_get_current_offset( 1128| 14.7M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 14.7M|#define YR_RE_CODE_SECTION 7 ------------------ 1129| | 1130| 14.7M| repeat_start_args_addr = (RE_REPEAT_ARGS*) yr_arena_ref_to_ptr( 1131| 14.7M| emit_context->arena, &repeat_start_args_ref); 1132| | 1133| 14.7M| if (bookmark_4 - bookmark_1 > INT32_MAX) ------------------ | Branch (1133:11): [True: 0, False: 14.7M] ------------------ 1134| 0| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 0|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1135| | 1136| 14.7M| repeat_start_args_addr->offset = (int32_t) (bookmark_4 - bookmark_1); 1137| 14.7M| } 1138| | 1139| 14.9M| if (emit_split) ------------------ | Branch (1139:9): [True: 2.06k, False: 14.9M] ------------------ 1140| 2.06k| { 1141| 2.06k| bookmark_1 = yr_arena_get_current_offset( 1142| 2.06k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.06k|#define YR_RE_CODE_SECTION 7 ------------------ 1143| | 1144| 2.06k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 134| 2.06k| { \ | | 135| 4.13k| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 1.58k, False: 480] | | ------------------ | | 136| 2.06k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.06k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 13, False: 2.05k] | | ------------------ | | 137| 2.06k| return __error; \ | | 138| 2.06k| } ------------------ 1145| 2.06k| emit_context, 1146| 2.06k| re_node->greedy ? RE_OPCODE_SPLIT_A : RE_OPCODE_SPLIT_B, 1147| 2.06k| 0, 1148| 2.06k| NULL, 1149| 2.06k| &split_offset_ref)); 1150| 2.05k| } 1151| | 1152| 14.9M| if (emit_epilog) ------------------ | Branch (1152:9): [True: 14.9M, False: 1.30k] ------------------ 1153| 14.9M| { 1154| 14.9M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 134| 14.9M| { \ | | 135| 74.7M| int __error = (x); \ | | ------------------ | | | Branch (135:20): [True: 14.9M, False: 1.90k] | | | Branch (135:20): [True: 14.9M, False: 1.90k] | | | Branch (135:20): [True: 544, False: 1.36k] | | ------------------ | | 136| 14.9M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.9M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 119, False: 14.9M] | | ------------------ | | 137| 14.9M| return __error; \ | | 138| 14.9M| } ------------------ 1155| 14.9M| emit_context, 1156| 14.9M| re_node->children_head, 1157| 14.9M| emit_prolog ? flags | EMIT_DONT_SET_FORWARDS_CODE : flags, 1158| 14.9M| emit_prolog || emit_repeat ? NULL : &instruction_ref)); 1159| 14.9M| } 1160| | 1161| 14.9M| if (emit_split) ------------------ | Branch (1161:9): [True: 2.04k, False: 14.9M] ------------------ 1162| 2.04k| { 1163| 2.04k| bookmark_2 = yr_arena_get_current_offset( 1164| 2.04k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.04k|#define YR_RE_CODE_SECTION 7 ------------------ 1165| | 1166| 2.04k| if (bookmark_2 - bookmark_1 > INT16_MAX) ------------------ | Branch (1166:11): [True: 8, False: 2.03k] ------------------ 1167| 8| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 92| 8|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1168| | 1169| 2.03k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 1170| 2.03k| emit_context->arena, &split_offset_ref); 1171| | 1172| 2.03k| jmp_offset = (int16_t) (bookmark_2 - bookmark_1); 1173| | 1174| 2.03k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 1175| 2.03k| } 1176| | 1177| 14.9M| break; 1178| 162M| } 1179| | 1180| 162M| if (flags & EMIT_BACKWARDS) ------------------ | | 55| 162M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (1180:7): [True: 4.19M, False: 158M] ------------------ 1181| 4.19M| { 1182| 4.19M| if (!(flags & EMIT_DONT_SET_BACKWARDS_CODE)) ------------------ | | 57| 4.19M|#define EMIT_DONT_SET_BACKWARDS_CODE 0x04 ------------------ | Branch (1182:9): [True: 2.20M, False: 1.98M] ------------------ 1183| 2.20M| { 1184| 2.20M| re_node->backward_code_ref.buffer_id = YR_RE_CODE_SECTION; ------------------ | | 64| 2.20M|#define YR_RE_CODE_SECTION 7 ------------------ 1185| 2.20M| re_node->backward_code_ref.offset = yr_arena_get_current_offset( 1186| 2.20M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.20M|#define YR_RE_CODE_SECTION 7 ------------------ 1187| 2.20M| } 1188| 4.19M| } 1189| 158M| else 1190| 158M| { 1191| 158M| if (!(flags & EMIT_DONT_SET_FORWARDS_CODE)) ------------------ | | 56| 158M|#define EMIT_DONT_SET_FORWARDS_CODE 0x02 ------------------ | Branch (1191:9): [True: 2.30M, False: 156M] ------------------ 1192| 2.30M| { 1193| 2.30M| re_node->forward_code_ref = instruction_ref; 1194| 2.30M| } 1195| 158M| } 1196| | 1197| 162M| if (code_ref != NULL) ------------------ | Branch (1197:7): [True: 30.4M, False: 132M] ------------------ 1198| 30.4M| *code_ref = instruction_ref; 1199| | 1200| 162M| return ERROR_SUCCESS; ------------------ | | 40| 162M|#define ERROR_SUCCESS 0 ------------------ 1201| 162M|} re_yyparse: 1009| 15.9k|{ 1010| |/* Lookahead token kind. */ 1011| 15.9k|int yychar; 1012| | 1013| | 1014| |/* The semantic value of the lookahead symbol. */ 1015| |/* Default value used for initialization, for pacifying older GCCs 1016| | or non-GCC compilers. */ 1017| 15.9k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 418| 15.9k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1018| 15.9k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 418| 15.9k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1019| | 1020| | /* Number of syntax errors so far. */ 1021| 15.9k| int yynerrs = 0; 1022| | 1023| 15.9k| yy_state_fast_t yystate = 0; 1024| | /* Number of tokens to shift before error messages enabled. */ 1025| 15.9k| int yyerrstatus = 0; 1026| | 1027| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1028| | to reallocate them elsewhere. */ 1029| | 1030| | /* Their size. */ 1031| 15.9k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 325| 15.9k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 925| 15.9k|# define YYINITDEPTH 200 ------------------ 1032| | 1033| | /* The state stack: array, bottom, top. */ 1034| 15.9k| yy_state_t yyssa[YYINITDEPTH]; 1035| 15.9k| yy_state_t *yyss = yyssa; 1036| 15.9k| yy_state_t *yyssp = yyss; 1037| | 1038| | /* The semantic value stack: array, bottom, top. */ 1039| 15.9k| YYSTYPE yyvsa[YYINITDEPTH]; 1040| 15.9k| YYSTYPE *yyvs = yyvsa; 1041| 15.9k| YYSTYPE *yyvsp = yyvs; 1042| | 1043| 15.9k| int yyn; 1044| | /* The return value of yyparse. */ 1045| 15.9k| int yyresult; 1046| | /* Lookahead symbol kind. */ 1047| 15.9k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1048| | /* The variables used to return semantic value and location from the 1049| | action routines. */ 1050| 15.9k| YYSTYPE yyval; 1051| | 1052| | 1053| | 1054| 15.9k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1055| | 1056| | /* The number of symbols on the RHS of the reduced rule. 1057| | Keep to zero when no symbol should be popped. */ 1058| 15.9k| int yylen = 0; 1059| | 1060| 15.9k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 916| 15.9k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1061| | 1062| 15.9k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 50| 15.9k|#define yychar re_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 73| 15.9k|#define YYEMPTY -2 ------------------ 1063| | 1064| 15.9k| goto yysetstate; 1065| | 1066| | 1067| |/*------------------------------------------------------------. 1068| || yynewstate -- push a new state, which is found in yystate. | 1069| |`------------------------------------------------------------*/ 1070| 10.5M|yynewstate: 1071| | /* In all cases, when you get here, the value and location stacks 1072| | have just been pushed. So pushing a state here evens the stacks. */ 1073| 10.5M| yyssp++; 1074| | 1075| | 1076| |/*--------------------------------------------------------------------. 1077| || yysetstate -- set current state (the top of the stack) to yystate. | 1078| |`--------------------------------------------------------------------*/ 1079| 10.5M|yysetstate: 1080| 10.5M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 916| 10.5M|# define YYDPRINTF(Args) ((void) 0) ------------------ 1081| 10.5M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 441| 10.5M|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (441:31): [Folded - Ignored] | | | Branch (441:37): [True: 0, False: 0] | | | Branch (441:37): [True: 0, False: 0] | | ------------------ ------------------ 1082| 10.5M| YY_IGNORE_USELESS_CAST_BEGIN 1083| 10.5M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 116| 10.5M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1084| 10.5M| YY_IGNORE_USELESS_CAST_END 1085| 10.5M| YY_STACK_PRINT (yyss, yyssp); 1086| | 1087| 10.5M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1087:7): [True: 223, False: 10.5M] ------------------ 1088| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1089| | YYNOMEM; 1090| |#else 1091| 223| { 1092| | /* Get the current used size of the three stacks, in elements. */ 1093| 223| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 325| 223|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1094| | 1095| |# if defined yyoverflow 1096| | { 1097| | /* Give user a chance to reallocate the stack. Use copies of 1098| | these so that the &'s don't force the real ones into 1099| | memory. */ 1100| | yy_state_t *yyss1 = yyss; 1101| | YYSTYPE *yyvs1 = yyvs; 1102| | 1103| | /* Each stack pointer address is followed by the size of the 1104| | data in use in that stack, in bytes. This used to be a 1105| | conditional around just the two extra args, but that might 1106| | be undefined if yyoverflow is a macro. */ 1107| | yyoverflow (YY_("memory exhausted"), 1108| | &yyss1, yysize * YYSIZEOF (*yyssp), 1109| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1110| | &yystacksize); 1111| | yyss = yyss1; 1112| | yyvs = yyvs1; 1113| | } 1114| |# else /* defined YYSTACK_RELOCATE */ 1115| | /* Extend the stack our own way. */ 1116| 223| if (YYMAXDEPTH <= yystacksize) ------------------ | | 936| 223|# define YYMAXDEPTH 10000 ------------------ | Branch (1116:11): [True: 0, False: 223] ------------------ 1117| 0| YYNOMEM; ------------------ | | 767| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1118| 223| yystacksize *= 2; 1119| 223| if (YYMAXDEPTH < yystacksize) ------------------ | | 936| 223|# define YYMAXDEPTH 10000 ------------------ | Branch (1119:11): [True: 1, False: 222] ------------------ 1120| 1| yystacksize = YYMAXDEPTH; ------------------ | | 936| 1|# define YYMAXDEPTH 10000 ------------------ 1121| | 1122| 223| { 1123| 223| yy_state_t *yyss1 = yyss; 1124| 223| union yyalloc *yyptr = 1125| 223| YY_CAST (union yyalloc *, ------------------ | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1126| 223| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1127| 223| if (! yyptr) ------------------ | Branch (1127:13): [True: 0, False: 223] ------------------ 1128| 0| YYNOMEM; ------------------ | | 767| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1129| 223| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 538| 223| do \ | | 539| 223| { \ | | 540| 223| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 325| 223|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 541| 223| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 556| 223| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 542| 223| Stack = &yyptr->Stack_alloc; \ | | 543| 223| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 522| 223|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 544| 223| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 545| 223| } \ | | 546| 223| while (0) | | ------------------ | | | Branch (546:12): [Folded - Ignored] | | ------------------ ------------------ 1130| 223| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 538| 223| do \ | | 539| 223| { \ | | 540| 223| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 325| 223|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 541| 223| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 556| 223| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 542| 223| Stack = &yyptr->Stack_alloc; \ | | 543| 223| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 522| 223|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 544| 223| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 358| 223|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 223|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 545| 223| } \ | | 546| 223| while (0) | | ------------------ | | | Branch (546:12): [Folded - Ignored] | | ------------------ ------------------ 1131| 223|# undef YYSTACK_RELOCATE 1132| 223| if (yyss1 != yyssa) ------------------ | Branch (1132:13): [True: 119, False: 104] ------------------ 1133| 119| YYSTACK_FREE (yyss1); ------------------ | | 483| 119|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 90| 119|#define YYFREE yr_free | | ------------------ ------------------ 1134| 223| } 1135| 0|# endif 1136| | 1137| 0| yyssp = yyss + yysize - 1; 1138| 223| yyvsp = yyvs + yysize - 1; 1139| | 1140| 223| YY_IGNORE_USELESS_CAST_BEGIN 1141| 223| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 916| 223|# define YYDPRINTF(Args) ((void) 0) ------------------ 1142| 223| YY_CAST (long, yystacksize))); 1143| 223| YY_IGNORE_USELESS_CAST_END 1144| | 1145| 223| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1145:11): [True: 0, False: 223] ------------------ 1146| 0| YYABORT; ------------------ | | 765| 0|#define YYABORT goto yyabortlab ------------------ 1147| 223| } 1148| 10.5M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1149| | 1150| | 1151| 10.5M| if (yystate == YYFINAL) ------------------ | | 571| 10.5M|#define YYFINAL 22 ------------------ | Branch (1151:7): [True: 15.9k, False: 10.5M] ------------------ 1152| 15.9k| YYACCEPT; ------------------ | | 764| 15.9k|#define YYACCEPT goto yyacceptlab ------------------ 1153| | 1154| 10.5M| goto yybackup; 1155| | 1156| | 1157| |/*-----------. 1158| || yybackup. | 1159| |`-----------*/ 1160| 10.5M|yybackup: 1161| | /* Do appropriate processing given the current state. Read a 1162| | lookahead token if we need one and don't already have one. */ 1163| | 1164| | /* First try to decide what to do without reference to lookahead token. */ 1165| 10.5M| yyn = yypact[yystate]; 1166| 10.5M| if (yypact_value_is_default (yyn)) ------------------ | | 669| 10.5M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 666| 10.5M|#define YYPACT_NINF (-12) | | ------------------ | | | Branch (669:3): [True: 5.13M, False: 5.37M] | | ------------------ ------------------ 1167| 5.13M| goto yydefault; 1168| | 1169| | /* Not known => get a lookahead token if don't already have one. */ 1170| | 1171| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 1172| 5.37M| if (yychar == YYEMPTY) ------------------ | | 50| 5.37M|#define yychar re_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 73| 5.37M|#define YYEMPTY -2 ------------------ | Branch (1172:7): [True: 2.71M, False: 2.66M] ------------------ 1173| 2.71M| { 1174| 2.71M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 916| 2.71M|# define YYDPRINTF(Args) ((void) 0) ------------------ 1175| 2.71M| yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 50| 2.71M|#define yychar re_yychar ------------------ yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 46| 2.71M|#define yylex re_yylex ------------------ 1176| 2.71M| } 1177| | 1178| 5.37M| if (yychar <= YYEOF) ------------------ | | 50| 5.37M|#define yychar re_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 74| 5.37M|#define YYEOF 0 ------------------ | Branch (1178:7): [True: 62.0k, False: 5.31M] ------------------ 1179| 62.0k| { 1180| 62.0k| yychar = YYEOF; ------------------ | | 50| 62.0k|#define yychar re_yychar ------------------ yychar = YYEOF; ------------------ | | 74| 62.0k|#define YYEOF 0 ------------------ 1181| 62.0k| yytoken = YYSYMBOL_YYEOF; 1182| 62.0k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 916| 62.0k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1183| 62.0k| } 1184| 5.31M| else if (yychar == YYerror) ------------------ | | 50| 5.31M|#define yychar re_yychar ------------------ else if (yychar == YYerror) ------------------ | | 75| 5.31M|#define YYerror 256 ------------------ | Branch (1184:12): [True: 0, False: 5.31M] ------------------ 1185| 0| { 1186| | /* The scanner already issued an error message, process directly 1187| | to error recovery. But do not keep the error token as 1188| | lookahead, it is too special and may lead us to an endless 1189| | loop in error recovery. */ 1190| 0| yychar = YYUNDEF; ------------------ | | 50| 0|#define yychar re_yychar ------------------ yychar = YYUNDEF; ------------------ | | 76| 0|#define YYUNDEF 257 ------------------ 1191| 0| yytoken = YYSYMBOL_YYerror; 1192| 0| goto yyerrlab1; 1193| 0| } 1194| 5.31M| else 1195| 5.31M| { 1196| 5.31M| yytoken = YYTRANSLATE (yychar); ------------------ | | 591| 5.31M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 585| 5.31M|#define YYMAXUTOK 269 | | ------------------ | | | Branch (591:4): [True: 5.31M, False: 0] | | | Branch (591:18): [True: 5.31M, False: 0] | | ------------------ | | 592| 5.31M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 116| 5.31M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 593| 5.31M| : YYSYMBOL_YYUNDEF) ------------------ 1197| 5.31M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1198| 5.31M| } 1199| | 1200| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1201| | detect an error, take that action. */ 1202| 5.37M| yyn += yytoken; 1203| 5.37M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 573| 5.34M|#define YYLAST 45 ------------------ | Branch (1203:7): [True: 29.9k, False: 5.34M] | Branch (1203:18): [True: 305, False: 5.34M] | Branch (1203:34): [True: 2.63M, False: 2.70M] ------------------ 1204| 2.67M| goto yydefault; 1205| 2.70M| yyn = yytable[yyn]; 1206| 2.70M| if (yyn <= 0) ------------------ | Branch (1206:7): [True: 0, False: 2.70M] ------------------ 1207| 0| { 1208| 0| if (yytable_value_is_error (yyn)) ------------------ | | 674| 0| 0 | | ------------------ | | | Branch (674:3): [Folded - Ignored] | | ------------------ ------------------ 1209| 0| goto yyerrlab; 1210| 0| yyn = -yyn; 1211| 0| goto yyreduce; 1212| 0| } 1213| | 1214| | /* Count tokens shifted since error; after three, turn off error 1215| | status. */ 1216| 2.70M| if (yyerrstatus) ------------------ | Branch (1216:7): [True: 567, False: 2.70M] ------------------ 1217| 567| yyerrstatus--; 1218| | 1219| | /* Shift the lookahead token. */ 1220| 2.70M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1221| 2.70M| yystate = yyn; 1222| 2.70M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1223| 2.70M| *++yyvsp = yylval; 1224| 2.70M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1225| | 1226| | /* Discard the shifted token. */ 1227| 2.70M| yychar = YYEMPTY; ------------------ | | 50| 2.70M|#define yychar re_yychar ------------------ yychar = YYEMPTY; ------------------ | | 73| 2.70M|#define YYEMPTY -2 ------------------ 1228| 2.70M| goto yynewstate; 1229| | 1230| | 1231| |/*-----------------------------------------------------------. 1232| || yydefault -- do the default action for the current state. | 1233| |`-----------------------------------------------------------*/ 1234| 7.80M|yydefault: 1235| 7.80M| yyn = yydefact[yystate]; 1236| 7.80M| if (yyn == 0) ------------------ | Branch (1236:7): [True: 6.07k, False: 7.79M] ------------------ 1237| 6.07k| goto yyerrlab; 1238| 7.79M| goto yyreduce; 1239| | 1240| | 1241| |/*-----------------------------. 1242| || yyreduce -- do a reduction. | 1243| |`-----------------------------*/ 1244| 7.79M|yyreduce: 1245| | /* yyn is the number of a rule to reduce with. */ 1246| 7.79M| yylen = yyr2[yyn]; 1247| | 1248| | /* If YYLEN is nonzero, implement the default value of the action: 1249| | '$$ = $1'. 1250| | 1251| | Otherwise, the following line sets YYVAL to garbage. 1252| | This behavior is undocumented and Bison 1253| | users should not rely upon it. Assigning to YYVAL 1254| | unconditionally makes the parser a bit smaller, and it avoids a 1255| | GCC warning that YYVAL may be used uninitialized. */ 1256| 7.79M| yyval = yyvsp[1-yylen]; 1257| | 1258| | 1259| 7.79M| YY_REDUCE_PRINT (yyn); 1260| 7.79M| switch (yyn) 1261| 7.79M| { 1262| 15.6k| case 2: /* re: alternative */ ------------------ | Branch (1262:3): [True: 15.6k, False: 7.78M] ------------------ 1263| 15.6k|#line 107 "re_grammar.y" 1264| 15.6k| { 1265| 15.6k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 15.6k|#define yyget_extra re_yyget_extra ------------------ 1266| 15.6k| re_ast->root_node = (yyvsp[0].re_node); 1267| 15.6k| } 1268| 15.6k|#line 1269 "re_grammar.c" 1269| 15.6k| break; 1270| | 1271| 75.5k| case 4: /* alternative: concatenation */ ------------------ | Branch (1271:3): [True: 75.5k, False: 7.72M] ------------------ 1272| 75.5k|#line 116 "re_grammar.y" 1273| 75.5k| { 1274| 75.5k| (yyval.re_node) = (yyvsp[0].re_node); 1275| 75.5k| } 1276| 75.5k|#line 1277 "re_grammar.c" 1277| 75.5k| break; 1278| | 1279| 10.3k| case 5: /* alternative: alternative '|' concatenation */ ------------------ | Branch (1279:3): [True: 10.3k, False: 7.78M] ------------------ 1280| 10.3k|#line 120 "re_grammar.y" 1281| 10.3k| { 1282| 10.3k| mark_as_not_fast_regexp(); ------------------ | | 93| 10.3k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 10.3k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 10.3k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1283| | 1284| 10.3k| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 10.3k|#define RE_NODE_ALT 5 ------------------ 1285| | 1286| 10.3k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 10.3k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 10.3k] | | ------------------ | | 104| 10.3k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1287| 10.3k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 103| 10.3k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 10.3k] | | ------------------ | | 104| 10.3k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1288| | 1289| 10.3k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 10.3k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 10.3k] | | ------------------ | | 97| 10.3k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1290| | 1291| 10.3k| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1292| 10.3k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1293| 10.3k| } 1294| 0|#line 1295 "re_grammar.c" 1295| 0| break; 1296| | 1297| 8.22k| case 6: /* alternative: alternative '|' */ ------------------ | Branch (1297:3): [True: 8.22k, False: 7.79M] ------------------ 1298| 8.22k|#line 134 "re_grammar.y" 1299| 8.22k| { 1300| 8.22k| RE_NODE* node; 1301| | 1302| 8.22k| mark_as_not_fast_regexp(); ------------------ | | 93| 8.22k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 8.22k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 8.22k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1303| | 1304| 8.22k| node = yr_re_node_create(RE_NODE_EMPTY); ------------------ | | 56| 8.22k|#define RE_NODE_EMPTY 16 ------------------ 1305| | 1306| 8.22k| destroy_node_if(node == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 8.22k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 8.22k] | | ------------------ | | 104| 8.22k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1307| 8.22k| fail_if(node == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 8.22k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 8.22k] | | ------------------ | | 97| 8.22k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1308| | 1309| 8.22k| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 8.22k|#define RE_NODE_ALT 5 ------------------ 1310| | 1311| 8.22k| destroy_node_if((yyval.re_node) == NULL, node); ------------------ | | 103| 8.22k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 8.22k] | | ------------------ | | 104| 8.22k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1312| 8.22k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 8.22k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 8.22k] | | ------------------ | | 104| 8.22k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1313| | 1314| 8.22k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 8.22k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 8.22k] | | ------------------ | | 97| 8.22k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1315| | 1316| 8.22k| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1317| 8.22k| yr_re_node_append_child((yyval.re_node), node); 1318| 8.22k| } 1319| 0|#line 1320 "re_grammar.c" 1320| 0| break; 1321| | 1322| 87.3k| case 7: /* concatenation: repeat */ ------------------ | Branch (1322:3): [True: 87.3k, False: 7.71M] ------------------ 1323| 87.3k|#line 158 "re_grammar.y" 1324| 87.3k| { 1325| 87.3k| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 87.3k|#define RE_NODE_CONCAT 4 ------------------ 1326| | 1327| 87.3k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 103| 87.3k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 87.3k] | | ------------------ | | 104| 87.3k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1328| 87.3k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 87.3k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 87.3k] | | ------------------ | | 97| 87.3k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1329| | 1330| 87.3k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1331| 87.3k| } 1332| 0|#line 1333 "re_grammar.c" 1333| 0| break; 1334| | 1335| 2.47M| case 8: /* concatenation: concatenation repeat */ ------------------ | Branch (1335:3): [True: 2.47M, False: 5.32M] ------------------ 1336| 2.47M|#line 167 "re_grammar.y" 1337| 2.47M| { 1338| 2.47M| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1339| 2.47M| (yyval.re_node) = (yyvsp[-1].re_node); 1340| 2.47M| } 1341| 2.47M|#line 1342 "re_grammar.c" 1342| 2.47M| break; 1343| | 1344| 783| case 9: /* repeat: single '*' */ ------------------ | Branch (1344:3): [True: 783, False: 7.79M] ------------------ 1345| 783|#line 175 "re_grammar.y" 1346| 783| { 1347| 783| RE_AST* re_ast; 1348| | 1349| 783| mark_as_not_fast_regexp(); ------------------ | | 93| 783| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 783|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 783|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1350| | 1351| 783| re_ast = yyget_extra(yyscanner); ------------------ | | 53| 783|#define yyget_extra re_yyget_extra ------------------ 1352| 783| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 783|#define RE_FLAGS_GREEDY 0x400 ------------------ 1353| | 1354| 783| (yyval.re_node) = yr_re_node_create(RE_NODE_STAR); ------------------ | | 47| 783|#define RE_NODE_STAR 7 ------------------ 1355| | 1356| 783| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 783| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 783] | | ------------------ | | 104| 783| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1357| 783| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 783| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 783] | | ------------------ | | 97| 783| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1358| | 1359| 783| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1360| 783| } 1361| 0|#line 1362 "re_grammar.c" 1362| 0| break; 1363| | 1364| 298| case 10: /* repeat: single '*' '?' */ ------------------ | Branch (1364:3): [True: 298, False: 7.79M] ------------------ 1365| 298|#line 191 "re_grammar.y" 1366| 298| { 1367| 298| RE_AST* re_ast; 1368| | 1369| 298| mark_as_not_fast_regexp(); ------------------ | | 93| 298| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 298|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 298|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1370| | 1371| 298| re_ast = yyget_extra(yyscanner); ------------------ | | 53| 298|#define yyget_extra re_yyget_extra ------------------ 1372| 298| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 298|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1373| | 1374| 298| (yyval.re_node) = yr_re_node_create(RE_NODE_STAR); ------------------ | | 47| 298|#define RE_NODE_STAR 7 ------------------ 1375| | 1376| 298| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 298| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 298] | | ------------------ | | 104| 298| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1377| 298| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 298| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 298] | | ------------------ | | 97| 298| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1378| | 1379| 298| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1380| | 1381| 298| (yyval.re_node)->greedy = false; 1382| 298| } 1383| 0|#line 1384 "re_grammar.c" 1384| 0| break; 1385| | 1386| 1.28k| case 11: /* repeat: single '+' */ ------------------ | Branch (1386:3): [True: 1.28k, False: 7.79M] ------------------ 1387| 1.28k|#line 209 "re_grammar.y" 1388| 1.28k| { 1389| 1.28k| RE_AST* re_ast; 1390| | 1391| 1.28k| mark_as_not_fast_regexp(); ------------------ | | 93| 1.28k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 1.28k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 1.28k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1392| | 1393| 1.28k| re_ast = yyget_extra(yyscanner); ------------------ | | 53| 1.28k|#define yyget_extra re_yyget_extra ------------------ 1394| 1.28k| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 1.28k|#define RE_FLAGS_GREEDY 0x400 ------------------ 1395| | 1396| 1.28k| (yyval.re_node) = yr_re_node_create(RE_NODE_PLUS); ------------------ | | 48| 1.28k|#define RE_NODE_PLUS 8 ------------------ 1397| | 1398| 1.28k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 1.28k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 1.28k] | | ------------------ | | 104| 1.28k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1399| 1.28k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 1.28k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 1.28k] | | ------------------ | | 97| 1.28k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1400| | 1401| 1.28k| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1402| 1.28k| } 1403| 0|#line 1404 "re_grammar.c" 1404| 0| break; 1405| | 1406| 212| case 12: /* repeat: single '+' '?' */ ------------------ | Branch (1406:3): [True: 212, False: 7.79M] ------------------ 1407| 212|#line 225 "re_grammar.y" 1408| 212| { 1409| 212| RE_AST* re_ast; 1410| | 1411| 212| mark_as_not_fast_regexp(); ------------------ | | 93| 212| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 212|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 212|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1412| | 1413| 212| re_ast = yyget_extra(yyscanner); ------------------ | | 53| 212|#define yyget_extra re_yyget_extra ------------------ 1414| 212| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 212|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1415| | 1416| 212| (yyval.re_node) = yr_re_node_create(RE_NODE_PLUS); ------------------ | | 48| 212|#define RE_NODE_PLUS 8 ------------------ 1417| | 1418| 212| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 212| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 212] | | ------------------ | | 104| 212| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1419| 212| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 212| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 212] | | ------------------ | | 97| 212| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1420| | 1421| 212| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1422| 212| (yyval.re_node)->greedy = false; 1423| 212| } 1424| 0|#line 1425 "re_grammar.c" 1425| 0| break; 1426| | 1427| 1.06k| case 13: /* repeat: single '?' */ ------------------ | Branch (1427:3): [True: 1.06k, False: 7.79M] ------------------ 1428| 1.06k|#line 242 "re_grammar.y" 1429| 1.06k| { 1430| 1.06k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 1.06k|#define yyget_extra re_yyget_extra ------------------ 1431| 1.06k| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 1.06k|#define RE_FLAGS_GREEDY 0x400 ------------------ 1432| | 1433| 1.06k| if ((yyvsp[-1].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 1.06k|#define RE_NODE_ANY 3 ------------------ | Branch (1433:13): [True: 172, False: 893] ------------------ 1434| 172| { 1435| 172| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 172|#define RE_NODE_RANGE_ANY 21 ------------------ 1436| 172| destroy_node_if(true, (yyvsp[-1].re_node)); ------------------ | | 103| 172| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 172| { \ | | 105| 172| yr_re_node_destroy(node); \ | | 106| 172| } \ ------------------ 1437| 172| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 172| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 172] | | ------------------ | | 97| 172| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1438| 172| } 1439| 893| else 1440| 893| { 1441| 893| mark_as_not_fast_regexp(); ------------------ | | 93| 893| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 893|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 893|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1442| 893| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 893|#define RE_NODE_RANGE 6 ------------------ 1443| 893| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 893| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 893] | | ------------------ | | 104| 893| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1444| 893| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 893| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 893] | | ------------------ | | 97| 893| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1445| 893| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1446| 893| } 1447| | 1448| 1.06k| (yyval.re_node)->start = 0; 1449| 1.06k| (yyval.re_node)->end = 1; 1450| 1.06k| } 1451| 0|#line 1452 "re_grammar.c" 1452| 0| break; 1453| | 1454| 759| case 14: /* repeat: single '?' '?' */ ------------------ | Branch (1454:3): [True: 759, False: 7.79M] ------------------ 1455| 759|#line 265 "re_grammar.y" 1456| 759| { 1457| 759| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 759|#define yyget_extra re_yyget_extra ------------------ 1458| 759| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 759|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1459| | 1460| 759| if ((yyvsp[-2].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 759|#define RE_NODE_ANY 3 ------------------ | Branch (1460:13): [True: 607, False: 152] ------------------ 1461| 607| { 1462| 607| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 607|#define RE_NODE_RANGE_ANY 21 ------------------ 1463| 607| destroy_node_if(true, (yyvsp[-2].re_node)); ------------------ | | 103| 607| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 607| { \ | | 105| 607| yr_re_node_destroy(node); \ | | 106| 607| } \ ------------------ 1464| 607| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 607| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 607] | | ------------------ | | 97| 607| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1465| 607| } 1466| 152| else 1467| 152| { 1468| 152| mark_as_not_fast_regexp(); ------------------ | | 93| 152| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 152|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 152|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1469| 152| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 152|#define RE_NODE_RANGE 6 ------------------ 1470| 152| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 152| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 152] | | ------------------ | | 104| 152| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1471| 152| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 152| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 152] | | ------------------ | | 97| 152| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1472| 152| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1473| 152| } 1474| | 1475| 759| (yyval.re_node)->start = 0; 1476| 759| (yyval.re_node)->end = 1; 1477| 759| (yyval.re_node)->greedy = false; 1478| 759| } 1479| 0|#line 1480 "re_grammar.c" 1480| 0| break; 1481| | 1482| 1.46k| case 15: /* repeat: single _RANGE_ */ ------------------ | Branch (1482:3): [True: 1.46k, False: 7.79M] ------------------ 1483| 1.46k|#line 289 "re_grammar.y" 1484| 1.46k| { 1485| 1.46k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 1.46k|#define yyget_extra re_yyget_extra ------------------ 1486| 1.46k| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 1.46k|#define RE_FLAGS_GREEDY 0x400 ------------------ 1487| | 1488| 1.46k| if ((yyvsp[-1].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 1.46k|#define RE_NODE_ANY 3 ------------------ | Branch (1488:13): [True: 148, False: 1.31k] ------------------ 1489| 148| { 1490| 148| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 148|#define RE_NODE_RANGE_ANY 21 ------------------ 1491| 148| destroy_node_if(true, (yyvsp[-1].re_node)); ------------------ | | 103| 148| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 148| { \ | | 105| 148| yr_re_node_destroy(node); \ | | 106| 148| } \ ------------------ 1492| 148| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 148| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 148] | | ------------------ | | 97| 148| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1493| 148| } 1494| 1.31k| else 1495| 1.31k| { 1496| 1.31k| mark_as_not_fast_regexp(); ------------------ | | 93| 1.31k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 1.31k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 1.31k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1497| 1.31k| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 1.31k|#define RE_NODE_RANGE 6 ------------------ 1498| 1.31k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 1.31k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 1.31k] | | ------------------ | | 104| 1.31k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1499| 1.31k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 1.31k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 1.31k] | | ------------------ | | 97| 1.31k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1500| 1.31k| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1501| 1.31k| } 1502| | 1503| 1.46k| (yyval.re_node)->start = (yyvsp[0].range) & 0xFFFF;; 1504| 1.46k| (yyval.re_node)->end = (yyvsp[0].range) >> 16;; 1505| 1.46k| } 1506| 0|#line 1507 "re_grammar.c" 1507| 0| break; 1508| | 1509| 3.54k| case 16: /* repeat: single _RANGE_ '?' */ ------------------ | Branch (1509:3): [True: 3.54k, False: 7.79M] ------------------ 1510| 3.54k|#line 312 "re_grammar.y" 1511| 3.54k| { 1512| 3.54k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 3.54k|#define yyget_extra re_yyget_extra ------------------ 1513| 3.54k| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 3.54k|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1514| | 1515| 3.54k| if ((yyvsp[-2].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 3.54k|#define RE_NODE_ANY 3 ------------------ | Branch (1515:13): [True: 3.22k, False: 322] ------------------ 1516| 3.22k| { 1517| 3.22k| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 3.22k|#define RE_NODE_RANGE_ANY 21 ------------------ 1518| 3.22k| destroy_node_if(true, (yyvsp[-2].re_node)); ------------------ | | 103| 3.22k| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 3.22k| { \ | | 105| 3.22k| yr_re_node_destroy(node); \ | | 106| 3.22k| } \ ------------------ 1519| 3.22k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 3.22k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 3.22k] | | ------------------ | | 97| 3.22k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1520| 3.22k| } 1521| 322| else 1522| 322| { 1523| 322| mark_as_not_fast_regexp(); ------------------ | | 93| 322| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 322|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 322|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1524| 322| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 322|#define RE_NODE_RANGE 6 ------------------ 1525| 322| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 322| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 322] | | ------------------ | | 104| 322| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1526| 322| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 322| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 322] | | ------------------ | | 97| 322| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1527| 322| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1528| 322| } 1529| | 1530| 3.54k| (yyval.re_node)->start = (yyvsp[-1].range) & 0xFFFF;; 1531| 3.54k| (yyval.re_node)->end = (yyvsp[-1].range) >> 16;; 1532| 3.54k| (yyval.re_node)->greedy = false; 1533| 3.54k| } 1534| 0|#line 1535 "re_grammar.c" 1535| 0| break; 1536| | 1537| 2.54M| case 17: /* repeat: single */ ------------------ | Branch (1537:3): [True: 2.54M, False: 5.25M] ------------------ 1538| 2.54M|#line 336 "re_grammar.y" 1539| 2.54M| { 1540| 2.54M| (yyval.re_node) = (yyvsp[0].re_node); 1541| 2.54M| } 1542| 2.54M|#line 1543 "re_grammar.c" 1543| 2.54M| break; 1544| | 1545| 145| case 18: /* repeat: _WORD_BOUNDARY_ */ ------------------ | Branch (1545:3): [True: 145, False: 7.79M] ------------------ 1546| 145|#line 340 "re_grammar.y" 1547| 145| { 1548| 145| (yyval.re_node) = yr_re_node_create(RE_NODE_WORD_BOUNDARY); ------------------ | | 59| 145|#define RE_NODE_WORD_BOUNDARY 19 ------------------ 1549| | 1550| 145| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 145| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 145] | | ------------------ | | 97| 145| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1551| 145| } 1552| 0|#line 1553 "re_grammar.c" 1553| 0| break; 1554| | 1555| 131| case 19: /* repeat: _NON_WORD_BOUNDARY_ */ ------------------ | Branch (1555:3): [True: 131, False: 7.79M] ------------------ 1556| 131|#line 346 "re_grammar.y" 1557| 131| { 1558| 131| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_WORD_BOUNDARY); ------------------ | | 60| 131|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ 1559| | 1560| 131| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 131| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 131] | | ------------------ | | 97| 131| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1561| 131| } 1562| 0|#line 1563 "re_grammar.c" 1563| 0| break; 1564| | 1565| 557| case 20: /* repeat: '^' */ ------------------ | Branch (1565:3): [True: 557, False: 7.79M] ------------------ 1566| 557|#line 352 "re_grammar.y" 1567| 557| { 1568| 557| (yyval.re_node) = yr_re_node_create(RE_NODE_ANCHOR_START); ------------------ | | 57| 557|#define RE_NODE_ANCHOR_START 17 ------------------ 1569| | 1570| 557| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 557| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 557] | | ------------------ | | 97| 557| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1571| 557| } 1572| 0|#line 1573 "re_grammar.c" 1573| 0| break; 1574| | 1575| 2.45k| case 21: /* repeat: '$' */ ------------------ | Branch (1575:3): [True: 2.45k, False: 7.79M] ------------------ 1576| 2.45k|#line 358 "re_grammar.y" 1577| 2.45k| { 1578| 2.45k| (yyval.re_node) = yr_re_node_create(RE_NODE_ANCHOR_END); ------------------ | | 58| 2.45k|#define RE_NODE_ANCHOR_END 18 ------------------ 1579| | 1580| 2.45k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 2.45k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 2.45k] | | ------------------ | | 97| 2.45k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1581| 2.45k| } 1582| 0|#line 1583 "re_grammar.c" 1583| 0| break; 1584| | 1585| 59.3k| case 22: /* single: '(' alternative ')' */ ------------------ | Branch (1585:3): [True: 59.3k, False: 7.74M] ------------------ 1586| 59.3k|#line 367 "re_grammar.y" 1587| 59.3k| { 1588| 59.3k| (yyval.re_node) = (yyvsp[-1].re_node); 1589| 59.3k| } 1590| 59.3k|#line 1591 "re_grammar.c" 1591| 59.3k| break; 1592| | 1593| 11.3k| case 23: /* single: '.' */ ------------------ | Branch (1593:3): [True: 11.3k, False: 7.78M] ------------------ 1594| 11.3k|#line 371 "re_grammar.y" 1595| 11.3k| { 1596| 11.3k| (yyval.re_node) = yr_re_node_create(RE_NODE_ANY); ------------------ | | 43| 11.3k|#define RE_NODE_ANY 3 ------------------ 1597| | 1598| 11.3k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 11.3k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 11.3k] | | ------------------ | | 97| 11.3k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1599| | 1600| 11.3k| (yyval.re_node)->value = 0x00; 1601| 11.3k| (yyval.re_node)->mask = 0x00; 1602| 11.3k| } 1603| 0|#line 1604 "re_grammar.c" 1604| 0| break; 1605| | 1606| 2.48M| case 24: /* single: _CHAR_ */ ------------------ | Branch (1606:3): [True: 2.48M, False: 5.31M] ------------------ 1607| 2.48M|#line 380 "re_grammar.y" 1608| 2.48M| { 1609| 2.48M| (yyval.re_node) = yr_re_node_create(RE_NODE_LITERAL); ------------------ | | 41| 2.48M|#define RE_NODE_LITERAL 1 ------------------ 1610| | 1611| 2.48M| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 2.48M| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 2.48M] | | ------------------ | | 97| 2.48M| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1612| | 1613| 2.48M| (yyval.re_node)->value = (yyvsp[0].integer); 1614| 2.48M| (yyval.re_node)->mask = 0xFF; 1615| 2.48M| } 1616| 0|#line 1617 "re_grammar.c" 1617| 0| break; 1618| | 1619| 142| case 25: /* single: _WORD_CHAR_ */ ------------------ | Branch (1619:3): [True: 142, False: 7.79M] ------------------ 1620| 142|#line 389 "re_grammar.y" 1621| 142| { 1622| 142| (yyval.re_node) = yr_re_node_create(RE_NODE_WORD_CHAR); ------------------ | | 50| 142|#define RE_NODE_WORD_CHAR 10 ------------------ 1623| | 1624| 142| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 142| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 142] | | ------------------ | | 97| 142| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1625| 142| } 1626| 0|#line 1627 "re_grammar.c" 1627| 0| break; 1628| | 1629| 313| case 26: /* single: _NON_WORD_CHAR_ */ ------------------ | Branch (1629:3): [True: 313, False: 7.79M] ------------------ 1630| 313|#line 395 "re_grammar.y" 1631| 313| { 1632| 313| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_WORD_CHAR); ------------------ | | 51| 313|#define RE_NODE_NON_WORD_CHAR 11 ------------------ 1633| | 1634| 313| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 313| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 313] | | ------------------ | | 97| 313| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1635| 313| } 1636| 0|#line 1637 "re_grammar.c" 1637| 0| break; 1638| | 1639| 254| case 27: /* single: _SPACE_ */ ------------------ | Branch (1639:3): [True: 254, False: 7.79M] ------------------ 1640| 254|#line 401 "re_grammar.y" 1641| 254| { 1642| 254| (yyval.re_node) = yr_re_node_create(RE_NODE_SPACE); ------------------ | | 52| 254|#define RE_NODE_SPACE 12 ------------------ 1643| | 1644| 254| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 254| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 254] | | ------------------ | | 97| 254| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1645| 254| } 1646| 0|#line 1647 "re_grammar.c" 1647| 0| break; 1648| | 1649| 1.58k| case 28: /* single: _NON_SPACE_ */ ------------------ | Branch (1649:3): [True: 1.58k, False: 7.79M] ------------------ 1650| 1.58k|#line 407 "re_grammar.y" 1651| 1.58k| { 1652| 1.58k| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_SPACE); ------------------ | | 53| 1.58k|#define RE_NODE_NON_SPACE 13 ------------------ 1653| | 1654| 1.58k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 1.58k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 1.58k] | | ------------------ | | 97| 1.58k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1655| 1.58k| } 1656| 0|#line 1657 "re_grammar.c" 1657| 0| break; 1658| | 1659| 154| case 29: /* single: _DIGIT_ */ ------------------ | Branch (1659:3): [True: 154, False: 7.79M] ------------------ 1660| 154|#line 413 "re_grammar.y" 1661| 154| { 1662| 154| (yyval.re_node) = yr_re_node_create(RE_NODE_DIGIT); ------------------ | | 54| 154|#define RE_NODE_DIGIT 14 ------------------ 1663| | 1664| 154| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 154| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 154] | | ------------------ | | 97| 154| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1665| 154| } 1666| 0|#line 1667 "re_grammar.c" 1667| 0| break; 1668| | 1669| 157| case 30: /* single: _NON_DIGIT_ */ ------------------ | Branch (1669:3): [True: 157, False: 7.79M] ------------------ 1670| 157|#line 419 "re_grammar.y" 1671| 157| { 1672| 157| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_DIGIT); ------------------ | | 55| 157|#define RE_NODE_NON_DIGIT 15 ------------------ 1673| | 1674| 157| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 157| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 157] | | ------------------ | | 97| 157| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1675| 157| } 1676| 0|#line 1677 "re_grammar.c" 1677| 0| break; 1678| | 1679| 944| case 31: /* single: _CLASS_ */ ------------------ | Branch (1679:3): [True: 944, False: 7.79M] ------------------ 1680| 944|#line 425 "re_grammar.y" 1681| 944| { 1682| 944| (yyval.re_node) = yr_re_node_create(RE_NODE_CLASS); ------------------ | | 49| 944|#define RE_NODE_CLASS 9 ------------------ 1683| | 1684| 944| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 944| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 944] | | ------------------ | | 97| 944| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1685| | 1686| 944| (yyval.re_node)->re_class = (yyvsp[0].re_class); 1687| 944| } 1688| 0|#line 1689 "re_grammar.c" 1689| 0| break; 1690| | 1691| | 1692| 0|#line 1693 "re_grammar.c" 1693| | 1694| 6.07k| default: break; ------------------ | Branch (1694:7): [True: 6.07k, False: 7.79M] ------------------ 1695| 7.79M| } 1696| | /* User semantic actions sometimes alter yychar, and that requires 1697| | that yytoken be updated with the new translation. We take the 1698| | approach of translating immediately before every use of yytoken. 1699| | One alternative is translating here after every semantic action, 1700| | but that translation would be missed if the semantic action invokes 1701| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1702| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1703| | incorrect destructor might then be invoked immediately. In the 1704| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 1705| | to an incorrect destructor call or verbose syntax error message 1706| | before the lookahead is translated. */ 1707| 7.79M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1708| | 1709| 7.79M| YYPOPSTACK (yylen); ------------------ | | 1054| 7.79M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1710| 7.79M| yylen = 0; 1711| | 1712| 7.79M| *++yyvsp = yyval; 1713| | 1714| | /* Now 'shift' the result of the reduction. Determine what state 1715| | that goes to, based on the state we popped back to and the rule 1716| | number reduced by. */ 1717| 7.79M| { 1718| 7.79M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 576| 7.79M|#define YYNTOKENS 24 ------------------ 1719| 7.79M| const int yyi = yypgoto[yylhs] + *yyssp; 1720| 7.79M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 573| 15.5M|#define YYLAST 45 ------------------ | Branch (1720:16): [True: 7.76M, False: 37.3k] | Branch (1720:28): [True: 7.76M, False: 0] | Branch (1720:45): [True: 4.13M, False: 3.62M] ------------------ 1721| 7.79M| ? yytable[yyi] 1722| 7.79M| : yydefgoto[yylhs]); 1723| 7.79M| } 1724| | 1725| 7.79M| goto yynewstate; 1726| | 1727| | 1728| |/*--------------------------------------. 1729| || yyerrlab -- here on detecting error. | 1730| |`--------------------------------------*/ 1731| 6.07k|yyerrlab: 1732| | /* Make sure we have latest lookahead translation. See comments at 1733| | user semantic actions for why this is necessary. */ 1734| 6.07k| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 50| 6.07k|#define yychar re_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 73| 6.07k|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 591| 12.1k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 585| 6.07k|#define YYMAXUTOK 269 | | ------------------ | | | Branch (591:4): [True: 6.07k, False: 0] | | | Branch (591:18): [True: 6.07k, False: 0] | | ------------------ | | 592| 12.1k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 116| 6.07k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 593| 12.1k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (1734:13): [True: 0, False: 6.07k] ------------------ 1735| | /* If not already recovering from an error, report this error. */ 1736| 6.07k| if (!yyerrstatus) ------------------ | Branch (1736:7): [True: 567, False: 5.50k] ------------------ 1737| 567| { 1738| 567| ++yynerrs; ------------------ | | 52| 567|#define yynerrs re_yynerrs ------------------ 1739| 567| yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 47| 567|#define yyerror re_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 375| 567|# define YY_(Msgid) Msgid ------------------ 1740| 567| } 1741| | 1742| 6.07k| if (yyerrstatus == 3) ------------------ | Branch (1742:7): [True: 5.50k, False: 567] ------------------ 1743| 5.50k| { 1744| | /* If just tried and failed to reuse lookahead token after an 1745| | error, discard it. */ 1746| | 1747| 5.50k| if (yychar <= YYEOF) ------------------ | | 50| 5.50k|#define yychar re_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 74| 5.50k|#define YYEOF 0 ------------------ | Branch (1747:11): [True: 0, False: 5.50k] ------------------ 1748| 0| { 1749| | /* Return failure if at end of input. */ 1750| 0| if (yychar == YYEOF) ------------------ | | 50| 0|#define yychar re_yychar ------------------ if (yychar == YYEOF) ------------------ | | 74| 0|#define YYEOF 0 ------------------ | Branch (1750:15): [True: 0, False: 0] ------------------ 1751| 0| YYABORT; ------------------ | | 765| 0|#define YYABORT goto yyabortlab ------------------ 1752| 0| } 1753| 5.50k| else 1754| 5.50k| { 1755| 5.50k| yydestruct ("Error: discarding", 1756| 5.50k| yytoken, &yylval, yyscanner, lex_env); 1757| 5.50k| yychar = YYEMPTY; ------------------ | | 50| 5.50k|#define yychar re_yychar ------------------ yychar = YYEMPTY; ------------------ | | 73| 5.50k|#define YYEMPTY -2 ------------------ 1758| 5.50k| } 1759| 5.50k| } 1760| | 1761| | /* Else will try to reuse lookahead token after shifting the error 1762| | token. */ 1763| 6.07k| goto yyerrlab1; 1764| | 1765| | 1766| |/*---------------------------------------------------. 1767| || yyerrorlab -- error raised explicitly by YYERROR. | 1768| |`---------------------------------------------------*/ 1769| 6.07k|yyerrorlab: 1770| | /* Pacify compilers when the user code never invokes YYERROR and the 1771| | label yyerrorlab therefore never appears in user code. */ 1772| 0| if (0) ------------------ | Branch (1772:7): [Folded - Ignored] ------------------ 1773| 0| YYERROR; ------------------ | | 766| 0|#define YYERROR goto yyerrorlab ------------------ 1774| 0| ++yynerrs; ------------------ | | 52| 0|#define yynerrs re_yynerrs ------------------ 1775| | 1776| | /* Do not reclaim the symbols of the rule whose action triggered 1777| | this YYERROR. */ 1778| 0| YYPOPSTACK (yylen); ------------------ | | 1054| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1779| 0| yylen = 0; 1780| 0| YY_STACK_PRINT (yyss, yyssp); 1781| 0| yystate = *yyssp; 1782| 0| goto yyerrlab1; 1783| | 1784| | 1785| |/*-------------------------------------------------------------. 1786| || yyerrlab1 -- common code for both syntax error and YYERROR. | 1787| |`-------------------------------------------------------------*/ 1788| 6.07k|yyerrlab1: 1789| 6.07k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 1790| | 1791| | /* Pop stack until we find a state that shifts the error token. */ 1792| 6.07k| for (;;) 1793| 49.1k| { 1794| 49.1k| yyn = yypact[yystate]; 1795| 49.1k| if (!yypact_value_is_default (yyn)) ------------------ | | 669| 49.1k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 666| 49.1k|#define YYPACT_NINF (-12) | | ------------------ ------------------ | Branch (1795:11): [True: 49.1k, False: 0] ------------------ 1796| 49.1k| { 1797| 49.1k| yyn += YYSYMBOL_YYerror; 1798| 49.1k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 573| 98.3k|#define YYLAST 45 ------------------ | Branch (1798:15): [True: 49.1k, False: 11] | Branch (1798:27): [True: 49.1k, False: 0] | Branch (1798:44): [True: 6.07k, False: 43.0k] ------------------ 1799| 6.07k| { 1800| 6.07k| yyn = yytable[yyn]; 1801| 6.07k| if (0 < yyn) ------------------ | Branch (1801:19): [True: 6.07k, False: 0] ------------------ 1802| 6.07k| break; 1803| 6.07k| } 1804| 49.1k| } 1805| | 1806| | /* Pop the current state because it cannot handle the error token. */ 1807| 43.0k| if (yyssp == yyss) ------------------ | Branch (1807:11): [True: 0, False: 43.0k] ------------------ 1808| 0| YYABORT; ------------------ | | 765| 0|#define YYABORT goto yyabortlab ------------------ 1809| | 1810| | 1811| 43.0k| yydestruct ("Error: popping", 1812| 43.0k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, lex_env); ------------------ | | 640| 43.0k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 116| 43.0k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1813| 43.0k| YYPOPSTACK (1); ------------------ | | 1054| 43.0k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1814| 43.0k| yystate = *yyssp; 1815| 43.0k| YY_STACK_PRINT (yyss, yyssp); 1816| 43.0k| } 1817| | 1818| 6.07k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1819| 6.07k| *++yyvsp = yylval; 1820| 6.07k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1821| | 1822| | 1823| | /* Shift the error token. */ 1824| 6.07k| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1825| | 1826| 6.07k| yystate = yyn; 1827| 6.07k| goto yynewstate; 1828| | 1829| | 1830| |/*-------------------------------------. 1831| || yyacceptlab -- YYACCEPT comes here. | 1832| |`-------------------------------------*/ 1833| 15.9k|yyacceptlab: 1834| 15.9k| yyresult = 0; 1835| 15.9k| goto yyreturnlab; 1836| | 1837| | 1838| |/*-----------------------------------. 1839| || yyabortlab -- YYABORT comes here. | 1840| |`-----------------------------------*/ 1841| 0|yyabortlab: 1842| 0| yyresult = 1; 1843| 0| goto yyreturnlab; 1844| | 1845| | 1846| |/*-----------------------------------------------------------. 1847| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1848| |`-----------------------------------------------------------*/ 1849| 0|yyexhaustedlab: 1850| 0| yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 47| 0|#define yyerror re_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 375| 0|# define YY_(Msgid) Msgid ------------------ 1851| 0| yyresult = 2; 1852| 0| goto yyreturnlab; 1853| | 1854| | 1855| |/*----------------------------------------------------------. 1856| || yyreturnlab -- parsing is finished, clean up and return. | 1857| |`----------------------------------------------------------*/ 1858| 15.9k|yyreturnlab: 1859| 15.9k| if (yychar != YYEMPTY) ------------------ | | 50| 15.9k|#define yychar re_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 73| 15.9k|#define YYEMPTY -2 ------------------ | Branch (1859:7): [True: 0, False: 15.9k] ------------------ 1860| 0| { 1861| | /* Make sure we have latest lookahead translation. See comments at 1862| | user semantic actions for why this is necessary. */ 1863| 0| yytoken = YYTRANSLATE (yychar); ------------------ | | 591| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 585| 0|#define YYMAXUTOK 269 | | ------------------ | | | Branch (591:4): [True: 0, False: 0] | | | Branch (591:18): [True: 0, False: 0] | | ------------------ | | 592| 0| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 116| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 593| 0| : YYSYMBOL_YYUNDEF) ------------------ 1864| 0| yydestruct ("Cleanup: discarding lookahead", 1865| 0| yytoken, &yylval, yyscanner, lex_env); 1866| 0| } 1867| | /* Do not reclaim the symbols of the rule whose action triggered 1868| | this YYABORT or YYACCEPT. */ 1869| 15.9k| YYPOPSTACK (yylen); ------------------ | | 1054| 15.9k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1870| 15.9k| YY_STACK_PRINT (yyss, yyssp); 1871| 47.9k| while (yyssp != yyss) ------------------ | Branch (1871:10): [True: 31.9k, False: 15.9k] ------------------ 1872| 31.9k| { 1873| 31.9k| yydestruct ("Cleanup: popping", 1874| 31.9k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, lex_env); ------------------ | | 640| 31.9k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 116| 31.9k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1875| 31.9k| YYPOPSTACK (1); ------------------ | | 1054| 31.9k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1876| 31.9k| } 1877| 15.9k|#ifndef yyoverflow 1878| 15.9k| if (yyss != yyssa) ------------------ | Branch (1878:7): [True: 104, False: 15.8k] ------------------ 1879| 104| YYSTACK_FREE (yyss); ------------------ | | 483| 104|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 90| 104|#define YYFREE yr_free | | ------------------ ------------------ 1880| 15.9k|#endif 1881| | 1882| 15.9k| return yyresult; 1883| 6.07k|} re_grammar.c:yydestruct: 951| 80.5k|{ 952| 80.5k| YY_USE (yyvaluep); ------------------ | | 398| 80.5k|# define YY_USE(E) ((void) (E)) ------------------ 953| 80.5k| YY_USE (yyscanner); ------------------ | | 398| 80.5k|# define YY_USE(E) ((void) (E)) ------------------ 954| 80.5k| YY_USE (lex_env); ------------------ | | 398| 80.5k|# define YY_USE(E) ((void) (E)) ------------------ 955| 80.5k| if (!yymsg) ------------------ | Branch (955:7): [True: 0, False: 80.5k] ------------------ 956| 0| yymsg = "Deleting"; 957| 80.5k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 958| | 959| 80.5k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 960| 80.5k| switch (yykind) 961| 80.5k| { 962| 159| case YYSYMBOL__CLASS_: /* _CLASS_ */ ------------------ | Branch (962:5): [True: 159, False: 80.4k] ------------------ 963| 159|#line 98 "re_grammar.y" 964| 159| { yr_free(((*yyvaluep).re_class)); ((*yyvaluep).re_class) = NULL; } 965| 159|#line 966 "re_grammar.c" 966| 159| break; 967| | 968| 514| case YYSYMBOL_alternative: /* alternative */ ------------------ | Branch (968:5): [True: 514, False: 80.0k] ------------------ 969| 514|#line 99 "re_grammar.y" 970| 514| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 971| 514|#line 972 "re_grammar.c" 972| 514| break; 973| | 974| 1.49k| case YYSYMBOL_concatenation: /* concatenation */ ------------------ | Branch (974:5): [True: 1.49k, False: 79.0k] ------------------ 975| 1.49k|#line 100 "re_grammar.y" 976| 1.49k| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 977| 1.49k|#line 978 "re_grammar.c" 978| 1.49k| break; 979| | 980| 0| case YYSYMBOL_repeat: /* repeat */ ------------------ | Branch (980:5): [True: 0, False: 80.5k] ------------------ 981| 0|#line 101 "re_grammar.y" 982| 0| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 983| 0|#line 984 "re_grammar.c" 984| 0| break; 985| | 986| 0| case YYSYMBOL_single: /* single */ ------------------ | Branch (986:5): [True: 0, False: 80.5k] ------------------ 987| 0|#line 102 "re_grammar.y" 988| 0| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 989| 0|#line 990 "re_grammar.c" 990| 0| break; 991| | 992| 78.4k| default: ------------------ | Branch (992:7): [True: 78.4k, False: 2.16k] ------------------ 993| 78.4k| break; 994| 80.5k| } 995| 80.5k| YY_IGNORE_MAYBE_UNINITIALIZED_END 996| 80.5k|} re_yylex: 1044| 2.71M|{ 1045| 2.71M| yy_state_type yy_current_state; 1046| 2.71M| char *yy_cp, *yy_bp; 1047| 2.71M| int yy_act; 1048| 2.71M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1049| | 1050| 2.71M| yylval = yylval_param; ------------------ | | 863| 2.71M| # define yylval yyg->yylval_r ------------------ 1051| | 1052| 2.71M| if ( !yyg->yy_init ) ------------------ | Branch (1052:7): [True: 15.9k, False: 2.69M] ------------------ 1053| 15.9k| { 1054| 15.9k| yyg->yy_init = 1; 1055| | 1056| |#ifdef YY_USER_INIT 1057| | YY_USER_INIT; 1058| |#endif 1059| | 1060| 15.9k| if ( ! yyg->yy_start ) ------------------ | Branch (1060:8): [True: 15.9k, False: 0] ------------------ 1061| 15.9k| yyg->yy_start = 1; /* first start state */ 1062| | 1063| 15.9k| if ( ! yyin ) ------------------ | | 344| 15.9k|#define yyin yyg->yyin_r ------------------ | Branch (1063:8): [True: 15.9k, False: 0] ------------------ 1064| 15.9k| yyin = stdin; ------------------ | | 344| 15.9k|#define yyin yyg->yyin_r ------------------ 1065| | 1066| 15.9k| if ( ! yyout ) ------------------ | | 345| 15.9k|#define yyout yyg->yyout_r ------------------ | Branch (1066:8): [True: 15.9k, False: 0] ------------------ 1067| 15.9k| yyout = stdout; ------------------ | | 345| 15.9k|#define yyout yyg->yyout_r ------------------ 1068| | 1069| 15.9k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ | Branch (1069:8): [True: 0, False: 15.9k] ------------------ 1070| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 1071| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1072| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer re_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 379| 0|#define YY_BUF_SIZE 16384 ------------------ 1073| 0| } 1074| | 1075| 15.9k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 15.9k|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 1076| 15.9k| } 1077| | 1078| 2.71M| { 1079| 2.71M|#line 114 "libyara/re_lexer.l" 1080| | 1081| | 1082| 2.71M|#line 1082 "libyara/re_lexer.c" 1083| | 1084| 2.72M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1084:23): [Folded - Ignored] ------------------ 1085| 2.72M| { 1086| 2.72M| yy_cp = yyg->yy_c_buf_p; 1087| | 1088| | /* Support of yytext. */ 1089| 2.72M| *yy_cp = yyg->yy_hold_char; 1090| | 1091| | /* yy_bp points to the position in yy_ch_buf of the start of 1092| | * the current run. 1093| | */ 1094| 2.72M| yy_bp = yy_cp; 1095| | 1096| 2.72M| yy_current_state = yyg->yy_start; 1097| 2.72M|yy_match: 1098| 2.72M| do 1099| 5.52M| { 1100| 5.52M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 5.52M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1101| 5.52M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1101:9): [True: 2.75M, False: 2.76M] ------------------ 1102| 2.75M| { 1103| 2.75M| yyg->yy_last_accepting_state = yy_current_state; 1104| 2.75M| yyg->yy_last_accepting_cpos = yy_cp; 1105| 2.75M| } 1106| 9.72M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1106:12): [True: 4.19M, False: 5.52M] ------------------ 1107| 4.19M| { 1108| 4.19M| yy_current_state = (int) yy_def[yy_current_state]; 1109| 4.19M| if ( yy_current_state >= 47 ) ------------------ | Branch (1109:10): [True: 1.47M, False: 2.72M] ------------------ 1110| 1.47M| yy_c = yy_meta[yy_c]; 1111| 4.19M| } 1112| 5.52M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1113| 5.52M| ++yy_cp; 1114| 5.52M| } 1115| 5.52M| while ( yy_current_state != 46 ); ------------------ | Branch (1115:11): [True: 2.79M, False: 2.72M] ------------------ 1116| 2.72M| yy_cp = yyg->yy_last_accepting_cpos; 1117| 2.72M| yy_current_state = yyg->yy_last_accepting_state; 1118| | 1119| 2.74M|yy_find_action: 1120| 2.74M| yy_act = yy_accept[yy_current_state]; 1121| | 1122| 2.74M| YY_DO_BEFORE_ACTION; ------------------ | | 578| 2.74M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 2.74M|#define yytext_ptr yytext_r | | ------------------ | | 579| 2.74M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 2.74M|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 2.74M| yyg->yy_hold_char = *yy_cp; \ | | 581| 2.74M| *yy_cp = '\0'; \ | | 582| 2.74M| yyg->yy_c_buf_p = yy_cp; ------------------ 1123| | 1124| 2.74M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 5.48M|#define YY_END_OF_BUFFER 30 ------------------ | Branch (1124:8): [True: 2.71M, False: 31.2k] | Branch (1124:38): [True: 1.44M, False: 1.26M] ------------------ 1125| 1.44M| { 1126| 1.44M| int yyl; 1127| 2.90M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 2.90M|#define yyleng yyg->yyleng_r ------------------ | Branch (1127:19): [True: 1.45M, False: 1.44M] ------------------ 1128| 1.45M| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 1.45M|#define yytext yyg->yytext_r ------------------ | Branch (1128:10): [True: 0, False: 1.45M] ------------------ 1129| | 1130| 0| do{ yylineno++; ------------------ | | 349| 0|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1131| 0| yycolumn=0; ------------------ | | 350| 0|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1132| 0| }while(0) ------------------ | Branch (1132:12): [Folded - Ignored] ------------------ 1133| 1.44M|; 1134| 1.44M| } 1135| | 1136| 2.75M|do_action: /* This label is used only to access EOF actions. */ 1137| | 1138| 2.75M| switch ( yy_act ) 1139| 2.75M| { /* beginning of action switch */ 1140| 380| case 0: /* must back up */ ------------------ | Branch (1140:4): [True: 380, False: 2.75M] ------------------ 1141| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1142| 380| *yy_cp = yyg->yy_hold_char; 1143| 380| yy_cp = yyg->yy_last_accepting_cpos; 1144| 380| yy_current_state = yyg->yy_last_accepting_state; 1145| 380| goto yy_find_action; 1146| | 1147| 4.37k|case 1: ------------------ | Branch (1147:1): [True: 4.37k, False: 2.75M] ------------------ 1148| 4.37k|YY_RULE_SETUP 1149| 4.37k|#line 116 "libyara/re_lexer.l" 1150| 4.37k|{ 1151| | 1152| | // Examples: {3,8} {3, 8}, {3 ,8} {3 , 8} {0,5} {,5} {7,} 1153| | 1154| 4.37k| int hi_bound; 1155| 4.37k| int lo_bound = atoi(yytext + 1); ------------------ | | 348| 4.37k|#define yytext yyg->yytext_r ------------------ 1156| | 1157| 4.37k| char* comma = strchr(yytext, ','); ------------------ | | 348| 4.37k|#define yytext yyg->yytext_r ------------------ 1158| 4.37k| char* hi_bound_ptr = comma + 1; 1159| | 1160| | // Skip spaces after the comma, if any. 1161| 4.38k| while (*hi_bound_ptr == ' ') hi_bound_ptr++; ------------------ | Branch (1161:10): [True: 7, False: 4.37k] ------------------ 1162| | 1163| 4.37k| if (*hi_bound_ptr == '}') ------------------ | Branch (1163:7): [True: 4.04k, False: 329] ------------------ 1164| 4.04k| hi_bound = RE_MAX_RANGE; ------------------ | | 39| 4.04k|#define RE_MAX_RANGE INT16_MAX ------------------ 1165| 329| else 1166| 329| hi_bound = atoi(hi_bound_ptr); 1167| | 1168| 4.37k| if (hi_bound > RE_MAX_RANGE) ------------------ | | 39| 4.37k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (1168:7): [True: 9, False: 4.36k] ------------------ 1169| 9| { 1170| 9| yyerror(yyscanner, lex_env, "repeat interval too large"); ------------------ | | 47| 9|#define yyerror re_yyerror ------------------ 1171| 9| yyterminate(); ------------------ | | 998| 9|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 9|#define YY_NULL 0 | | ------------------ ------------------ 1172| 9| } 1173| | 1174| 4.36k| if (hi_bound < lo_bound || hi_bound < 0 || lo_bound < 0) ------------------ | Branch (1174:7): [True: 11, False: 4.35k] | Branch (1174:30): [True: 0, False: 4.35k] | Branch (1174:46): [True: 10, False: 4.34k] ------------------ 1175| 21| { 1176| 21| yyerror(yyscanner, lex_env, "bad repeat interval"); ------------------ | | 47| 21|#define yyerror re_yyerror ------------------ 1177| 21| yyterminate(); ------------------ | | 998| 21|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 21|#define YY_NULL 0 | | ------------------ ------------------ 1178| 21| } 1179| | 1180| 4.34k| yylval->range = (hi_bound << 16) | lo_bound; ------------------ | | 863| 4.34k| # define yylval yyg->yylval_r ------------------ 1181| | 1182| 4.34k| return _RANGE_; ------------------ | | 79| 4.34k|#define _RANGE_ 260 ------------------ 1183| 4.36k|} 1184| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1185| 1.17k|case 2: ------------------ | Branch (1185:1): [True: 1.17k, False: 2.75M] ------------------ 1186| 1.17k|YY_RULE_SETUP 1187| 1.17k|#line 152 "libyara/re_lexer.l" 1188| 1.17k|{ 1189| | 1190| | // Example: {10} 1191| | 1192| 1.17k| int value = atoi(yytext + 1); ------------------ | | 348| 1.17k|#define yytext yyg->yytext_r ------------------ 1193| | 1194| | // atoi can return a negative value if the input string represents a number 1195| | // too large to fit in an integer. 1196| | 1197| 1.17k| if (value > RE_MAX_RANGE || value < 0) ------------------ | | 39| 2.35k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (1197:7): [True: 45, False: 1.13k] | Branch (1197:31): [True: 9, False: 1.12k] ------------------ 1198| 54| { 1199| 54| yyerror(yyscanner, lex_env, "repeat interval too large"); ------------------ | | 47| 54|#define yyerror re_yyerror ------------------ 1200| 54| yyterminate(); ------------------ | | 998| 54|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 54|#define YY_NULL 0 | | ------------------ ------------------ 1201| 54| } 1202| | 1203| 1.12k| yylval->range = (value << 16) | value; ------------------ | | 863| 1.12k| # define yylval yyg->yylval_r ------------------ 1204| | 1205| 1.12k| return _RANGE_; ------------------ | | 79| 1.12k|#define _RANGE_ 260 ------------------ 1206| 1.17k|} 1207| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1208| 191|case 3: ------------------ | Branch (1208:1): [True: 191, False: 2.75M] ------------------ 1209| 191|YY_RULE_SETUP 1210| 191|#line 173 "libyara/re_lexer.l" 1211| 191|{ 1212| | 1213| | // Start of a negated character class. Example: [^abcd] 1214| | 1215| 191| BEGIN(char_class); ------------------ | | 357| 191|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 809| 191|#define char_class 1 ------------------ 1216| 191| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 83| 191|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1217| 191| LEX_ENV->re_class.negated = true; ------------------ | | 83| 191|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1218| 191|} 1219| 191| YY_BREAK ------------------ | | 1035| 191|#define YY_BREAK /*LINTED*/break; ------------------ 1220| 132|case 4: ------------------ | Branch (1220:1): [True: 132, False: 2.75M] ------------------ 1221| 132|YY_RULE_SETUP 1222| 132|#line 182 "libyara/re_lexer.l" 1223| 132|{ 1224| | 1225| | // Start of character negated class containing a ]. 1226| | // Example: [^]abc] this must be interpreted as a class 1227| | // not matching ], a, b, nor c 1228| | 1229| 132| BEGIN(char_class); ------------------ | | 357| 132|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 809| 132|#define char_class 1 ------------------ 1230| 132| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 83| 132|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1231| 132| LEX_ENV->re_class.negated = true; ------------------ | | 83| 132|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1232| 132| LEX_ENV->re_class.bitmap[']' / 8] |= 1 << ']' % 8; ------------------ | | 83| 132|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1233| 132|} 1234| 132| YY_BREAK ------------------ | | 1035| 132|#define YY_BREAK /*LINTED*/break; ------------------ 1235| 259|case 5: ------------------ | Branch (1235:1): [True: 259, False: 2.75M] ------------------ 1236| 259|YY_RULE_SETUP 1237| 259|#line 195 "libyara/re_lexer.l" 1238| 259|{ 1239| | 1240| | // Start of character class containing a ]. 1241| | // Example: []abc] this must be interpreted as a class 1242| | // matching ], a, b, or c. 1243| | 1244| 259| BEGIN(char_class); ------------------ | | 357| 259|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 809| 259|#define char_class 1 ------------------ 1245| 259| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 83| 259|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1246| 259| LEX_ENV->re_class.negated = false; ------------------ | | 83| 259|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1247| 259| LEX_ENV->re_class.bitmap[']' / 8] |= 1 << ']' % 8; ------------------ | | 83| 259|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1248| 259|} 1249| 259| YY_BREAK ------------------ | | 1035| 259|#define YY_BREAK /*LINTED*/break; ------------------ 1250| 806|case 6: ------------------ | Branch (1250:1): [True: 806, False: 2.75M] ------------------ 1251| 806|YY_RULE_SETUP 1252| 806|#line 208 "libyara/re_lexer.l" 1253| 806|{ 1254| | 1255| | // Start of character class. Example: [abcd] 1256| | 1257| 806| BEGIN(char_class); ------------------ | | 357| 806|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 809| 806|#define char_class 1 ------------------ 1258| 806| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 83| 806|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1259| 806| LEX_ENV->re_class.negated = false; ------------------ | | 83| 806|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1260| 806|} 1261| 806| YY_BREAK ------------------ | | 1035| 806|#define YY_BREAK /*LINTED*/break; ------------------ 1262| 1.44M|case 7: ------------------ | Branch (1262:1): [True: 1.44M, False: 1.30M] ------------------ 1263| |/* rule 7 can match eol */ 1264| 1.44M|YY_RULE_SETUP 1265| 1.44M|#line 218 "libyara/re_lexer.l" 1266| 1.44M|{ 1267| | 1268| | // Any non-special character is passed as a CHAR token to the scanner. 1269| | 1270| 1.44M| yylval->integer = yytext[0]; ------------------ | | 863| 1.44M| # define yylval yyg->yylval_r ------------------ yylval->integer = yytext[0]; ------------------ | | 348| 1.44M|#define yytext yyg->yytext_r ------------------ 1271| 1.44M| return _CHAR_; ------------------ | | 77| 1.44M|#define _CHAR_ 258 ------------------ 1272| 1.17k|} 1273| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1274| 142|case 8: ------------------ | Branch (1274:1): [True: 142, False: 2.75M] ------------------ 1275| 142|YY_RULE_SETUP 1276| 142|#line 227 "libyara/re_lexer.l" 1277| 142|{ 1278| 142| return _WORD_CHAR_; ------------------ | | 81| 142|#define _WORD_CHAR_ 262 ------------------ 1279| 1.17k|} 1280| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1281| 323|case 9: ------------------ | Branch (1281:1): [True: 323, False: 2.75M] ------------------ 1282| 323|YY_RULE_SETUP 1283| 323|#line 232 "libyara/re_lexer.l" 1284| 323|{ 1285| 323| return _NON_WORD_CHAR_; ------------------ | | 82| 323|#define _NON_WORD_CHAR_ 263 ------------------ 1286| 1.17k|} 1287| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1288| 254|case 10: ------------------ | Branch (1288:1): [True: 254, False: 2.75M] ------------------ 1289| 254|YY_RULE_SETUP 1290| 254|#line 237 "libyara/re_lexer.l" 1291| 254|{ 1292| 254| return _SPACE_; ------------------ | | 83| 254|#define _SPACE_ 264 ------------------ 1293| 1.17k|} 1294| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1295| 1.58k|case 11: ------------------ | Branch (1295:1): [True: 1.58k, False: 2.75M] ------------------ 1296| 1.58k|YY_RULE_SETUP 1297| 1.58k|#line 242 "libyara/re_lexer.l" 1298| 1.58k|{ 1299| 1.58k| return _NON_SPACE_; ------------------ | | 84| 1.58k|#define _NON_SPACE_ 265 ------------------ 1300| 1.17k|} 1301| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1302| 154|case 12: ------------------ | Branch (1302:1): [True: 154, False: 2.75M] ------------------ 1303| 154|YY_RULE_SETUP 1304| 154|#line 247 "libyara/re_lexer.l" 1305| 154|{ 1306| 154| return _DIGIT_; ------------------ | | 85| 154|#define _DIGIT_ 266 ------------------ 1307| 1.17k|} 1308| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1309| 163|case 13: ------------------ | Branch (1309:1): [True: 163, False: 2.75M] ------------------ 1310| 163|YY_RULE_SETUP 1311| 163|#line 252 "libyara/re_lexer.l" 1312| 163|{ 1313| 163| return _NON_DIGIT_; ------------------ | | 86| 163|#define _NON_DIGIT_ 267 ------------------ 1314| 1.17k|} 1315| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1316| 145|case 14: ------------------ | Branch (1316:1): [True: 145, False: 2.75M] ------------------ 1317| 145|YY_RULE_SETUP 1318| 145|#line 257 "libyara/re_lexer.l" 1319| 145|{ 1320| 145| return _WORD_BOUNDARY_; ------------------ | | 87| 145|#define _WORD_BOUNDARY_ 268 ------------------ 1321| 1.17k|} 1322| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1323| 131|case 15: ------------------ | Branch (1323:1): [True: 131, False: 2.75M] ------------------ 1324| 131|YY_RULE_SETUP 1325| 131|#line 261 "libyara/re_lexer.l" 1326| 131|{ 1327| 131| return _NON_WORD_BOUNDARY_; ------------------ | | 88| 131|#define _NON_WORD_BOUNDARY_ 269 ------------------ 1328| 1.17k|} 1329| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1330| 10|case 16: ------------------ | Branch (1330:1): [True: 10, False: 2.75M] ------------------ 1331| 10|YY_RULE_SETUP 1332| 10|#line 266 "libyara/re_lexer.l" 1333| 10|{ 1334| | 1335| 10| yyerror(yyscanner, lex_env, "backreferences are not allowed"); ------------------ | | 47| 10|#define yyerror re_yyerror ------------------ 1336| 10| yyterminate(); ------------------ | | 998| 10|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 10|#define YY_NULL 0 | | ------------------ ------------------ 1337| 1.17k|} 1338| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1339| 1.04M|case 17: ------------------ | Branch (1339:1): [True: 1.04M, False: 1.71M] ------------------ 1340| 1.04M|YY_RULE_SETUP 1341| 1.04M|#line 273 "libyara/re_lexer.l" 1342| 1.04M|{ 1343| | 1344| 1.04M| uint8_t c; 1345| 1.04M| int return_code; 1346| | 1347| 1.04M| return_code = read_escaped_char(yyscanner, &c, LEX_ENV->strict_escape); ------------------ | | 83| 1.04M|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1348| 1.04M| if (return_code == VALID_ESCAPE_SEQUENCE) ------------------ | | 71| 1.04M|#define VALID_ESCAPE_SEQUENCE 1 ------------------ | Branch (1348:7): [True: 1.04M, False: 232] ------------------ 1349| 1.04M| { 1350| 1.04M| yylval->integer = c; ------------------ | | 863| 1.04M| # define yylval yyg->yylval_r ------------------ 1351| 1.04M| return _CHAR_; ------------------ | | 77| 1.04M|#define _CHAR_ 258 ------------------ 1352| 1.04M| } 1353| 232| else if (return_code == UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 72| 232|#define UNKNOWN_ESCAPE_SEQUENCE 2 ------------------ | Branch (1353:12): [True: 0, False: 232] ------------------ 1354| 0| { 1355| 0| yywarning(yyscanner, lex_env, "unknown escape sequence"); ------------------ | | 48| 0|#define yywarning re_yywarning ------------------ 1356| 0| yylval->integer = c; ------------------ | | 863| 0| # define yylval yyg->yylval_r ------------------ 1357| 0| return _CHAR_; ------------------ | | 77| 0|#define _CHAR_ 258 ------------------ 1358| 0| } 1359| 232| else 1360| 232| { 1361| 232| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 47| 232|#define yyerror re_yyerror ------------------ 1362| 232| yyterminate(); ------------------ | | 998| 232|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 232|#define YY_NULL 0 | | ------------------ ------------------ 1363| 232| } 1364| 1.04M|} 1365| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1366| 1.10k|case 18: ------------------ | Branch (1366:1): [True: 1.10k, False: 2.75M] ------------------ 1367| 1.10k|YY_RULE_SETUP 1368| 1.10k|#line 298 "libyara/re_lexer.l" 1369| 1.10k|{ 1370| | 1371| | // End of character class. 1372| 1.10k| yylval->re_class = (RE_CLASS*) yr_malloc(sizeof(RE_CLASS)); ------------------ | | 863| 1.10k| # define yylval yyg->yylval_r ------------------ 1373| 1.10k| memcpy(yylval->re_class->bitmap, LEX_ENV->re_class.bitmap, 32); ------------------ | | 863| 1.10k| # define yylval yyg->yylval_r ------------------ memcpy(yylval->re_class->bitmap, LEX_ENV->re_class.bitmap, 32); ------------------ | | 83| 1.10k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1374| | 1375| 1.10k| yylval->re_class->negated = LEX_ENV->re_class.negated; ------------------ | | 863| 1.10k| # define yylval yyg->yylval_r ------------------ yylval->re_class->negated = LEX_ENV->re_class.negated; ------------------ | | 83| 1.10k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1376| | 1377| 1.10k| BEGIN(INITIAL); ------------------ | | 357| 1.10k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 808| 1.10k|#define INITIAL 0 ------------------ 1378| 1.10k| return _CLASS_; ------------------ | | 80| 1.10k|#define _CLASS_ 261 ------------------ 1379| 1.04M|} 1380| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1381| 1.71k|case 19: ------------------ | Branch (1381:1): [True: 1.71k, False: 2.75M] ------------------ 1382| |/* rule 19 can match eol */ 1383| 1.71k|YY_RULE_SETUP 1384| 1.71k|#line 312 "libyara/re_lexer.l" 1385| 1.71k|{ 1386| | 1387| | // A range inside a character class. The regexp is... 1388| | // 1389| | // ( \x{hex_digit}{2} Hex digit (i.e: \x01) ... 1390| | // | \. ...or any escaped character (i.e. \\, \-) ... 1391| | // | [^]\] ...or any character except ] and \ ... 1392| | // ) 1393| | // - ... followed by - 1394| | // [^]] ... followed by any character except ] 1395| | // 1396| | // Some examples: 1397| | // 1398| | // [abc0-9] 1399| | // ^-^ matching range 0-9 1400| | // 1401| | // [a-za-] 1402| | // ^-^- matching range a-z 1403| | // 1404| | // [\.-a] 1405| | // ^--^- matching range \.-a 1406| | // 1407| | 1408| 1.71k| uint16_t c; 1409| 1.71k| uint8_t start = yytext[0]; ------------------ | | 348| 1.71k|#define yytext yyg->yytext_r ------------------ 1410| 1.71k| uint8_t end = yytext[2]; ------------------ | | 348| 1.71k|#define yytext yyg->yytext_r ------------------ 1411| | 1412| 1.71k| if (start == '\\') ------------------ | Branch (1412:7): [True: 560, False: 1.15k] ------------------ 1413| 560| { 1414| 560| if (!escaped_char_value(yytext, &start, LEX_ENV->strict_escape)) ------------------ | | 348| 560|#define yytext yyg->yytext_r ------------------ if (!escaped_char_value(yytext, &start, LEX_ENV->strict_escape)) ------------------ | | 83| 560|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ | Branch (1414:9): [True: 9, False: 551] ------------------ 1415| 9| { 1416| 9| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 47| 9|#define yyerror re_yyerror ------------------ 1417| 9| yyterminate(); ------------------ | | 998| 9|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 9|#define YY_NULL 0 | | ------------------ ------------------ 1418| 9| } 1419| | 1420| 551| if (yytext[1] == 'x') ------------------ | | 348| 551|#define yytext yyg->yytext_r ------------------ | Branch (1420:9): [True: 256, False: 295] ------------------ 1421| 256| end = yytext[5]; ------------------ | | 348| 256|#define yytext yyg->yytext_r ------------------ 1422| 295| else 1423| 295| end = yytext[3]; ------------------ | | 348| 295|#define yytext yyg->yytext_r ------------------ 1424| 551| } 1425| | 1426| 1.71k| if (end == '\\') ------------------ | Branch (1426:7): [True: 786, False: 924] ------------------ 1427| 786| { 1428| 786| if (!read_escaped_char(yyscanner, &end, LEX_ENV->strict_escape)) ------------------ | | 83| 786|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ | Branch (1428:9): [True: 173, False: 613] ------------------ 1429| 173| { 1430| 173| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 47| 173|#define yyerror re_yyerror ------------------ 1431| 173| yyterminate(); ------------------ | | 998| 173|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 173|#define YY_NULL 0 | | ------------------ ------------------ 1432| 173| } 1433| 786| } 1434| | 1435| 1.53k| if (end < start) ------------------ | Branch (1435:7): [True: 39, False: 1.49k] ------------------ 1436| 39| { 1437| 39| yyerror(yyscanner, lex_env, "bad character range"); ------------------ | | 47| 39|#define yyerror re_yyerror ------------------ 1438| 39| yyterminate(); ------------------ | | 998| 39|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 39|#define YY_NULL 0 | | ------------------ ------------------ 1439| 39| } 1440| | 1441| 82.8k| for (c = start; c <= end; c++) ------------------ | Branch (1441:19): [True: 81.3k, False: 1.49k] ------------------ 1442| 81.3k| { 1443| 81.3k| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 83| 81.3k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1444| 81.3k| } 1445| 1.49k|} 1446| 1.49k| YY_BREAK ------------------ | | 1035| 1.49k|#define YY_BREAK /*LINTED*/break; ------------------ 1447| 698|case 20: ------------------ | Branch (1447:1): [True: 698, False: 2.75M] ------------------ 1448| 698|YY_RULE_SETUP 1449| 698|#line 375 "libyara/re_lexer.l" 1450| 698|{ 1451| | 1452| 23.0k| for (int i = 0; i < 32; i++) ------------------ | Branch (1452:19): [True: 22.3k, False: 698] ------------------ 1453| 22.3k| LEX_ENV->re_class.bitmap[i] |= word_chars[i]; ------------------ | | 83| 22.3k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1454| 698|} 1455| 698| YY_BREAK ------------------ | | 1035| 698|#define YY_BREAK /*LINTED*/break; ------------------ 1456| 701|case 21: ------------------ | Branch (1456:1): [True: 701, False: 2.75M] ------------------ 1457| 701|YY_RULE_SETUP 1458| 701|#line 382 "libyara/re_lexer.l" 1459| 701|{ 1460| | 1461| 23.1k| for (int i = 0; i < 32; i++) ------------------ | Branch (1461:19): [True: 22.4k, False: 701] ------------------ 1462| 22.4k| LEX_ENV->re_class.bitmap[i] |= ~word_chars[i]; ------------------ | | 83| 22.4k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1463| 701|} 1464| 701| YY_BREAK ------------------ | | 1035| 701|#define YY_BREAK /*LINTED*/break; ------------------ 1465| 713|case 22: ------------------ | Branch (1465:1): [True: 713, False: 2.75M] ------------------ 1466| 713|YY_RULE_SETUP 1467| 713|#line 389 "libyara/re_lexer.l" 1468| 713|{ 1469| | 1470| 23.5k| for (int i = 0; i < 32; i++) ------------------ | Branch (1470:19): [True: 22.8k, False: 713] ------------------ 1471| 22.8k| LEX_ENV->re_class.bitmap[i] |= space_chars[i]; ------------------ | | 83| 22.8k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1472| 713|} 1473| 713| YY_BREAK ------------------ | | 1035| 713|#define YY_BREAK /*LINTED*/break; ------------------ 1474| 712|case 23: ------------------ | Branch (1474:1): [True: 712, False: 2.75M] ------------------ 1475| 712|YY_RULE_SETUP 1476| 712|#line 396 "libyara/re_lexer.l" 1477| 712|{ 1478| | 1479| 23.4k| for (int i = 0; i < 32; i++) ------------------ | Branch (1479:19): [True: 22.7k, False: 712] ------------------ 1480| 22.7k| LEX_ENV->re_class.bitmap[i] |= ~space_chars[i]; ------------------ | | 83| 22.7k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1481| 712|} 1482| 712| YY_BREAK ------------------ | | 1035| 712|#define YY_BREAK /*LINTED*/break; ------------------ 1483| 413|case 24: ------------------ | Branch (1483:1): [True: 413, False: 2.75M] ------------------ 1484| 413|YY_RULE_SETUP 1485| 413|#line 403 "libyara/re_lexer.l" 1486| 413|{ 1487| | 1488| 4.54k| for (char c = '0'; c <= '9'; c++) ------------------ | Branch (1488:22): [True: 4.13k, False: 413] ------------------ 1489| 4.13k| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 83| 4.13k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1490| 413|} 1491| 413| YY_BREAK ------------------ | | 1035| 413|#define YY_BREAK /*LINTED*/break; ------------------ 1492| 700|case 25: ------------------ | Branch (1492:1): [True: 700, False: 2.75M] ------------------ 1493| 700|YY_RULE_SETUP 1494| 700|#line 410 "libyara/re_lexer.l" 1495| 700|{ 1496| | 1497| 23.1k| for (int i = 0; i < 32; i++) ------------------ | Branch (1497:19): [True: 22.4k, False: 700] ------------------ 1498| 22.4k| { 1499| | // digits 0-7 are in the sixth byte of the vector, let that byte alone 1500| 22.4k| if (i == 6) ------------------ | Branch (1500:9): [True: 700, False: 21.7k] ------------------ 1501| 700| continue; 1502| | 1503| | // digits 8 and 9 are the lowest two bits in the seventh byte of the 1504| | // vector, let those bits alone. 1505| 21.7k| if (i == 7) ------------------ | Branch (1505:9): [True: 700, False: 21.0k] ------------------ 1506| 700| LEX_ENV->re_class.bitmap[i] |= 0xFC; ------------------ | | 83| 700|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1507| 21.0k| else 1508| 21.0k| LEX_ENV->re_class.bitmap[i] = 0xFF; ------------------ | | 83| 21.0k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1509| 21.7k| } 1510| 700|} 1511| 700| YY_BREAK ------------------ | | 1035| 700|#define YY_BREAK /*LINTED*/break; ------------------ 1512| 869|case 26: ------------------ | Branch (1512:1): [True: 869, False: 2.75M] ------------------ 1513| 869|YY_RULE_SETUP 1514| 869|#line 428 "libyara/re_lexer.l" 1515| 869|{ 1516| | 1517| 869| uint8_t c; 1518| 869| int return_code; 1519| | 1520| 869| return_code = read_escaped_char(yyscanner, &c, LEX_ENV->strict_escape); ------------------ | | 83| 869|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1521| 869| if (return_code == VALID_ESCAPE_SEQUENCE) ------------------ | | 71| 869|#define VALID_ESCAPE_SEQUENCE 1 ------------------ | Branch (1521:7): [True: 856, False: 13] ------------------ 1522| 856| { 1523| 856| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 83| 856|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1524| 856| } 1525| 13| else if (return_code == UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 72| 13|#define UNKNOWN_ESCAPE_SEQUENCE 2 ------------------ | Branch (1525:12): [True: 0, False: 13] ------------------ 1526| 0| { 1527| 0| yywarning(yyscanner, lex_env, "unknown escape sequence"); ------------------ | | 48| 0|#define yywarning re_yywarning ------------------ 1528| 0| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 83| 0|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1529| 0| } 1530| 13| else 1531| 13| { 1532| 13| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 47| 13|#define yyerror re_yyerror ------------------ 1533| 13| yyterminate(); ------------------ | | 998| 13|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 13|#define YY_NULL 0 | | ------------------ ------------------ 1534| 13| } 1535| 869|} 1536| 856| YY_BREAK ------------------ | | 1035| 856|#define YY_BREAK /*LINTED*/break; ------------------ 1537| 6.82k|case 27: ------------------ | Branch (1537:1): [True: 6.82k, False: 2.75M] ------------------ 1538| 6.82k|YY_RULE_SETUP 1539| 6.82k|#line 451 "libyara/re_lexer.l" 1540| 6.82k|{ 1541| | 1542| 6.82k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 6.82k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 6.80k|#define yytext yyg->yytext_r ------------------ | Branch (1542:7): [True: 6.80k, False: 14] | Branch (1542:26): [True: 6.80k, False: 0] ------------------ 1543| 6.80k| { 1544| | // A character class (i.e: [0-9a-f]) is represented by a 256-bits vector, 1545| | // here we set to 1 the vector's bit corresponding to the input character. 1546| | 1547| 6.80k| LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 83| 6.80k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 348| 6.80k|#define yytext yyg->yytext_r ------------------ LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 348| 6.80k|#define yytext yyg->yytext_r ------------------ 1548| 6.80k| } 1549| 14| else 1550| 14| { 1551| 14| yyerror(yyscanner, lex_env, "non-ascii character"); ------------------ | | 47| 14|#define yyerror re_yyerror ------------------ 1552| 14| yyterminate(); ------------------ | | 998| 14|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 14|#define YY_NULL 0 | | ------------------ ------------------ 1553| 14| } 1554| 6.82k|} 1555| 6.80k| YY_BREAK ------------------ | | 1035| 6.80k|#define YY_BREAK /*LINTED*/break; ------------------ 1556| 6.80k|case YY_STATE_EOF(char_class): ------------------ | | 365| 37|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 37|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ | Branch (1556:1): [True: 37, False: 2.75M] ------------------ 1557| 37|#line 468 "libyara/re_lexer.l" 1558| 37|{ 1559| | 1560| | // End of regexp reached while scanning a character class. 1561| | 1562| 37| yyerror(yyscanner, lex_env, "missing terminating ] for character class"); ------------------ | | 47| 37|#define yyerror re_yyerror ------------------ 1563| 37| yyterminate(); ------------------ | | 998| 37|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 37|#define YY_NULL 0 | | ------------------ ------------------ 1564| 6.82k|} 1565| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1566| 198k|case 28: ------------------ | Branch (1566:1): [True: 198k, False: 2.55M] ------------------ 1567| 198k|YY_RULE_SETUP 1568| 198k|#line 477 "libyara/re_lexer.l" 1569| 198k|{ 1570| | 1571| 198k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 198k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 198k|#define yytext yyg->yytext_r ------------------ | Branch (1571:7): [True: 198k, False: 0] | Branch (1571:26): [True: 198k, False: 0] ------------------ 1572| 198k| { 1573| 198k| return yytext[0]; ------------------ | | 348| 198k|#define yytext yyg->yytext_r ------------------ 1574| 198k| } 1575| 0| else 1576| 0| { 1577| 0| yyerror(yyscanner, lex_env, "non-ascii character"); ------------------ | | 47| 0|#define yyerror re_yyerror ------------------ 1578| 0| yyterminate(); ------------------ | | 998| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1579| 0| } 1580| 198k|} 1581| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1582| 15.3k|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 15.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 15.3k|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ | Branch (1582:1): [True: 15.3k, False: 2.74M] ------------------ 1583| 15.3k|#line 491 "libyara/re_lexer.l" 1584| 15.3k|{ 1585| | 1586| 15.3k| yyterminate(); ------------------ | | 998| 15.3k|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 15.3k|#define YY_NULL 0 | | ------------------ ------------------ 1587| 198k|} 1588| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1589| 0|case 29: ------------------ | Branch (1589:1): [True: 0, False: 2.75M] ------------------ 1590| 0|YY_RULE_SETUP 1591| 0|#line 496 "libyara/re_lexer.l" 1592| 0|ECHO; 1593| 0| YY_BREAK ------------------ | | 1035| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1594| 0|#line 1594 "libyara/re_lexer.c" 1595| | 1596| 31.2k| case YY_END_OF_BUFFER: ------------------ | | 584| 31.2k|#define YY_END_OF_BUFFER 30 ------------------ | Branch (1596:2): [True: 31.2k, False: 2.72M] ------------------ 1597| 31.2k| { 1598| | /* Amount of text matched not including the EOB char. */ 1599| 31.2k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 31.2k|#define yytext_ptr yytext_r ------------------ 1600| | 1601| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1602| 31.2k| *yy_cp = yyg->yy_hold_char; 1603| 31.2k| YY_RESTORE_YY_MORE_OFFSET 1604| | 1605| 31.2k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 31.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 486| 31.2k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1605:8): [True: 15.4k, False: 15.7k] ------------------ 1606| 15.4k| { 1607| | /* We're scanning a new file or input source. It's 1608| | * possible that this happened because the user 1609| | * just pointed yyin at a new source and called 1610| | * yylex(). If so, then we have to assure 1611| | * consistency between YY_CURRENT_BUFFER and our 1612| | * globals. Here is the right place to do so, because 1613| | * this is the first action (other than possibly a 1614| | * back-up) that will match for the new input source. 1615| | */ 1616| 15.4k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 15.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1617| 15.4k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 15.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 15.4k|#define yyin yyg->yyin_r ------------------ 1618| 15.4k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 15.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 487| 15.4k|#define YY_BUFFER_NORMAL 1 ------------------ 1619| 15.4k| } 1620| | 1621| | /* Note that here we test for yy_c_buf_p "<=" to the position 1622| | * of the first EOB in the buffer, since yy_c_buf_p will 1623| | * already have been incremented past the NUL character 1624| | * (since all states make transitions on EOB to the 1625| | * end-of-buffer state). Contrast this with the test 1626| | * in input(). 1627| | */ 1628| 31.2k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 31.2k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1628:8): [True: 0, False: 31.2k] ------------------ 1629| 0| { /* This was really a NUL. */ 1630| 0| yy_state_type yy_next_state; 1631| | 1632| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1633| | 1634| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1635| | 1636| | /* Okay, we're now positioned to make the NUL 1637| | * transition. We couldn't have 1638| | * yy_get_previous_state() go ahead and do it 1639| | * for us because it doesn't know how to deal 1640| | * with the possibility of jamming (and we don't 1641| | * want to build jamming into it because then it 1642| | * will run more slowly). 1643| | */ 1644| | 1645| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1646| | 1647| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 709| 0|#define YY_MORE_ADJ 0 ------------------ 1648| | 1649| 0| if ( yy_next_state ) ------------------ | Branch (1649:9): [True: 0, False: 0] ------------------ 1650| 0| { 1651| | /* Consume the NUL. */ 1652| 0| yy_cp = ++yyg->yy_c_buf_p; 1653| 0| yy_current_state = yy_next_state; 1654| 0| goto yy_match; 1655| 0| } 1656| | 1657| 0| else 1658| 0| { 1659| 0| yy_cp = yyg->yy_last_accepting_cpos; 1660| 0| yy_current_state = yyg->yy_last_accepting_state; 1661| 0| goto yy_find_action; 1662| 0| } 1663| 0| } 1664| | 1665| 31.2k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1665:17): [True: 0, False: 31.2k] ------------------ 1666| 31.2k| { 1667| 15.4k| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 15.4k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1667:4): [True: 15.4k, False: 15.7k] ------------------ 1668| 15.4k| { 1669| 15.4k| yyg->yy_did_buffer_switch_on_eof = 0; 1670| | 1671| 15.4k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 15.4k|#define yywrap re_yywrap | | ------------------ | | | | 561| 15.4k|#define re_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1672| 15.4k| { 1673| | /* Note: because we've taken care in 1674| | * yy_get_next_buffer() to have set up 1675| | * yytext, we can now set up 1676| | * yy_c_buf_p so that if some total 1677| | * hoser (like flex itself) wants to 1678| | * call the scanner after we return the 1679| | * YY_NULL, it'll still work - another 1680| | * YY_NULL will get returned. 1681| | */ 1682| 15.4k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 15.4k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 709| 15.4k|#define YY_MORE_ADJ 0 ------------------ 1683| | 1684| 15.4k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 15.4k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 15.4k|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ 1685| 15.4k| goto do_action; 1686| 15.4k| } 1687| | 1688| 0| else 1689| 0| { 1690| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1690:11): [True: 0, False: 0] ------------------ 1691| 0| YY_NEW_FILE; ------------------ | | 367| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart re_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1692| 0| } 1693| 0| break; 1694| 15.4k| } 1695| | 1696| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1696:4): [True: 0, False: 31.2k] ------------------ 1697| 0| yyg->yy_c_buf_p = 1698| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1699| | 1700| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1701| | 1702| 0| yy_cp = yyg->yy_c_buf_p; 1703| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 709| 0|#define YY_MORE_ADJ 0 ------------------ 1704| 0| goto yy_match; 1705| | 1706| 15.7k| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 15.7k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1706:4): [True: 15.7k, False: 15.4k] ------------------ 1707| 15.7k| yyg->yy_c_buf_p = 1708| 15.7k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 15.7k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1709| | 1710| 15.7k| yy_current_state = yy_get_previous_state( yyscanner ); 1711| | 1712| 15.7k| yy_cp = yyg->yy_c_buf_p; 1713| 15.7k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 15.7k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 709| 15.7k|#define YY_MORE_ADJ 0 ------------------ 1714| 15.7k| goto yy_find_action; 1715| 31.2k| } 1716| 0| break; 1717| 31.2k| } 1718| | 1719| 0| default: ------------------ | Branch (1719:2): [True: 0, False: 2.75M] ------------------ 1720| 0| YY_FATAL_ERROR( ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1721| 2.75M| "fatal flex scanner internal error--no action found" ); 1722| 2.75M| } /* end of action switch */ 1723| 2.75M| } /* end of scanning one token */ 1724| 2.71M| } /* end of user's declarations */ 1725| 2.71M|} /* end of yylex */ re_yyrestart: 2023| 256|{ 2024| 256| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2025| | 2026| 256| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 509| 256|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 256, False: 0] | | ------------------ | | 510| 256| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 256| : NULL) ------------------ | Branch (2026:7): [True: 0, False: 256] ------------------ 2027| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 2028| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2029| 0| yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 20| 0|#define yy_create_buffer re_yy_create_buffer ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); ------------------ | | 379| 0|#define YY_BUF_SIZE 16384 ------------------ 2030| 0| } 2031| | 2032| 256| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 256|#define yy_init_buffer re_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 509| 256|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 256, False: 0] | | ------------------ | | 510| 256| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 256| : NULL) ------------------ 2033| 256| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 256|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2034| 256|} re_yy_switch_to_buffer: 2041| 15.9k|{ 2042| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2043| | 2044| | /* TODO. We should be able to replace this entire function body 2045| | * with 2046| | * yypop_buffer_state(); 2047| | * yypush_buffer_state(new_buffer); 2048| | */ 2049| 15.9k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 15.9k|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 2050| 15.9k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ | Branch (2050:7): [True: 0, False: 15.9k] ------------------ 2051| 0| return; 2052| | 2053| 15.9k| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 15.9k] | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ 2054| 0| { 2055| | /* Flush out information for old buffer. */ 2056| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 2057| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2058| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2059| 0| } 2060| | 2061| 15.9k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 15.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2062| 15.9k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 15.9k|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2063| | 2064| | /* We don't actually know whether we did this switch during 2065| | * EOF (yywrap()) processing, but the only time this flag 2066| | * is looked at is after yywrap() is called, so it's safe 2067| | * to go ahead and always set it. 2068| | */ 2069| 15.9k| yyg->yy_did_buffer_switch_on_eof = 1; 2070| 15.9k|} re_yy_delete_buffer: 2116| 15.9k|{ 2117| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2118| | 2119| 15.9k| if ( ! b ) ------------------ | Branch (2119:7): [True: 0, False: 15.9k] ------------------ 2120| 0| return; 2121| | 2122| 15.9k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ | Branch (2122:7): [True: 15.9k, False: 0] ------------------ 2123| 15.9k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 15.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2124| | 2125| 15.9k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2125:7): [True: 15.9k, False: 0] ------------------ 2126| 15.9k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 15.9k|#define yyfree re_yyfree ------------------ 2127| | 2128| 15.9k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 15.9k|#define yyfree re_yyfree ------------------ 2129| 15.9k|} re_yy_flush_buffer: 2165| 256|{ 2166| 256| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2167| 256| if ( ! b ) ------------------ | Branch (2167:7): [True: 0, False: 256] ------------------ 2168| 0| return; 2169| | 2170| 256| b->yy_n_chars = 0; 2171| | 2172| | /* We always need two end-of-buffer characters. The first causes 2173| | * a transition to the end-of-buffer state. The second causes 2174| | * a jam in that state. 2175| | */ 2176| 256| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 256|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2177| 256| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 256|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2178| | 2179| 256| b->yy_buf_pos = &b->yy_ch_buf[0]; 2180| | 2181| 256| b->yy_at_bol = 1; 2182| 256| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 256|#define YY_BUFFER_NEW 0 ------------------ 2183| | 2184| 256| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 509| 256|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 256, False: 0] | | ------------------ | | 510| 256| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 256| : NULL) ------------------ | Branch (2184:7): [True: 256, False: 0] ------------------ 2185| 256| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 256|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2186| 256|} re_yypop_buffer_state: 2226| 15.9k|{ 2227| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2228| 15.9k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ | Branch (2228:6): [True: 15.9k, False: 0] ------------------ 2229| 15.9k| return; 2230| | 2231| 0| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 0|#define yy_delete_buffer re_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 2232| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2233| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2233:6): [True: 0, False: 0] ------------------ 2234| 0| --yyg->yy_buffer_stack_top; 2235| | 2236| 0| if (YY_CURRENT_BUFFER) { ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 0] | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 2237| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2238| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2239| 0| } 2240| 0|} re_yy_scan_buffer: 2296| 15.9k|{ 2297| 15.9k| YY_BUFFER_STATE b; 2298| | 2299| 15.9k| if ( size < 2 || ------------------ | Branch (2299:7): [True: 0, False: 15.9k] ------------------ 2300| 15.9k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 31.9k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2300:7): [True: 0, False: 15.9k] ------------------ 2301| 15.9k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 15.9k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2301:7): [True: 0, False: 15.9k] ------------------ 2302| | /* They forgot to leave room for the EOB's. */ 2303| 0| return NULL; 2304| | 2305| 15.9k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 15.9k|#define yyalloc re_yyalloc ------------------ 2306| 15.9k| if ( ! b ) ------------------ | Branch (2306:7): [True: 0, False: 15.9k] ------------------ 2307| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2308| | 2309| 15.9k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2310| 15.9k| b->yy_buf_pos = b->yy_ch_buf = base; 2311| 15.9k| b->yy_is_our_buffer = 0; 2312| 15.9k| b->yy_input_file = NULL; 2313| 15.9k| b->yy_n_chars = b->yy_buf_size; 2314| 15.9k| b->yy_is_interactive = 0; 2315| 15.9k| b->yy_at_bol = 1; 2316| 15.9k| b->yy_fill_buffer = 0; 2317| 15.9k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 15.9k|#define YY_BUFFER_NEW 0 ------------------ 2318| | 2319| 15.9k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 15.9k|#define yy_switch_to_buffer re_yy_switch_to_buffer ------------------ 2320| | 2321| 15.9k| return b; 2322| 15.9k|} re_yy_scan_string: 2333| 15.9k|{ 2334| | 2335| 15.9k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 15.9k|#define yy_scan_bytes re_yy_scan_bytes ------------------ 2336| 15.9k|} re_yy_scan_bytes: 2346| 15.9k|{ 2347| 15.9k| YY_BUFFER_STATE b; 2348| 15.9k| char *buf; 2349| 15.9k| yy_size_t n; 2350| 15.9k| int i; 2351| | 2352| | /* Get memory for full buffer, including space for trailing EOB's. */ 2353| 15.9k| n = (yy_size_t) (_yybytes_len + 2); 2354| 15.9k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 15.9k|#define yyalloc re_yyalloc ------------------ 2355| 15.9k| if ( ! buf ) ------------------ | Branch (2355:7): [True: 0, False: 15.9k] ------------------ 2356| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2357| | 2358| 5.83M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2358:15): [True: 5.82M, False: 15.9k] ------------------ 2359| 5.82M| buf[i] = yybytes[i]; 2360| | 2361| 15.9k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 15.9k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2362| | 2363| 15.9k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 15.9k|#define yy_scan_buffer re_yy_scan_buffer ------------------ 2364| 15.9k| if ( ! b ) ------------------ | Branch (2364:7): [True: 0, False: 15.9k] ------------------ 2365| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2366| | 2367| | /* It's okay to grow etc. this buffer, and we should throw it 2368| | * away when we're done. 2369| | */ 2370| 15.9k| b->yy_is_our_buffer = 1; 2371| | 2372| 15.9k| return b; 2373| 15.9k|} re_yyget_extra: 2410| 48.9k|{ 2411| 48.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2412| 48.9k| return yyextra; ------------------ | | 346| 48.9k|#define yyextra yyg->yyextra_r ------------------ 2413| 48.9k|} re_yyset_extra: 2483| 15.9k|{ 2484| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2485| 15.9k| yyextra = user_defined ; ------------------ | | 346| 15.9k|#define yyextra yyg->yyextra_r ------------------ 2486| 15.9k|} re_yylex_init: 2569| 15.9k|{ 2570| 15.9k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2570:9): [True: 0, False: 15.9k] ------------------ 2571| 0| errno = EINVAL; 2572| 0| return 1; 2573| 0| } 2574| | 2575| 15.9k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 15.9k|#define yyalloc re_yyalloc ------------------ 2576| | 2577| 15.9k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2577:9): [True: 0, False: 15.9k] ------------------ 2578| 0| errno = ENOMEM; 2579| 0| return 1; 2580| 0| } 2581| | 2582| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2583| 15.9k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2584| | 2585| 15.9k| return yy_init_globals ( *ptr_yy_globals ); 2586| 15.9k|} re_yylex_destroy: 2657| 15.9k|{ 2658| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2659| | 2660| | /* Pop the buffer stack, destroying each element. */ 2661| 31.9k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 31.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 15.9k, False: 15.9k] | | | Branch (509:29): [True: 31.9k, False: 0] | | ------------------ | | 510| 31.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 31.9k| : NULL) ------------------ 2662| 15.9k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 15.9k|#define yy_delete_buffer re_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 15.9k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 15.9k, False: 0] | | ------------------ | | 510| 15.9k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 15.9k| : NULL) ------------------ 2663| 15.9k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 15.9k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2664| 15.9k| yypop_buffer_state(yyscanner); ------------------ | | 80| 15.9k|#define yypop_buffer_state re_yypop_buffer_state ------------------ 2665| 15.9k| } 2666| | 2667| | /* Destroy the stack itself. */ 2668| 15.9k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 15.9k|#define yyfree re_yyfree ------------------ 2669| 15.9k| yyg->yy_buffer_stack = NULL; 2670| | 2671| | /* Destroy the start condition stack. */ 2672| 15.9k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 15.9k|#define yyfree re_yyfree ------------------ 2673| 15.9k| yyg->yy_start_stack = NULL; 2674| | 2675| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2676| | * yylex() is called, initialization will occur. */ 2677| 15.9k| yy_init_globals( yyscanner); 2678| | 2679| | /* Destroy the main struct (reentrant only). */ 2680| 15.9k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 15.9k|#define yyfree re_yyfree ------------------ 2681| 15.9k| yyscanner = NULL; 2682| 15.9k| return 0; 2683| 15.9k|} re_yyalloc: 2713| 63.9k|{ 2714| 63.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2715| 63.9k| (void)yyg; 2716| 63.9k| return malloc(size); 2717| 63.9k|} re_yyfree: 2735| 79.9k|{ 2736| 79.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2737| 79.9k| (void)yyg; 2738| 79.9k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2739| 79.9k|} escaped_char_value: 2750| 1.04M|{ 2751| 1.04M| unsigned int hex_value; 2752| 1.04M| char hex[3]; 2753| | 2754| 1.04M| assert(text[0] == '\\'); 2755| | 2756| 1.04M| switch(text[1]) 2757| 1.04M| { 2758| 1.00M| case 'x': ------------------ | Branch (2758:3): [True: 1.00M, False: 32.6k] ------------------ 2759| 1.00M| if (!isxdigit(text[2]) || !isxdigit(text[3])) ------------------ | Branch (2759:9): [True: 17, False: 1.00M] | Branch (2759:31): [True: 24, False: 1.00M] ------------------ 2760| 41| return 0; 2761| 1.00M| hex[0] = text[2]; 2762| 1.00M| hex[1] = text[3]; 2763| 1.00M| hex[2] = '\0'; 2764| 1.00M| sscanf(hex, "%x", &hex_value); 2765| 1.00M| *value = (uint8_t) hex_value; 2766| 1.00M| break; 2767| | 2768| 449| case 'n': ------------------ | Branch (2768:3): [True: 449, False: 1.04M] ------------------ 2769| 449| *value = '\n'; 2770| 449| break; 2771| | 2772| 271| case 't': ------------------ | Branch (2772:3): [True: 271, False: 1.04M] ------------------ 2773| 271| *value = '\t'; 2774| 271| break; 2775| | 2776| 169| case 'r': ------------------ | Branch (2776:3): [True: 169, False: 1.04M] ------------------ 2777| 169| *value = '\r'; 2778| 169| break; 2779| | 2780| 182| case 'f': ------------------ | Branch (2780:3): [True: 182, False: 1.04M] ------------------ 2781| 182| *value = '\f'; 2782| 182| break; 2783| | 2784| 146| case 'a': ------------------ | Branch (2784:3): [True: 146, False: 1.04M] ------------------ 2785| 146| *value = '\a'; 2786| 146| break; 2787| | 2788| | // Support metacharacters in escape sequences 2789| 1.35k| case '\\': ------------------ | Branch (2789:3): [True: 1.35k, False: 1.04M] ------------------ 2790| 4.67k| case '^': ------------------ | Branch (2790:3): [True: 3.32k, False: 1.03M] ------------------ 2791| 6.37k| case '$': ------------------ | Branch (2791:3): [True: 1.70k, False: 1.04M] ------------------ 2792| 12.2k| case '.': ------------------ | Branch (2792:3): [True: 5.92k, False: 1.03M] ------------------ 2793| 12.4k| case '|': ------------------ | Branch (2793:3): [True: 111, False: 1.04M] ------------------ 2794| 12.8k| case '(': ------------------ | Branch (2794:3): [True: 489, False: 1.04M] ------------------ 2795| 12.9k| case ')': ------------------ | Branch (2795:3): [True: 82, False: 1.04M] ------------------ 2796| 13.1k| case '[': ------------------ | Branch (2796:3): [True: 173, False: 1.04M] ------------------ 2797| 14.2k| case ']': ------------------ | Branch (2797:3): [True: 1.11k, False: 1.04M] ------------------ 2798| | 2799| | // Support other special characters that are used in rules and need to be escaped 2800| 14.4k| case '*': ------------------ | Branch (2800:3): [True: 161, False: 1.04M] ------------------ 2801| 23.2k| case '+': ------------------ | Branch (2801:3): [True: 8.80k, False: 1.03M] ------------------ 2802| 24.8k| case '?': ------------------ | Branch (2802:3): [True: 1.58k, False: 1.04M] ------------------ 2803| 24.9k| case '"': ------------------ | Branch (2803:3): [True: 154, False: 1.04M] ------------------ 2804| 25.1k| case '\'': ------------------ | Branch (2804:3): [True: 176, False: 1.04M] ------------------ 2805| 25.3k| case '-': ------------------ | Branch (2805:3): [True: 211, False: 1.04M] ------------------ 2806| 25.8k| case '{': ------------------ | Branch (2806:3): [True: 525, False: 1.04M] ------------------ 2807| 27.5k| case '}': ------------------ | Branch (2807:3): [True: 1.69k, False: 1.04M] ------------------ 2808| 27.7k| case '#': ------------------ | Branch (2808:3): [True: 199, False: 1.04M] ------------------ 2809| 27.9k| case ':': ------------------ | Branch (2809:3): [True: 149, False: 1.04M] ------------------ 2810| 28.2k| case '_': ------------------ | Branch (2810:3): [True: 328, False: 1.04M] ------------------ 2811| 28.3k| case '=': ------------------ | Branch (2811:3): [True: 137, False: 1.04M] ------------------ 2812| 28.3k| case '/': ------------------ | Branch (2812:3): [True: 0, False: 1.04M] ------------------ 2813| 28.7k| case '!': ------------------ | Branch (2813:3): [True: 390, False: 1.04M] ------------------ 2814| 29.4k| case ',': ------------------ | Branch (2814:3): [True: 668, False: 1.04M] ------------------ 2815| 29.6k| case '@': ------------------ | Branch (2815:3): [True: 192, False: 1.04M] ------------------ 2816| 29.8k| case '<': ------------------ | Branch (2816:3): [True: 198, False: 1.04M] ------------------ 2817| 29.9k| case '>': ------------------ | Branch (2817:3): [True: 140, False: 1.04M] ------------------ 2818| 30.1k| case '~': ------------------ | Branch (2818:3): [True: 136, False: 1.04M] ------------------ 2819| 30.1k| case '&': ------------------ | Branch (2819:3): [True: 41, False: 1.04M] ------------------ 2820| 30.5k| case '%': ------------------ | Branch (2820:3): [True: 353, False: 1.04M] ------------------ 2821| 30.5k| *value = text[1]; 2822| 30.5k| break; 2823| 898| default: ------------------ | Branch (2823:3): [True: 898, False: 1.04M] ------------------ 2824| 898| *value = text[1]; 2825| 898| if (strict_escape) ------------------ | Branch (2825:9): [True: 0, False: 898] ------------------ 2826| 0| return UNKNOWN_ESCAPE_SEQUENCE; ------------------ | | 72| 0|#define UNKNOWN_ESCAPE_SEQUENCE 2 ------------------ 2827| 898| return VALID_ESCAPE_SEQUENCE; ------------------ | | 71| 898|#define VALID_ESCAPE_SEQUENCE 1 ------------------ 2828| 1.04M| } 2829| | 2830| 1.04M| return VALID_ESCAPE_SEQUENCE; ------------------ | | 71| 1.04M|#define VALID_ESCAPE_SEQUENCE 1 ------------------ 2831| 1.04M|} read_escaped_char: 2845| 1.04M|{ 2846| 1.04M| char text[4] = {0, 0, 0, 0}; 2847| | 2848| 1.04M| text[0] = '\\'; 2849| 1.04M| text[1] = RE_YY_INPUT(yyscanner); ------------------ | | 2837| 1.04M|#define RE_YY_INPUT input ------------------ 2850| | 2851| 1.04M| if (text[1] == EOF || text[1] == 0) ------------------ | Branch (2851:7): [True: 39, False: 1.04M] | Branch (2851:25): [True: 0, False: 1.04M] ------------------ 2852| 39| return 0; 2853| | 2854| 1.04M| if (text[1] == 'x') ------------------ | Branch (2854:7): [True: 1.00M, False: 32.3k] ------------------ 2855| 1.00M| { 2856| 1.00M| text[2] = RE_YY_INPUT(yyscanner); ------------------ | | 2837| 1.00M|#define RE_YY_INPUT input ------------------ 2857| | 2858| 1.00M| if (text[2] == EOF || text[2] == 0) ------------------ | Branch (2858:9): [True: 69, False: 1.00M] | Branch (2858:27): [True: 22, False: 1.00M] ------------------ 2859| 91| return 0; 2860| | 2861| 1.00M| text[3] = RE_YY_INPUT(yyscanner); ------------------ | | 2837| 1.00M|#define RE_YY_INPUT input ------------------ 2862| | 2863| 1.00M| if (text[3] == EOF || text[3] == 0) ------------------ | Branch (2863:9): [True: 22, False: 1.00M] | Branch (2863:27): [True: 234, False: 1.00M] ------------------ 2864| 256| return 0; 2865| 1.00M| } 2866| | 2867| 1.04M| return escaped_char_value(text, escaped_char, strict_escape); 2868| 1.04M|} re_yyerror: 2892| 1.17k|{ 2893| | // if lex_env->last_error was set to some error code before 2894| | // don't overwrite it, we are interested in the first error, not in 2895| | // subsequent errors like "syntax error, unexpected $end" caused by 2896| | // early parser termination. 2897| | 2898| 1.17k| if (lex_env->last_error == ERROR_SUCCESS || lex_env->last_error == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 40| 2.35k|#define ERROR_SUCCESS 0 ------------------ if (lex_env->last_error == ERROR_SUCCESS || lex_env->last_error == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 483|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (2898:7): [True: 695, False: 483] | Branch (2898:47): [True: 0, False: 483] ------------------ 2899| 695| { 2900| 695| lex_env->last_error = ERROR_INVALID_REGULAR_EXPRESSION; ------------------ | | 54| 695|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ 2901| | 2902| 695| strlcpy( 2903| 695| lex_env->last_error_message, 2904| 695| error_message, 2905| 695| sizeof(lex_env->last_error_message)); 2906| 695| } 2907| 1.17k|} yr_parse_re_string: 2933| 15.9k|{ 2934| 15.9k| yyscan_t yyscanner; 2935| 15.9k| jmp_buf recovery_trampoline; 2936| 15.9k| RE_LEX_ENVIRONMENT lex_env; 2937| | 2938| 15.9k| lex_env.last_error = ERROR_SUCCESS; ------------------ | | 40| 15.9k|#define ERROR_SUCCESS 0 ------------------ 2939| 15.9k| if (flags & RE_PARSER_FLAG_ENABLE_STRICT_ESCAPE_SEQUENCES) ------------------ | Branch (2939:7): [True: 0, False: 15.9k] ------------------ 2940| 0| lex_env.strict_escape = true; 2941| 15.9k| else 2942| 15.9k| lex_env.strict_escape = false; 2943| 15.9k| lex_env.last_error_message[0] = '\0'; 2944| | 2945| 15.9k| yr_thread_storage_set_value( 2946| 15.9k| &yr_yyfatal_trampoline_tls, 2947| 15.9k| &recovery_trampoline); 2948| | 2949| | // setjmp returns a non-zero value only when we are returning to this 2950| | // point via a call to longjmp to the recovery trampoline. 2951| 15.9k| if (setjmp(recovery_trampoline) != 0) ------------------ | Branch (2951:7): [True: 0, False: 15.9k] ------------------ 2952| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 2953| | 2954| 15.9k| FAIL_ON_ERROR(yr_re_ast_create(re_ast)); ------------------ | | 134| 15.9k| { \ | | 135| 15.9k| int __error = (x); \ | | 136| 15.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 15.9k] | | ------------------ | | 137| 15.9k| return __error; \ | | 138| 15.9k| } ------------------ 2955| | 2956| 15.9k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 15.9k|#define yylex_init re_yylex_init ------------------ | Branch (2956:7): [True: 0, False: 15.9k] ------------------ 2957| 0| { 2958| 0| yr_re_ast_destroy(*re_ast); 2959| 0| *re_ast = NULL; 2960| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 2961| 0| } 2962| | 2963| 15.9k| yyset_extra(*re_ast, yyscanner); ------------------ | | 140| 15.9k|#define yyset_extra re_yyset_extra ------------------ 2964| 15.9k| yy_scan_string(re_string, yyscanner); ------------------ | | 38| 15.9k|#define yy_scan_string re_yy_scan_string ------------------ 2965| | 2966| 15.9k| yyparse(yyscanner, &lex_env); ------------------ | | 45| 15.9k|#define yyparse re_yyparse ------------------ 2967| 15.9k| yylex_destroy(yyscanner); ------------------ | | 116| 15.9k|#define yylex_destroy re_yylex_destroy ------------------ 2968| | 2969| 15.9k| if (lex_env.last_error != ERROR_SUCCESS) ------------------ | | 40| 15.9k|#define ERROR_SUCCESS 0 ------------------ | Branch (2969:7): [True: 695, False: 15.2k] ------------------ 2970| 695| { 2971| 695| if (lex_env.last_error != ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 695|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (2971:9): [True: 695, False: 0] ------------------ 2972| 695| { 2973| 695| yr_re_ast_destroy(*re_ast); 2974| 695| *re_ast = NULL; 2975| 695| } 2976| | 2977| 695| strlcpy( 2978| 695| error->message, 2979| 695| lex_env.last_error_message, 2980| 695| sizeof(error->message)); 2981| | 2982| 695| return lex_env.last_error; 2983| 695| } 2984| | 2985| 15.2k| return ERROR_SUCCESS; ------------------ | | 40| 15.2k|#define ERROR_SUCCESS 0 ------------------ 2986| 15.9k|} re_lexer.c:yy_get_next_buffer: 1735| 31.4k|{ 1736| 31.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1737| 31.4k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 31.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1738| 31.4k| char *source = yyg->yytext_ptr; ------------------ | | 567| 31.4k|#define yytext_ptr yytext_r ------------------ 1739| 31.4k| int number_to_move, i; 1740| 31.4k| int ret_val; 1741| | 1742| 31.4k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 31.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1742:7): [True: 0, False: 31.4k] ------------------ 1743| 0| YY_FATAL_ERROR( ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1744| 31.4k| "fatal flex scanner internal error--end of buffer missed" ); 1745| | 1746| 31.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 31.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1746:7): [True: 31.4k, False: 0] ------------------ 1747| 31.4k| { /* Don't try to fill the buffer, so this is an EOF. */ 1748| 31.4k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 31.4k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 709| 31.4k|#define YY_MORE_ADJ 0 ------------------ | Branch (1748:8): [True: 15.4k, False: 16.0k] ------------------ 1749| 15.4k| { 1750| | /* We matched a single character, the EOB, so 1751| | * treat this as a final EOF. 1752| | */ 1753| 15.4k| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 15.4k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1754| 15.4k| } 1755| | 1756| 16.0k| else 1757| 16.0k| { 1758| | /* We matched some text prior to the EOB, first 1759| | * process it. 1760| | */ 1761| 16.0k| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 16.0k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1762| 16.0k| } 1763| 31.4k| } 1764| | 1765| | /* Try to read more data. */ 1766| | 1767| | /* First move last chars to start of buffer. */ 1768| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1769| | 1770| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1770:15): [True: 0, False: 0] ------------------ 1771| 0| *(dest++) = *(source++); 1772| | 1773| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (1773:7): [True: 0, False: 0] ------------------ 1774| | /* don't do the read, it's not guaranteed to return an EOF, 1775| | * just force an EOF 1776| | */ 1777| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1778| | 1779| 0| else 1780| 0| { 1781| 0| int num_to_read = 1782| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1783| | 1784| 0| while ( num_to_read <= 0 ) ------------------ | Branch (1784:11): [True: 0, False: 0] ------------------ 1785| 0| { /* Not enough room in the buffer - grow it. */ 1786| | 1787| | /* just a shorter name for the current buffer */ 1788| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1789| | 1790| 0| int yy_c_buf_p_offset = 1791| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1792| | 1793| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (1793:9): [True: 0, False: 0] ------------------ 1794| 0| { 1795| 0| int new_size = b->yy_buf_size * 2; 1796| | 1797| 0| if ( new_size <= 0 ) ------------------ | Branch (1797:10): [True: 0, False: 0] ------------------ 1798| 0| b->yy_buf_size += b->yy_buf_size / 8; 1799| 0| else 1800| 0| b->yy_buf_size *= 2; 1801| | 1802| 0| b->yy_ch_buf = (char *) 1803| | /* Include room in for 2 EOB chars. */ 1804| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 230| 0|#define yyrealloc re_yyrealloc ------------------ 1805| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1806| 0| } 1807| 0| else 1808| | /* Can't grow it, we don't own it. */ 1809| 0| b->yy_ch_buf = NULL; 1810| | 1811| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (1811:9): [True: 0, False: 0] ------------------ 1812| 0| YY_FATAL_ERROR( ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1813| 0| "fatal error - scanner input buffer overflow" ); 1814| | 1815| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1816| | 1817| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1818| 0| number_to_move - 1; 1819| | 1820| 0| } 1821| | 1822| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 945| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1822:8): [True: 0, False: 0] ------------------ 1823| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 945| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 1824| | 1825| | /* Read in more data. */ 1826| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 962| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (962:7): [True: 0, False: 0] | | ------------------ | | 963| 0| { \ | | 964| 0| int c = '*'; \ | | 965| 0| int n; \ | | 966| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (966:16): [True: 0, False: 0] | | ------------------ | | 967| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (967:9): [True: 0, False: 0] | | | Branch (967:38): [True: 0, False: 0] | | ------------------ | | 968| 0| buf[n] = (char) c; \ | | 969| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (969:8): [True: 0, False: 0] | | ------------------ | | 970| 0| buf[n++] = (char) c; \ | | 971| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (971:8): [True: 0, False: 0] | | | Branch (971:20): [True: 0, False: 0] | | ------------------ | | 972| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) | | ------------------ | | 973| 0| result = n; \ | | 974| 0| } \ | | 975| 0| else \ | | 976| 0| { \ | | 977| 0| errno=0; \ | | 978| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (978:11): [True: 0, False: 0] | | | Branch (978:78): [True: 0, False: 0] | | ------------------ | | 979| 0| { \ | | 980| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (980:8): [True: 0, False: 0] | | ------------------ | | 981| 0| { \ | | 982| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) | | ------------------ | | 983| 0| break; \ | | 984| 0| } \ | | 985| 0| errno=0; \ | | 986| 0| clearerr(yyin); \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | 987| 0| } \ | | 988| 0| }\ ------------------ 1827| 0| yyg->yy_n_chars, num_to_read ); 1828| | 1829| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1830| 0| } 1831| | 1832| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1832:7): [True: 0, False: 0] ------------------ 1833| 0| { 1834| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 709| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1834:8): [True: 0, False: 0] ------------------ 1835| 0| { 1836| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 398| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1837| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart re_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ 1838| 0| } 1839| | 1840| 0| else 1841| 0| { 1842| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 399| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1843| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1844| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1845| 0| } 1846| 0| } 1847| | 1848| 0| else 1849| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1850| | 1851| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1851:6): [True: 0, False: 0] ------------------ 1852| | /* Extend the array by 50%, plus the number we really need. */ 1853| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1854| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 230| 0|#define yyrealloc re_yyrealloc ------------------ 1855| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1856| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1856:8): [True: 0, False: 0] ------------------ 1857| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1858| | /* "- 2" to take care of EOB's */ 1859| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1860| 0| } 1861| | 1862| 0| yyg->yy_n_chars += number_to_move; 1863| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1864| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 1865| | 1866| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1867| | 1868| 0| return ret_val; 1869| 31.4k|} re_lexer.c:yy_get_previous_state: 1874| 15.7k|{ 1875| 15.7k| yy_state_type yy_current_state; 1876| 15.7k| char *yy_cp; 1877| 15.7k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1878| | 1879| 15.7k| yy_current_state = yyg->yy_start; 1880| | 1881| 59.3k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 15.7k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 709| 15.7k|#define YY_MORE_ADJ 0 ------------------ | Branch (1881:47): [True: 43.5k, False: 15.7k] ------------------ 1882| 43.5k| { 1883| 43.5k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 43.5k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1883:19): [True: 43.5k, False: 0] ------------------ 1884| 43.5k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1884:8): [True: 462, False: 43.0k] ------------------ 1885| 462| { 1886| 462| yyg->yy_last_accepting_state = yy_current_state; 1887| 462| yyg->yy_last_accepting_cpos = yy_cp; 1888| 462| } 1889| 55.2k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1889:11): [True: 11.7k, False: 43.5k] ------------------ 1890| 11.7k| { 1891| 11.7k| yy_current_state = (int) yy_def[yy_current_state]; 1892| 11.7k| if ( yy_current_state >= 47 ) ------------------ | Branch (1892:9): [True: 11.7k, False: 0] ------------------ 1893| 11.7k| yy_c = yy_meta[yy_c]; 1894| 11.7k| } 1895| 43.5k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1896| 43.5k| } 1897| | 1898| 15.7k| return yy_current_state; 1899| 15.7k|} re_lexer.c:re_yy_load_buffer_state: 2073| 32.5k|{ 2074| 32.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2075| 32.5k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2076| 32.5k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 32.5k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2077| 32.5k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 32.5k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 32.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2078| 32.5k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2079| 32.5k|} re_lexer.c:re_yy_init_buffer: 2137| 256|{ 2138| 256| int oerrno = errno; 2139| 256| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2140| | 2141| 256| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 256|#define yy_flush_buffer re_yy_flush_buffer ------------------ 2142| | 2143| 256| b->yy_input_file = file; 2144| 256| b->yy_fill_buffer = 1; 2145| | 2146| | /* If b is the current buffer, then yy_init_buffer was _probably_ 2147| | * called from yyrestart() or through yy_get_next_buffer. 2148| | * In that case, we don't want to reset the lineno or column. 2149| | */ 2150| 256| if (b != YY_CURRENT_BUFFER){ ------------------ | | 509| 256|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 256, False: 0] | | ------------------ | | 510| 256| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 256| : NULL) ------------------ | Branch (2150:9): [True: 0, False: 256] ------------------ 2151| 0| b->yy_bs_lineno = 1; 2152| 0| b->yy_bs_column = 0; 2153| 0| } 2154| | 2155| 256| b->yy_is_interactive = 0; 2156| | 2157| 256| errno = oerrno; 2158| 256|} re_lexer.c:re_yyensure_buffer_stack: 2246| 15.9k|{ 2247| 15.9k| yy_size_t num_to_alloc; 2248| 15.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2249| | 2250| 15.9k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2250:6): [True: 15.9k, False: 0] ------------------ 2251| | 2252| | /* First allocation is just for 2 elements, since we don't know if this 2253| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2254| | * immediate realloc on the next call. 2255| | */ 2256| 15.9k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2257| 15.9k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 15.9k|#define yyalloc re_yyalloc ------------------ 2258| 15.9k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2259| 15.9k| , yyscanner); 2260| 15.9k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2260:8): [True: 0, False: 15.9k] ------------------ 2261| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2262| | 2263| 15.9k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2264| | 2265| 15.9k| yyg->yy_buffer_stack_max = num_to_alloc; 2266| 15.9k| yyg->yy_buffer_stack_top = 0; 2267| 15.9k| return; 2268| 15.9k| } 2269| | 2270| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2270:6): [True: 0, False: 0] ------------------ 2271| | 2272| | /* Increase the buffer to prepare for a possible push. */ 2273| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2274| | 2275| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2276| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 230| 0|#define yyrealloc re_yyrealloc ------------------ 2277| 0| (yyg->yy_buffer_stack, 2278| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2279| 0| , yyscanner); 2280| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2280:8): [True: 0, False: 0] ------------------ 2281| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 90| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2282| | 2283| | /* zero only the new slots.*/ 2284| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2285| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2286| 0| } 2287| 0|} re_lexer.c:yy_init_globals: 2623| 31.9k|{ 2624| 31.9k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2625| | /* Initialization is the same as for the non-reentrant scanner. 2626| | * This function is called from yylex_destroy(), so don't allocate here. 2627| | */ 2628| | 2629| 31.9k| yyg->yy_buffer_stack = NULL; 2630| 31.9k| yyg->yy_buffer_stack_top = 0; 2631| 31.9k| yyg->yy_buffer_stack_max = 0; 2632| 31.9k| yyg->yy_c_buf_p = NULL; 2633| 31.9k| yyg->yy_init = 0; 2634| 31.9k| yyg->yy_start = 0; 2635| | 2636| 31.9k| yyg->yy_start_stack_ptr = 0; 2637| 31.9k| yyg->yy_start_stack_depth = 0; 2638| 31.9k| yyg->yy_start_stack = NULL; 2639| | 2640| |/* Defined in main.c */ 2641| |#ifdef YY_STDINIT 2642| | yyin = stdin; 2643| | yyout = stdout; 2644| |#else 2645| 31.9k| yyin = NULL; ------------------ | | 344| 31.9k|#define yyin yyg->yyin_r ------------------ 2646| 31.9k| yyout = NULL; ------------------ | | 345| 31.9k|#define yyout yyg->yyout_r ------------------ 2647| 31.9k|#endif 2648| | 2649| | /* For future reference: Set errno on error, since we are called by 2650| | * yylex_init() 2651| | */ 2652| 31.9k| return 0; 2653| 31.9k|} re_lexer.c:input: 1942| 3.06M|{ 1943| 3.06M| int c; 1944| 3.06M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1945| | 1946| 3.06M| *yyg->yy_c_buf_p = yyg->yy_hold_char; 1947| | 1948| 3.06M| if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 3.06M|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (1948:7): [True: 256, False: 3.06M] ------------------ 1949| 256| { 1950| | /* yy_c_buf_p now points to the character we want to return. 1951| | * If this occurs *before* the EOB characters, then it's a 1952| | * valid NUL; if not, then we've hit the end of the buffer. 1953| | */ 1954| 256| if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 256|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1954:8): [True: 0, False: 256] ------------------ 1955| | /* This was really a NUL. */ 1956| 0| *yyg->yy_c_buf_p = '\0'; 1957| | 1958| 256| else 1959| 256| { /* need more input */ 1960| 256| int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); ------------------ | | 567| 256|#define yytext_ptr yytext_r ------------------ 1961| 256| ++yyg->yy_c_buf_p; 1962| | 1963| 256| switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1963:13): [True: 0, False: 256] ------------------ 1964| 256| { 1965| 256| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 256|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1965:5): [True: 256, False: 0] ------------------ 1966| | /* This happens because yy_g_n_b() 1967| | * sees that we've accumulated a 1968| | * token and flags that we need to 1969| | * try matching the token before 1970| | * proceeding. But for input(), 1971| | * there's no matching to consider. 1972| | * So convert the EOB_ACT_LAST_MATCH 1973| | * to EOB_ACT_END_OF_FILE. 1974| | */ 1975| | 1976| | /* Reset buffer status. */ 1977| 256| yyrestart( yyin , yyscanner); ------------------ | | 98| 256|#define yyrestart re_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 256|#define yyin yyg->yyin_r ------------------ 1978| | 1979| | /*FALLTHROUGH*/ 1980| | 1981| 256| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 256|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1981:5): [True: 0, False: 256] ------------------ 1982| 256| { 1983| 256| if ( yywrap( yyscanner ) ) ------------------ | | 206| 256|#define yywrap re_yywrap | | ------------------ | | | | 561| 256|#define re_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1984| 256| return 0; 1985| | 1986| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1986:11): [True: 0, False: 0] ------------------ 1987| 0| YY_NEW_FILE; ------------------ | | 367| 0|#define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 98| 0|#define yyrestart re_yyrestart | | ------------------ | | #define YY_NEW_FILE yyrestart( yyin , yyscanner ) | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ ------------------ 1988| |#ifdef __cplusplus 1989| | return yyinput(yyscanner); 1990| |#else 1991| 0| return input(yyscanner); 1992| 256|#endif 1993| 256| } 1994| | 1995| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1995:5): [True: 0, False: 256] ------------------ 1996| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + offset; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1997| 0| break; 1998| 256| } 1999| 256| } 2000| 256| } 2001| | 2002| 3.06M| c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ 2003| 3.06M| *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ 2004| 3.06M| yyg->yy_hold_char = *++yyg->yy_c_buf_p; 2005| | 2006| 3.06M| if ( c == '\n' ) ------------------ | Branch (2006:7): [True: 0, False: 3.06M] ------------------ 2007| | 2008| 0| do{ yylineno++; ------------------ | | 349| 0|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 2009| 0| yycolumn=0; ------------------ | | 350| 0|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 2010| 0| }while(0) ------------------ | Branch (2010:12): [Folded - Ignored] ------------------ 2011| 3.06M|; 2012| | 2013| 3.06M| return c; 2014| 3.06M|} yr_rules_from_arena: 327| 112|{ 328| 112| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_get_ptr( 329| 112| arena, YR_SUMMARY_SECTION, 0); ------------------ | | 68| 112|#define YR_SUMMARY_SECTION 11 ------------------ 330| | 331| 112| if (summary == NULL) ------------------ | Branch (331:7): [True: 0, False: 112] ------------------ 332| 0| return ERROR_CORRUPT_FILE; ------------------ | | 52| 0|#define ERROR_CORRUPT_FILE 7 ------------------ 333| | 334| 112| YR_RULES* new_rules = (YR_RULES*) yr_malloc(sizeof(YR_RULES)); 335| | 336| 112| if (new_rules == NULL) ------------------ | Branch (336:7): [True: 0, False: 112] ------------------ 337| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 338| | 339| 112| new_rules->no_required_strings = (YR_BITMASK*) yr_calloc( 340| 112| sizeof(YR_BITMASK), YR_BITMASK_SIZE(summary->num_rules)); ------------------ | | 57| 112|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 112|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 341| | 342| 112| if (new_rules->no_required_strings == NULL) ------------------ | Branch (342:7): [True: 0, False: 112] ------------------ 343| 0| { 344| 0| yr_free(new_rules); 345| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 346| 0| } 347| | 348| | // Now YR_RULES relies on this arena, let's increment the arena's 349| | // reference count so that if the original owner of the arena calls 350| | // yr_arena_destroy the arena is not destroyed. 351| 112| yr_arena_acquire(arena); 352| | 353| 112| new_rules->arena = arena; 354| 112| new_rules->num_rules = summary->num_rules; 355| 112| new_rules->num_strings = summary->num_strings; 356| 112| new_rules->num_namespaces = summary->num_namespaces; 357| | 358| 112| new_rules->rules_table = yr_arena_get_ptr(arena, YR_RULES_TABLE, 0); ------------------ | | 58| 112|#define YR_RULES_TABLE 1 ------------------ 359| | 360| 112| new_rules->strings_table = yr_arena_get_ptr(arena, YR_STRINGS_TABLE, 0); ------------------ | | 60| 112|#define YR_STRINGS_TABLE 3 ------------------ 361| | 362| 112| new_rules->ext_vars_table = yr_arena_get_ptr( 363| 112| arena, YR_EXTERNAL_VARIABLES_TABLE, 0); ------------------ | | 61| 112|#define YR_EXTERNAL_VARIABLES_TABLE 4 ------------------ 364| | 365| 112| new_rules->ac_transition_table = yr_arena_get_ptr( 366| 112| arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 112|#define YR_AC_TRANSITION_TABLE 8 ------------------ 367| | 368| 112| new_rules->ac_match_table = yr_arena_get_ptr( 369| 112| arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 112|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 370| | 371| 112| new_rules->ac_match_pool = yr_arena_get_ptr( 372| 112| arena, YR_AC_STATE_MATCHES_POOL, 0); ------------------ | | 67| 112|#define YR_AC_STATE_MATCHES_POOL 10 ------------------ 373| | 374| 112| new_rules->code_start = yr_arena_get_ptr(arena, YR_CODE_SECTION, 0); ------------------ | | 63| 112|#define YR_CODE_SECTION 6 ------------------ 375| | 376| | // If a rule has no required_strings, this means that the condition might 377| | // evaluate to true without any matching strings, and we therefore have to 378| | // mark it as "to be evaluated" from the beginning. 379| 180| for (int i = 0; i < new_rules->num_rules; i++) ------------------ | Branch (379:19): [True: 68, False: 112] ------------------ 380| 68| { 381| 68| if (new_rules->rules_table[i].required_strings == 0) ------------------ | Branch (381:9): [True: 31, False: 37] ------------------ 382| 31| yr_bitmask_set(new_rules->no_required_strings, i); ------------------ | | 60| 31| do \ | | 61| 31| { \ | | 62| 31| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 31|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 31|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 31| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 383| 68| } 384| | 385| 112| *rules = new_rules; 386| | 387| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 388| 112|} yr_rules_destroy: 534| 112|{ 535| 112| YR_EXTERNAL_VARIABLE* external = rules->ext_vars_table; 536| | 537| 112| while (!EXTERNAL_VARIABLE_IS_NULL(external)) ------------------ | | 152| 112| ((x) != NULL ? (x)->type == EXTERNAL_VARIABLE_TYPE_NULL : true) | | ------------------ | | | | 144| 112|#define EXTERNAL_VARIABLE_TYPE_NULL 0 | | ------------------ | | | Branch (152:4): [True: 112, False: 0] | | ------------------ ------------------ | Branch (537:10): [True: 0, False: 112] ------------------ 538| 0| { 539| 0| if (external->type == EXTERNAL_VARIABLE_TYPE_MALLOC_STRING) ------------------ | | 149| 0|#define EXTERNAL_VARIABLE_TYPE_MALLOC_STRING 5 ------------------ | Branch (539:9): [True: 0, False: 0] ------------------ 540| 0| yr_free(external->value.s); 541| | 542| 0| external++; 543| 0| } 544| | 545| 112| yr_free(rules->no_required_strings); 546| 112| yr_arena_release(rules->arena); 547| 112| yr_free(rules); 548| | 549| 112| return ERROR_SUCCESS; ------------------ | | 40| 112|#define ERROR_SUCCESS 0 ------------------ 550| 112|} ss_compare: 45| 868|{ 46| 868| size_t i = 0; 47| | 48| 56.0k| while (s1->length > i && s2->length > i && s1->c_string[i] == s2->c_string[i]) ------------------ | Branch (48:10): [True: 55.1k, False: 862] | Branch (48:28): [True: 55.1k, False: 0] | Branch (48:46): [True: 55.1k, False: 6] ------------------ 49| 55.1k| { 50| 55.1k| i++; 51| 55.1k| } 52| | 53| 868| if (i == s1->length && i == s2->length) ------------------ | Branch (53:7): [True: 862, False: 6] | Branch (53:26): [True: 862, False: 0] ------------------ 54| 862| return 0; 55| 6| else if (i == s1->length) ------------------ | Branch (55:12): [True: 0, False: 6] ------------------ 56| 0| return -1; 57| 6| else if (i == s2->length) ------------------ | Branch (57:12): [True: 0, False: 6] ------------------ 58| 0| return 1; 59| 6| else if (s1->c_string[i] < s2->c_string[i]) ------------------ | Branch (59:12): [True: 1, False: 5] ------------------ 60| 1| return -1; 61| 5| else 62| 5| return 1; 63| 868|} ss_new: 216| 2.66k|{ 217| 2.66k| SIZED_STRING* result; 218| | 219| 2.66k| size_t length = strlen(s); 220| | 221| 2.66k| result = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 222| | 223| 2.66k| if (result == NULL) ------------------ | Branch (223:7): [True: 0, False: 2.66k] ------------------ 224| 0| return NULL; 225| | 226| 2.66k| result->length = (uint32_t) length; 227| 2.66k| result->flags = 0; 228| | 229| | // Copy the string and the null terminator. 230| 2.66k| strcpy(result->c_string, s); 231| | 232| 2.66k| return result; 233| 2.66k|} ss_convert_to_wide: 240| 4.27k|{ 241| 4.27k| SIZED_STRING* wide = (SIZED_STRING*) yr_malloc( 242| 4.27k| sizeof(SIZED_STRING) + s->length * 2); 243| | 244| 4.27k| if (wide == NULL) ------------------ | Branch (244:7): [True: 0, False: 4.27k] ------------------ 245| 0| return NULL; 246| | 247| 1.13M| for (size_t i = 0; i < s->length; i++) ------------------ | Branch (247:22): [True: 1.13M, False: 4.27k] ------------------ 248| 1.13M| { 249| 1.13M| wide->c_string[i * 2] = s->c_string[i]; 250| 1.13M| wide->c_string[i * 2 + 1] = '\x00'; 251| 1.13M| } 252| | 253| 4.27k| wide->length = s->length * 2; 254| 4.27k| wide->flags = s->flags | STRING_FLAGS_WIDE; ------------------ | | 70| 4.27k|#define STRING_FLAGS_WIDE 0x10 ------------------ 255| | 256| 4.27k| return wide; 257| 4.27k|} yr_stack_create: 42| 8.78k|{ 43| 8.78k| *stack = (YR_STACK*) yr_malloc(sizeof(YR_STACK)); 44| | 45| 8.78k| if (*stack == NULL) ------------------ | Branch (45:7): [True: 0, False: 8.78k] ------------------ 46| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 47| | 48| 8.78k| (*stack)->items = yr_malloc(initial_capacity * item_size); 49| | 50| 8.78k| if ((*stack)->items == NULL) ------------------ | Branch (50:7): [True: 0, False: 8.78k] ------------------ 51| 0| { 52| 0| yr_free(*stack); 53| 0| *stack = NULL; 54| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 55| 0| } 56| | 57| 8.78k| (*stack)->capacity = initial_capacity; 58| 8.78k| (*stack)->item_size = item_size; 59| 8.78k| (*stack)->top = 0; 60| | 61| 8.78k| return ERROR_SUCCESS; ------------------ | | 40| 8.78k|#define ERROR_SUCCESS 0 ------------------ 62| 8.78k|} yr_stack_destroy: 68| 8.78k|{ 69| 8.78k| yr_free(stack->items); 70| 8.78k| yr_free(stack); 71| 8.78k|} yr_stack_push: 79| 8.10M|{ 80| 8.10M| if (stack->top == stack->capacity) ------------------ | Branch (80:7): [True: 459, False: 8.10M] ------------------ 81| 459| { 82| 459| void* items = yr_realloc( 83| 459| stack->items, 2 * stack->capacity * stack->item_size); 84| | 85| 459| if (items == NULL) ------------------ | Branch (85:9): [True: 0, False: 459] ------------------ 86| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 87| | 88| 459| stack->items = items; 89| 459| stack->capacity *= 2; 90| 459| } 91| | 92| 8.10M| memcpy( 93| 8.10M| (uint8_t*) stack->items + stack->top * stack->item_size, 94| 8.10M| item, 95| 8.10M| stack->item_size); 96| | 97| 8.10M| stack->top++; 98| | 99| 8.10M| return ERROR_SUCCESS; ------------------ | | 40| 8.10M|#define ERROR_SUCCESS 0 ------------------ 100| 8.10M|} yr_stack_pop: 109| 8.11M|{ 110| 8.11M| if (stack->top == 0) // Return 0 if stack is empty. ------------------ | Branch (110:7): [True: 8.78k, False: 8.10M] ------------------ 111| 8.78k| return 0; 112| | 113| 8.10M| stack->top--; 114| | 115| 8.10M| memcpy( 116| 8.10M| item, 117| 8.10M| (uint8_t*) stack->items + stack->top * stack->item_size, 118| 8.10M| stack->item_size); 119| | 120| 8.10M| return 1; 121| 8.11M|} xtoi: 36| 13.3k|{ 37| 13.3k| size_t i; 38| 13.3k| size_t l = strlen(hexstr); 39| | 40| 13.3k| uint64_t r = 0; 41| | 42| 40.1k| for (i = 0; i < l; i++) ------------------ | Branch (42:15): [True: 26.7k, False: 13.3k] ------------------ 43| 26.7k| { 44| 26.7k| switch (hexstr[i]) 45| 26.7k| { 46| 10.4k| case '0': ------------------ | Branch (46:5): [True: 10.4k, False: 16.3k] ------------------ 47| 12.5k| case '1': ------------------ | Branch (47:5): [True: 2.07k, False: 24.7k] ------------------ 48| 12.9k| case '2': ------------------ | Branch (48:5): [True: 484, False: 26.3k] ------------------ 49| 13.4k| case '3': ------------------ | Branch (49:5): [True: 448, False: 26.3k] ------------------ 50| 13.7k| case '4': ------------------ | Branch (50:5): [True: 278, False: 26.5k] ------------------ 51| 14.8k| case '5': ------------------ | Branch (51:5): [True: 1.17k, False: 25.6k] ------------------ 52| 15.3k| case '6': ------------------ | Branch (52:5): [True: 447, False: 26.3k] ------------------ 53| 15.6k| case '7': ------------------ | Branch (53:5): [True: 279, False: 26.5k] ------------------ 54| 15.8k| case '8': ------------------ | Branch (54:5): [True: 231, False: 26.5k] ------------------ 55| 15.9k| case '9': ------------------ | Branch (55:5): [True: 80, False: 26.7k] ------------------ 56| 15.9k| r |= ((uint64_t) (hexstr[i] - '0')) << ((l - i - 1) * 4); 57| 15.9k| break; 58| 971| case 'a': ------------------ | Branch (58:5): [True: 971, False: 25.8k] ------------------ 59| 1.57k| case 'b': ------------------ | Branch (59:5): [True: 605, False: 26.1k] ------------------ 60| 1.61k| case 'c': ------------------ | Branch (60:5): [True: 39, False: 26.7k] ------------------ 61| 2.89k| case 'd': ------------------ | Branch (61:5): [True: 1.28k, False: 25.5k] ------------------ 62| 2.92k| case 'e': ------------------ | Branch (62:5): [True: 29, False: 26.7k] ------------------ 63| 7.91k| case 'f': ------------------ | Branch (63:5): [True: 4.98k, False: 21.8k] ------------------ 64| 7.91k| r |= ((uint64_t) (hexstr[i] - 'a' + 10)) << ((l - i - 1) * 4); 65| 7.91k| break; 66| 2.13k| case 'A': ------------------ | Branch (66:5): [True: 2.13k, False: 24.6k] ------------------ 67| 2.34k| case 'B': ------------------ | Branch (67:5): [True: 217, False: 26.5k] ------------------ 68| 2.37k| case 'C': ------------------ | Branch (68:5): [True: 30, False: 26.7k] ------------------ 69| 2.41k| case 'D': ------------------ | Branch (69:5): [True: 35, False: 26.7k] ------------------ 70| 2.90k| case 'E': ------------------ | Branch (70:5): [True: 489, False: 26.3k] ------------------ 71| 2.95k| case 'F': ------------------ | Branch (71:5): [True: 50, False: 26.7k] ------------------ 72| 2.95k| r |= ((uint64_t) (hexstr[i] - 'A' + 10)) << ((l - i - 1) * 4); 73| 2.95k| break; 74| 0| default: ------------------ | Branch (74:5): [True: 0, False: 26.7k] ------------------ 75| 0| i = l; // force loop exit 76| 26.7k| } 77| 26.7k| } 78| | 79| 13.3k| return r; 80| 13.3k|} strlcpy: 91| 46.7k|{ 92| 46.7k| register char* d = dst; 93| 46.7k| register const char* s = src; 94| 46.7k| register size_t n = size; 95| | 96| | // Copy as many bytes as will fit 97| | 98| 46.7k| if (n != 0 && --n != 0) ------------------ | Branch (98:7): [True: 46.7k, False: 0] | Branch (98:17): [True: 46.7k, False: 0] ------------------ 99| 46.7k| { 100| 46.7k| do 101| 1.34M| { 102| 1.34M| if ((*d++ = *s++) == 0) ------------------ | Branch (102:11): [True: 27.3k, False: 1.32M] ------------------ 103| 27.3k| break; 104| | 105| 1.34M| } while (--n != 0); ------------------ | Branch (105:14): [True: 1.30M, False: 19.4k] ------------------ 106| 46.7k| } 107| | 108| | // Not enough room in dst, add NUL and traverse rest of src 109| | 110| 46.7k| if (n == 0) ------------------ | Branch (110:7): [True: 19.4k, False: 27.3k] ------------------ 111| 19.4k| { 112| 19.4k| if (size != 0) ------------------ | Branch (112:9): [True: 19.4k, False: 0] ------------------ 113| 19.4k| *d = '\0'; // NULL-terminate dst 114| | 115| 122k| while (*s++) ------------------ | Branch (115:12): [True: 103k, False: 19.4k] ------------------ 116| 103k| ; 117| 19.4k| } 118| | 119| 46.7k| return (s - src - 1); // count does not include NULL 120| 46.7k|} strlcat: 125| 19.7k|{ 126| 19.7k| register char* d = dst; 127| 19.7k| register const char* s = src; 128| 19.7k| register size_t n = size; 129| 19.7k| size_t dlen; 130| | 131| | // Find the end of dst and adjust bytes left but don't go past end 132| | 133| 1.41M| while (n-- != 0 && *d != '\0') d++; ------------------ | Branch (133:10): [True: 1.41M, False: 0] | Branch (133:22): [True: 1.39M, False: 19.7k] ------------------ 134| | 135| 19.7k| dlen = d - dst; 136| 19.7k| n = size - dlen; 137| | 138| 19.7k| if (n == 0) ------------------ | Branch (138:7): [True: 0, False: 19.7k] ------------------ 139| 0| return (dlen + strlen(s)); 140| | 141| 39.5k| while (*s != '\0') ------------------ | Branch (141:10): [True: 19.7k, False: 19.7k] ------------------ 142| 19.7k| { 143| 19.7k| if (n != 1) ------------------ | Branch (143:9): [True: 11.4k, False: 8.29k] ------------------ 144| 11.4k| { 145| 11.4k| *d++ = *s; 146| 11.4k| n--; 147| 11.4k| } 148| 19.7k| s++; 149| 19.7k| } 150| | 151| 19.7k| *d = '\0'; 152| | 153| 19.7k| return (dlen + (s - src)); // count does not include NULL 154| 19.7k|} yr_thread_storage_create: 160| 4|{ 161| 4| if (pthread_key_create(storage, NULL) != 0) ------------------ | Branch (161:7): [True: 0, False: 4] ------------------ 162| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 163| | 164| 4| return ERROR_SUCCESS; ------------------ | | 40| 4|#define ERROR_SUCCESS 0 ------------------ 165| 4|} yr_thread_storage_set_value: 178| 17.2k|{ 179| 17.2k| if (pthread_setspecific(*storage, value) != 0) ------------------ | Branch (179:7): [True: 0, False: 17.2k] ------------------ 180| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 181| | 182| 17.2k| return ERROR_SUCCESS; ------------------ | | 40| 17.2k|#define ERROR_SUCCESS 0 ------------------ 183| 17.2k|} LLVMFuzzerInitialize: 37| 2|{ 38| 2| yr_initialize(); 39| 2| return 0; 40| 2|} LLVMFuzzerTestOneInput: 44| 1.72k|{ 45| 1.72k| YR_RULES* rules; 46| 1.72k| YR_COMPILER* compiler; 47| | 48| 1.72k| char* buffer = (char*) malloc(size + 1); 49| | 50| 1.72k| if (!buffer) ------------------ | Branch (50:7): [True: 0, False: 1.72k] ------------------ 51| 0| return 0; 52| | 53| 1.72k| strncpy(buffer, (const char*) data, size); 54| 1.72k| buffer[size] = 0; 55| | 56| 1.72k| if (yr_compiler_create(&compiler) != ERROR_SUCCESS) ------------------ | Branch (56:7): [True: 0, False: 1.72k] ------------------ 57| 0| { 58| 0| free(buffer); 59| 0| return 0; 60| 0| } 61| | 62| 1.72k| if (yr_compiler_add_string(compiler, (const char*) buffer, NULL) == 0) ------------------ | Branch (62:7): [True: 112, False: 1.61k] ------------------ 63| 112| { 64| 112| if (yr_compiler_get_rules(compiler, &rules) == ERROR_SUCCESS) ------------------ | Branch (64:9): [True: 112, False: 0] ------------------ 65| 112| yr_rules_destroy(rules); 66| 112| } 67| | 68| 1.72k| yr_compiler_destroy(compiler); 69| 1.72k| free(buffer); 70| | 71| 1.72k| return 0; 72| 1.72k|}