yr_ac_automaton_create: 732| 1.27k|{ 733| 1.27k| YR_AC_AUTOMATON* new_automaton; 734| 1.27k| YR_AC_STATE* root_state; 735| | 736| 1.27k| new_automaton = (YR_AC_AUTOMATON*) yr_malloc(sizeof(YR_AC_AUTOMATON)); 737| 1.27k| root_state = (YR_AC_STATE*) yr_malloc(sizeof(YR_AC_STATE)); 738| | 739| 1.27k| if (new_automaton == NULL || root_state == NULL) ------------------ | Branch (739:7): [True: 0, False: 1.27k] | Branch (739:32): [True: 0, False: 1.27k] ------------------ 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.27k| root_state->depth = 0; 748| 1.27k| root_state->matches_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 1.27k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 749| 1.27k| root_state->failure = NULL; 750| 1.27k| root_state->first_child = NULL; 751| 1.27k| root_state->siblings = NULL; 752| 1.27k| root_state->t_table_slot = 0; 753| | 754| 1.27k| new_automaton->arena = arena; 755| 1.27k| new_automaton->root = root_state; 756| 1.27k| new_automaton->bitmask = NULL; 757| 1.27k| new_automaton->tables_size = 0; 758| | 759| 1.27k| *automaton = new_automaton; 760| | 761| 1.27k| return ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 762| 1.27k|} yr_ac_automaton_destroy: 768| 1.27k|{ 769| 1.27k| _yr_ac_state_destroy(automaton->root); 770| | 771| 1.27k| yr_free(automaton->bitmask); 772| 1.27k| yr_free(automaton); 773| | 774| 1.27k| return ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 775| 1.27k|} yr_ac_add_string: 787| 24.9k|{ 788| 5.26M| while (atom != NULL) ------------------ | Branch (788:10): [True: 5.24M, False: 24.9k] ------------------ 789| 5.24M| { 790| 5.24M| YR_AC_STATE* state = automaton->root; 791| | 792| 25.6M| for (int i = 0; i < atom->atom.length; i++) ------------------ | Branch (792:21): [True: 20.4M, False: 5.24M] ------------------ 793| 20.4M| { 794| 20.4M| YR_AC_STATE* next_state = _yr_ac_next_state(state, atom->atom.bytes[i]); 795| | 796| 20.4M| if (next_state == NULL) ------------------ | Branch (796:11): [True: 328k, False: 20.0M] ------------------ 797| 328k| { 798| 328k| next_state = _yr_ac_state_create(state, atom->atom.bytes[i]); 799| | 800| 328k| if (next_state == NULL) ------------------ | Branch (800:13): [True: 0, False: 328k] ------------------ 801| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 802| 328k| } 803| | 804| 20.4M| state = next_state; 805| 20.4M| } 806| | 807| 5.24M| YR_ARENA_REF new_match_ref; 808| | 809| 5.24M| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 5.24M| { \ | | 132| 5.24M| int __error = (x); \ | | 133| 5.24M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 5.24M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 5.24M] | | ------------------ | | 134| 5.24M| return __error; \ | | 135| 5.24M| } ------------------ 810| 5.24M| arena, 811| 5.24M| YR_AC_STATE_MATCHES_POOL, 812| 5.24M| sizeof(YR_AC_MATCH), 813| 5.24M| &new_match_ref, 814| 5.24M| offsetof(YR_AC_MATCH, string), 815| 5.24M| offsetof(YR_AC_MATCH, forward_code), 816| 5.24M| offsetof(YR_AC_MATCH, backward_code), 817| 5.24M| offsetof(YR_AC_MATCH, next), 818| 5.24M| EOL)); 819| | 820| 5.24M| YR_AC_MATCH* new_match = yr_arena_ref_to_ptr(arena, &new_match_ref); 821| | 822| 5.24M| new_match->backtrack = state->depth + atom->backtrack; 823| 5.24M| new_match->string = yr_arena_get_ptr( 824| 5.24M| arena, YR_STRINGS_TABLE, string_idx * sizeof(struct YR_STRING)); ------------------ | | 60| 5.24M|#define YR_STRINGS_TABLE 3 ------------------ 825| | 826| 5.24M| new_match->forward_code = yr_arena_ref_to_ptr( 827| 5.24M| arena, &atom->forward_code_ref); 828| | 829| 5.24M| new_match->backward_code = yr_arena_ref_to_ptr( 830| 5.24M| arena, &atom->backward_code_ref); 831| | 832| | // Add newly created match to the list of matches for the state. 833| 5.24M| new_match->next = yr_arena_ref_to_ptr(arena, &state->matches_ref); 834| 5.24M| state->matches_ref = new_match_ref; 835| | 836| 5.24M| atom = atom->next; 837| 5.24M| } 838| | 839| 24.9k| return ERROR_SUCCESS; ------------------ | | 40| 24.9k|#define ERROR_SUCCESS 0 ------------------ 840| 24.9k|} yr_ac_compile: 847| 132|{ 848| 132| FAIL_ON_ERROR(_yr_ac_create_failure_links(automaton)); ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 849| 132| FAIL_ON_ERROR(_yr_ac_optimize_failure_links(automaton)); ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 850| 132| FAIL_ON_ERROR(_yr_ac_build_transition_table(automaton)); ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 851| | 852| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 853| 132|} ahocorasick.c:_yr_ac_state_destroy: 196| 329k|{ 197| 329k| YR_AC_STATE* child_state = state->first_child; 198| | 199| 657k| while (child_state != NULL) ------------------ | Branch (199:10): [True: 328k, False: 329k] ------------------ 200| 328k| { 201| 328k| YR_AC_STATE* next_child_state = child_state->siblings; 202| 328k| _yr_ac_state_destroy(child_state); 203| 328k| child_state = next_child_state; 204| 328k| } 205| | 206| 329k| yr_free(state); 207| | 208| 329k| return ERROR_SUCCESS; ------------------ | | 40| 329k|#define ERROR_SUCCESS 0 ------------------ 209| 329k|} ahocorasick.c:_yr_ac_next_state: 147| 20.6M|{ 148| 20.6M| YR_AC_STATE* next_state = state->first_child; 149| | 150| 784M| while (next_state != NULL) ------------------ | Branch (150:10): [True: 783M, False: 423k] ------------------ 151| 783M| { 152| 783M| if (next_state->input == input) ------------------ | Branch (152:9): [True: 20.2M, False: 763M] ------------------ 153| 20.2M| return next_state; 154| | 155| 763M| next_state = next_state->siblings; 156| 763M| } 157| | 158| 423k| return NULL; 159| 20.6M|} ahocorasick.c:_yr_ac_state_create: 174| 328k|{ 175| 328k| YR_AC_STATE* new_state = (YR_AC_STATE*) yr_malloc(sizeof(YR_AC_STATE)); 176| | 177| 328k| if (new_state == NULL) ------------------ | Branch (177:7): [True: 0, False: 328k] ------------------ 178| 0| return NULL; 179| | 180| 328k| new_state->input = input; 181| 328k| new_state->depth = state->depth + 1; 182| 328k| new_state->matches_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 328k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 183| 328k| new_state->failure = NULL; 184| 328k| new_state->t_table_slot = 0; 185| 328k| new_state->first_child = NULL; 186| 328k| new_state->siblings = state->first_child; 187| 328k| state->first_child = new_state; 188| | 189| 328k| return new_state; 190| 328k|} ahocorasick.c:_yr_ac_create_failure_links: 218| 132|{ 219| 132| YR_AC_STATE* current_state; 220| 132| YR_AC_STATE* failure_state; 221| 132| YR_AC_STATE* temp_state; 222| 132| YR_AC_STATE* state; 223| 132| YR_AC_STATE* transition_state; 224| 132| YR_AC_STATE* root_state; 225| 132| YR_AC_MATCH* match; 226| | 227| 132| QUEUE queue; 228| | 229| 132| queue.head = NULL; 230| 132| queue.tail = NULL; 231| | 232| 132| root_state = automaton->root; 233| | 234| | // Set the failure link of root state to itself. 235| 132| root_state->failure = root_state; 236| | 237| | // Push root's children and set their failure link to root. 238| 132| state = root_state->first_child; 239| | 240| 699| while (state != NULL) ------------------ | Branch (240:10): [True: 567, False: 132] ------------------ 241| 567| { 242| 567| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 131| 567| { \ | | 132| 567| int __error = (x); \ | | 133| 567| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 567|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 567] | | ------------------ | | 134| 567| return __error; \ | | 135| 567| } ------------------ 243| 567| state->failure = root_state; 244| 567| state = state->siblings; 245| 567| } 246| | 247| | // Traverse the trie in BFS order calculating the failure link 248| | // for each state. 249| 182k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (249:10): [True: 182k, False: 132] ------------------ 250| 182k| { 251| 182k| current_state = _yr_ac_queue_pop(&queue); 252| 182k| match = yr_arena_ref_to_ptr(automaton->arena, ¤t_state->matches_ref); 253| | 254| 182k| if (match != NULL) ------------------ | Branch (254:9): [True: 122k, False: 59.9k] ------------------ 255| 122k| { 256| | // Find the last match in the list of matches. 257| 4.73M| while (match->next != NULL) match = match->next; ------------------ | Branch (257:14): [True: 4.61M, False: 122k] ------------------ 258| | 259| 122k| if (match->backtrack > 0) ------------------ | Branch (259:11): [True: 121k, False: 826] ------------------ 260| 121k| match->next = yr_arena_ref_to_ptr( 261| 121k| automaton->arena, &root_state->matches_ref); 262| 122k| } 263| 59.9k| else 264| 59.9k| { 265| | // This state doesn't have any matches, its matches will be those 266| | // in the root state, if any. 267| 59.9k| current_state->matches_ref = root_state->matches_ref; 268| 59.9k| } 269| | 270| | // Iterate over all the states that the current state can transition to. 271| 182k| transition_state = current_state->first_child; 272| | 273| 364k| while (transition_state != NULL) ------------------ | Branch (273:12): [True: 181k, False: 182k] ------------------ 274| 181k| { 275| 181k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, transition_state)); ------------------ | | 131| 181k| { \ | | 132| 181k| int __error = (x); \ | | 133| 181k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 181k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 181k] | | ------------------ | | 134| 181k| return __error; \ | | 135| 181k| } ------------------ 276| 181k| failure_state = current_state->failure; 277| | 278| 216k| while (1) ------------------ | Branch (278:14): [Folded - Ignored] ------------------ 279| 216k| { 280| 216k| temp_state = _yr_ac_next_state(failure_state, transition_state->input); 281| | 282| 216k| if (temp_state != NULL) ------------------ | Branch (282:13): [True: 120k, False: 95.3k] ------------------ 283| 120k| { 284| 120k| transition_state->failure = temp_state; 285| | 286| 120k| if (YR_ARENA_IS_NULL_REF(transition_state->matches_ref)) ------------------ | | 46| 120k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 120k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 120k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | | Branch (46:3): [True: 25.8k, False: 94.9k] | | ------------------ ------------------ 287| 25.8k| { 288| 25.8k| transition_state->matches_ref = temp_state->matches_ref; 289| 25.8k| } 290| 94.9k| else 291| 94.9k| { 292| 94.9k| match = yr_arena_ref_to_ptr( 293| 94.9k| automaton->arena, &transition_state->matches_ref); 294| | 295| 94.9k| assert(match != NULL); 296| | 297| | // Find the last match in the list of matches. 298| 4.63M| while (match->next != NULL) match = match->next; ------------------ | Branch (298:20): [True: 4.53M, False: 94.9k] ------------------ 299| | 300| 94.9k| match->next = yr_arena_ref_to_ptr( 301| 94.9k| automaton->arena, &temp_state->matches_ref); 302| 94.9k| } 303| | 304| 120k| break; 305| 120k| } 306| 95.3k| else 307| 95.3k| { 308| 95.3k| if (failure_state == root_state) ------------------ | Branch (308:15): [True: 61.1k, False: 34.1k] ------------------ 309| 61.1k| { 310| 61.1k| transition_state->failure = root_state; 311| 61.1k| break; 312| 61.1k| } 313| 34.1k| else 314| 34.1k| { 315| 34.1k| failure_state = failure_state->failure; 316| 34.1k| } 317| 95.3k| } 318| 216k| } // while(1) 319| | 320| 181k| transition_state = transition_state->siblings; 321| 181k| } 322| | 323| 182k| } // while(!__yr_ac_queue_is_empty(&queue)) 324| | 325| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 326| 132|} ahocorasick.c:_yr_ac_queue_push: 68| 547k|{ 69| 547k| QUEUE_NODE* pushed_node; 70| | 71| 547k| pushed_node = (QUEUE_NODE*) yr_malloc(sizeof(QUEUE_NODE)); 72| | 73| 547k| if (pushed_node == NULL) ------------------ | Branch (73:7): [True: 0, False: 547k] ------------------ 74| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 75| | 76| 547k| pushed_node->previous = queue->tail; 77| 547k| pushed_node->next = NULL; 78| 547k| pushed_node->value = state; 79| | 80| 547k| if (queue->tail != NULL) ------------------ | Branch (80:7): [True: 547k, False: 111] ------------------ 81| 547k| queue->tail->next = pushed_node; 82| 111| else // queue is empty 83| 111| queue->head = pushed_node; 84| | 85| 547k| queue->tail = pushed_node; 86| | 87| 547k| return ERROR_SUCCESS; ------------------ | | 40| 547k|#define ERROR_SUCCESS 0 ------------------ 88| 547k|} ahocorasick.c:_yr_ac_queue_is_empty: 131| 548k|{ 132| 548k| return queue->head == NULL; 133| 548k|} ahocorasick.c:_yr_ac_queue_pop: 100| 547k|{ 101| 547k| YR_AC_STATE* result; 102| 547k| QUEUE_NODE* popped_node; 103| | 104| 547k| if (queue->head == NULL) ------------------ | Branch (104:7): [True: 0, False: 547k] ------------------ 105| 0| return NULL; 106| | 107| 547k| popped_node = queue->head; 108| 547k| queue->head = popped_node->next; 109| | 110| 547k| if (queue->head) ------------------ | Branch (110:7): [True: 547k, False: 111] ------------------ 111| 547k| queue->head->previous = NULL; 112| 111| else // queue is empty 113| 111| queue->tail = NULL; 114| | 115| 547k| result = popped_node->value; 116| | 117| 547k| yr_free(popped_node); 118| 547k| return result; 119| 547k|} ahocorasick.c:_yr_ac_optimize_failure_links: 364| 132|{ 365| 132| QUEUE queue = {NULL, NULL}; 366| | 367| | // Push root's children. 368| 132| YR_AC_STATE* root_state = automaton->root; 369| 132| YR_AC_STATE* state = root_state->first_child; 370| | 371| 699| while (state != NULL) ------------------ | Branch (371:10): [True: 567, False: 132] ------------------ 372| 567| { 373| 567| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 131| 567| { \ | | 132| 567| int __error = (x); \ | | 133| 567| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 567|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 567] | | ------------------ | | 134| 567| return __error; \ | | 135| 567| } ------------------ 374| 567| state = state->siblings; 375| 567| } 376| | 377| 182k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (377:10): [True: 182k, False: 132] ------------------ 378| 182k| { 379| 182k| YR_AC_STATE* current_state = _yr_ac_queue_pop(&queue); 380| | 381| 182k| if (current_state->failure != root_state) ------------------ | Branch (381:9): [True: 120k, False: 61.7k] ------------------ 382| 120k| { 383| 120k| if (_yr_ac_transitions_subset(current_state, current_state->failure)) ------------------ | Branch (383:11): [True: 5.09k, False: 115k] ------------------ 384| 5.09k| current_state->failure = current_state->failure->failure; 385| 120k| } 386| | 387| | // Push children of current_state 388| 182k| state = current_state->first_child; 389| | 390| 364k| while (state != NULL) ------------------ | Branch (390:12): [True: 181k, False: 182k] ------------------ 391| 181k| { 392| 181k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 131| 181k| { \ | | 132| 181k| int __error = (x); \ | | 133| 181k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 181k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 181k] | | ------------------ | | 134| 181k| return __error; \ | | 135| 181k| } ------------------ 393| 181k| state = state->siblings; 394| 181k| } 395| 182k| } 396| | 397| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 398| 132|} ahocorasick.c:_yr_ac_transitions_subset: 334| 120k|{ 335| 120k| uint8_t set[32]; 336| | 337| 120k| YR_AC_STATE* state = s1->first_child; 338| | 339| 120k| memset(set, 0, 32); 340| | 341| 205k| while (state != NULL) ------------------ | Branch (341:10): [True: 84.3k, False: 120k] ------------------ 342| 84.3k| { 343| 84.3k| set[state->input / 8] |= 1 << state->input % 8; 344| 84.3k| state = state->siblings; 345| 84.3k| } 346| | 347| 120k| state = s2->first_child; 348| | 349| 136k| while (state != NULL) ------------------ | Branch (349:10): [True: 131k, False: 5.09k] ------------------ 350| 131k| { 351| 131k| if (!(set[state->input / 8] & 1 << state->input % 8)) ------------------ | Branch (351:9): [True: 115k, False: 15.3k] ------------------ 352| 115k| return false; 353| | 354| 15.3k| state = state->siblings; 355| 15.3k| } 356| | 357| 5.09k| return true; 358| 120k|} ahocorasick.c:_yr_ac_build_transition_table: 526| 132|{ 527| 132| YR_AC_TRANSITION* t_table; 528| 132| uint32_t* m_table; 529| 132| YR_AC_STATE* state; 530| 132| YR_AC_STATE* child_state; 531| 132| YR_AC_STATE* root_state = automaton->root; 532| | 533| 132| uint32_t slot; 534| | 535| 132| 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| 132| automaton->tables_size = 512; 540| | 541| 132| automaton->bitmask = yr_calloc( 542| 132| YR_BITMASK_SIZE(automaton->tables_size), sizeof(YR_BITMASK)); ------------------ | | 57| 132|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 132|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 543| | 544| 132| if (automaton->bitmask == NULL) ------------------ | Branch (544:7): [True: 0, False: 132] ------------------ 545| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 546| | 547| 132| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 548| 132| automaton->arena, 549| 132| YR_AC_TRANSITION_TABLE, 550| 132| automaton->tables_size * sizeof(YR_AC_TRANSITION), 551| 132| NULL)); 552| | 553| 132| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 554| 132| automaton->arena, 555| 132| YR_AC_STATE_MATCHES_TABLE, 556| 132| automaton->tables_size * sizeof(uint32_t), 557| 132| NULL)); 558| | 559| 132| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 132|#define YR_AC_TRANSITION_TABLE 8 ------------------ 560| 132| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 132|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 561| | 562| | // The failure link for the root node points to itself. 563| 132| t_table[0] = YR_AC_MAKE_TRANSITION(0, 0); ------------------ | | 50| 132| ((YR_AC_TRANSITION)( \ | | 51| 132| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 132|#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| 132| if (!YR_ARENA_IS_NULL_REF(root_state->matches_ref)) ------------------ | | 46| 132| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 132| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 132| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ ------------------ | Branch (570:7): [True: 7, False: 125] ------------------ 571| 7| 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| 132| yr_bitmask_set(automaton->bitmask, 0); ------------------ | | 60| 132| do \ | | 61| 132| { \ | | 62| 132| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 132|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 132|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 132| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 575| | 576| | // Index 0 is for root node. Unused indexes start at 1. 577| 132| automaton->t_table_unused_candidate = 1; 578| | 579| 132| child_state = root_state->first_child; 580| | 581| 699| while (child_state != NULL) ------------------ | Branch (581:10): [True: 567, False: 132] ------------------ 582| 567| { 583| | // Each state stores its slot number. 584| 567| child_state->t_table_slot = child_state->input + 1; 585| | 586| 567| t_table[child_state->input + 1] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 567| ((YR_AC_TRANSITION)( \ | | 51| 567| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 567|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 587| 567| 0, child_state->input + 1); 588| | 589| 567| yr_bitmask_set(automaton->bitmask, child_state->input + 1); ------------------ | | 60| 567| do \ | | 61| 567| { \ | | 62| 567| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 567|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 567|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 567| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 590| | 591| 567| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 131| 567| { \ | | 132| 567| int __error = (x); \ | | 133| 567| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 567|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 567] | | ------------------ | | 134| 567| return __error; \ | | 135| 567| } ------------------ 592| 567| child_state = child_state->siblings; 593| 567| } 594| | 595| 182k| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (595:10): [True: 182k, False: 132] ------------------ 596| 182k| { 597| 182k| state = _yr_ac_queue_pop(&queue); 598| | 599| 182k| FAIL_ON_ERROR(_yr_ac_find_suitable_transition_table_slot( ------------------ | | 131| 182k| { \ | | 132| 182k| int __error = (x); \ | | 133| 182k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 182k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 182k] | | ------------------ | | 134| 182k| return __error; \ | | 135| 182k| } ------------------ 600| 182k| 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| 182k| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 182k|#define YR_AC_TRANSITION_TABLE 8 ------------------ 606| 182k| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 182k|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 607| | 608| 182k| t_table[state->t_table_slot] |= (slot << YR_AC_SLOT_OFFSET_BITS); ------------------ | | 39| 182k|#define YR_AC_SLOT_OFFSET_BITS 9 ------------------ 609| 182k| t_table[slot] = YR_AC_MAKE_TRANSITION(state->failure->t_table_slot, 0); ------------------ | | 50| 182k| ((YR_AC_TRANSITION)( \ | | 51| 182k| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 182k|#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| 182k| if (YR_ARENA_IS_NULL_REF(state->matches_ref)) ------------------ | | 46| 182k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 182k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 182k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | | Branch (46:3): [True: 58.8k, False: 123k] | | ------------------ ------------------ 616| 58.8k| m_table[slot] = 0; 617| 123k| else 618| 123k| m_table[slot] = state->matches_ref.offset / sizeof(YR_AC_MATCH) + 1; 619| | 620| 182k| state->t_table_slot = slot; 621| | 622| 182k| yr_bitmask_set(automaton->bitmask, slot); ------------------ | | 60| 182k| do \ | | 61| 182k| { \ | | 62| 182k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 182k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 623| | 624| | // Push children of current_state 625| 182k| child_state = state->first_child; 626| | 627| 364k| while (child_state != NULL) ------------------ | Branch (627:12): [True: 181k, False: 182k] ------------------ 628| 181k| { 629| 181k| child_state->t_table_slot = slot + child_state->input + 1; 630| | 631| 181k| t_table[child_state->t_table_slot] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 181k| ((YR_AC_TRANSITION)( \ | | 51| 181k| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 181k|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 632| 181k| 0, child_state->input + 1); 633| | 634| 181k| yr_bitmask_set(automaton->bitmask, child_state->t_table_slot); ------------------ | | 60| 181k| do \ | | 61| 181k| { \ | | 62| 181k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 181k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 181k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 181k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 635| | 636| 181k| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 131| 181k| { \ | | 132| 181k| int __error = (x); \ | | 133| 181k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 181k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 181k] | | ------------------ | | 134| 181k| return __error; \ | | 135| 181k| } ------------------ 637| | 638| 181k| child_state = child_state->siblings; 639| 181k| } 640| 182k| } 641| | 642| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 643| 132|} ahocorasick.c:_yr_ac_find_suitable_transition_table_slot: 411| 182k|{ 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| 182k| YR_BITMASK state_bitmask[YR_BITMASK_SIZE(257)]; ------------------ | | 54| 182k|#define YR_BITMASK unsigned long ------------------ 415| | 416| 182k| YR_AC_STATE* child_state = state->first_child; 417| | 418| | // Start with all bits set to zero. 419| 182k| yr_bitmask_clear_all(state_bitmask); ------------------ | | 72| 182k|#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| 182k| yr_bitmask_set(state_bitmask, 0); ------------------ | | 60| 182k| do \ | | 61| 182k| { \ | | 62| 182k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 182k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 424| | 425| 364k| while (child_state != NULL) ------------------ | Branch (425:10): [True: 181k, False: 182k] ------------------ 426| 181k| { 427| 181k| yr_bitmask_set(state_bitmask, child_state->input + 1); ------------------ | | 60| 181k| do \ | | 61| 181k| { \ | | 62| 181k| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 181k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 181k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 181k| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 428| 181k| child_state = child_state->siblings; 429| 181k| } 430| | 431| 182k| *slot = yr_bitmask_find_non_colliding_offset( 432| 182k| automaton->bitmask, 433| 182k| state_bitmask, 434| 182k| automaton->tables_size, 435| 182k| 257, 436| 182k| &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| 182k| assert(*slot + 257 < YR_AC_MAX_TRANSITION_TABLE_SIZE); 442| | 443| 182k| if (*slot > automaton->tables_size - 257) ------------------ | Branch (443:7): [True: 1.40k, False: 181k] ------------------ 444| 1.40k| { 445| 1.40k| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 131| 1.40k| { \ | | 132| 1.40k| int __error = (x); \ | | 133| 1.40k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.40k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.40k] | | ------------------ | | 134| 1.40k| return __error; \ | | 135| 1.40k| } ------------------ 446| 1.40k| arena, YR_AC_TRANSITION_TABLE, 257 * sizeof(YR_AC_TRANSITION), NULL)); 447| | 448| 1.40k| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 131| 1.40k| { \ | | 132| 1.40k| int __error = (x); \ | | 133| 1.40k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.40k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.40k] | | ------------------ | | 134| 1.40k| return __error; \ | | 135| 1.40k| } ------------------ 449| 1.40k| arena, YR_AC_STATE_MATCHES_TABLE, 257 * sizeof(uint8_t*), NULL)); 450| | 451| 1.40k| size_t bm_len = YR_BITMASK_SIZE(automaton->tables_size) * ------------------ | | 57| 1.40k|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1.40k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 452| 1.40k| sizeof(YR_BITMASK); 453| | 454| 1.40k| size_t bm_len_incr = YR_BITMASK_SIZE(257) * sizeof(YR_BITMASK); ------------------ | | 57| 1.40k|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1.40k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 455| | 456| 1.40k| automaton->bitmask = yr_realloc(automaton->bitmask, bm_len + bm_len_incr); 457| | 458| 1.40k| if (automaton->bitmask == NULL) ------------------ | Branch (458:9): [True: 0, False: 1.40k] ------------------ 459| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 460| | 461| 1.40k| memset((uint8_t*) automaton->bitmask + bm_len, 0, bm_len_incr); 462| | 463| 1.40k| automaton->tables_size += 257; 464| 1.40k| } 465| | 466| 182k| return ERROR_SUCCESS; ------------------ | | 40| 182k|#define ERROR_SUCCESS 0 ------------------ 467| 182k|} yr_arena_create: 237| 1.27k|{ 238| 1.27k| YR_ARENA* new_arena = (YR_ARENA*) yr_calloc(1, sizeof(YR_ARENA)); 239| | 240| 1.27k| if (new_arena == NULL) ------------------ | Branch (240:7): [True: 0, False: 1.27k] ------------------ 241| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 242| | 243| 1.27k| new_arena->xrefs = 1; 244| 1.27k| new_arena->num_buffers = num_buffers; 245| 1.27k| new_arena->initial_buffer_size = initial_buffer_size; 246| | 247| 1.27k| *arena = new_arena; 248| | 249| 1.27k| return ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 250| 1.27k|} yr_arena_acquire: 253| 132|{ 254| 132| arena->xrefs++; 255| 132|} yr_arena_release: 272| 1.40k|{ 273| 1.40k| arena->xrefs--; 274| | 275| 1.40k| if (arena->xrefs > 0) ------------------ | Branch (275:7): [True: 132, False: 1.27k] ------------------ 276| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 277| | 278| 16.5k| for (uint32_t i = 0; i < arena->num_buffers; i++) ------------------ | Branch (278:24): [True: 15.2k, False: 1.27k] ------------------ 279| 15.2k| { 280| 15.2k| if (arena->buffers[i].data != NULL) ------------------ | Branch (280:9): [True: 6.51k, False: 8.72k] ------------------ 281| 6.51k| yr_free(arena->buffers[i].data); 282| 15.2k| } 283| | 284| 1.27k| YR_RELOC* reloc = arena->reloc_list_head; 285| | 286| 22.2M| while (reloc != NULL) ------------------ | Branch (286:10): [True: 22.2M, False: 1.27k] ------------------ 287| 22.2M| { 288| 22.2M| YR_RELOC* next = reloc->next; 289| 22.2M| yr_free(reloc); 290| 22.2M| reloc = next; 291| 22.2M| } 292| | 293| 1.27k| yr_free(arena); 294| | 295| 1.27k| return ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 296| 1.40k|} yr_arena_allocate_zeroed_memory: 342| 3.07k|{ 343| 3.07k| return _yr_arena_allocate_memory( 344| 3.07k| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, ref); ------------------ | | 114| 3.07k|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 345| 3.07k|} yr_arena_allocate_struct: 386| 5.27M|{ 387| 5.27M| YR_ARENA_REF r; 388| | 389| 5.27M| int result = _yr_arena_allocate_memory( 390| 5.27M| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, &r); ------------------ | | 114| 5.27M|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 391| | 392| 5.27M| if (result != ERROR_SUCCESS) ------------------ | | 40| 5.27M|#define ERROR_SUCCESS 0 ------------------ | Branch (392:7): [True: 0, False: 5.27M] ------------------ 393| 0| return result; 394| | 395| 5.27M| va_list field_offsets; 396| 5.27M| va_start(field_offsets, ref); 397| | 398| 5.27M| result = _yr_arena_make_ptr_relocatable( 399| 5.27M| arena, buffer_id, r.offset, field_offsets); 400| | 401| 5.27M| va_end(field_offsets); 402| | 403| 5.27M| if (result == ERROR_SUCCESS && ref != NULL) ------------------ | | 40| 10.5M|#define ERROR_SUCCESS 0 ------------------ | Branch (403:7): [True: 5.27M, False: 0] | Branch (403:34): [True: 5.27M, False: 0] ------------------ 404| 5.27M| { 405| 5.27M| ref->buffer_id = r.buffer_id; 406| 5.27M| ref->offset = r.offset; 407| 5.27M| } 408| | 409| 5.27M| return result; 410| 5.27M|} yr_arena_get_ptr: 416| 28.5M|{ 417| 28.5M| assert(buffer_id < arena->num_buffers); 418| 28.5M| assert(offset <= arena->buffers[buffer_id].used); 419| | 420| 28.5M| if (arena->buffers[buffer_id].data == NULL) ------------------ | Branch (420:7): [True: 1.46k, False: 28.5M] ------------------ 421| 1.46k| return NULL; 422| | 423| 28.5M| return arena->buffers[buffer_id].data + offset; 424| 28.5M|} yr_arena_get_current_offset: 427| 9.94M|{ 428| 9.94M| assert(buffer_id < arena->num_buffers); 429| | 430| 9.94M| return (yr_arena_off_t) arena->buffers[buffer_id].used; 431| 9.94M|} yr_arena_ptr_to_ref: 434| 3.10k|{ 435| 3.10k| *ref = YR_ARENA_NULL_REF; ------------------ | | 43| 3.10k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 436| | 437| 3.10k| if (address == NULL) ------------------ | Branch (437:7): [True: 0, False: 3.10k] ------------------ 438| 0| return 1; 439| | 440| 18.6k| for (uint32_t i = 0; i < arena->num_buffers; ++i) ------------------ | Branch (440:24): [True: 18.6k, False: 0] ------------------ 441| 18.6k| { 442| | // If the buffer is completetly empty, skip it. 443| 18.6k| if (arena->buffers[i].data == NULL) ------------------ | Branch (443:9): [True: 9.19k, False: 9.46k] ------------------ 444| 9.19k| 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| 9.46k| if ((uint8_t*) address >= arena->buffers[i].data && ------------------ | Branch (448:9): [True: 6.34k, False: 3.11k] ------------------ 449| 9.46k| (uint8_t*) address < arena->buffers[i].data + arena->buffers[i].used) ------------------ | Branch (449:9): [True: 3.10k, False: 3.24k] ------------------ 450| 3.10k| { 451| 3.10k| ref->buffer_id = i; 452| 3.10k| ref->offset = 453| 3.10k| (yr_arena_off_t) ((uint8_t*) address - arena->buffers[i].data); 454| | 455| 3.10k| return 1; 456| 3.10k| } 457| 9.46k| } 458| | 459| 0| return 0; 460| 3.10k|} yr_arena_ref_to_ptr: 463| 23.8M|{ 464| 23.8M| if (YR_ARENA_IS_NULL_REF(*ref)) ------------------ | | 46| 23.8M| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 23.8M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 23.8M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | | Branch (46:3): [True: 947k, False: 22.8M] | | ------------------ ------------------ 465| 947k| 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| 22.8M| return yr_arena_get_ptr(arena, ref->buffer_id, ref->offset); 474| 23.8M|} yr_arena_make_ptr_relocatable: 488| 1.12M|{ 489| 1.12M| int result; 490| | 491| 1.12M| va_list offsets; 492| 1.12M| va_start(offsets, buffer_id); 493| | 494| 1.12M| result = _yr_arena_make_ptr_relocatable(arena, buffer_id, 0, offsets); 495| | 496| 1.12M| va_end(offsets); 497| | 498| 1.12M| return result; 499| 1.12M|} yr_arena_write_data: 507| 55.7M|{ 508| 55.7M| YR_ARENA_REF r; 509| | 510| | // Allocate space in the buffer. 511| 55.7M| FAIL_ON_ERROR(_yr_arena_allocate_memory(arena, 0, buffer_id, size, &r)); ------------------ | | 131| 55.7M| { \ | | 132| 55.7M| int __error = (x); \ | | 133| 55.7M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 55.7M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 55.7M] | | ------------------ | | 134| 55.7M| return __error; \ | | 135| 55.7M| } ------------------ 512| | 513| | // Copy the data into the allocated space. 514| 55.7M| memcpy(arena->buffers[buffer_id].data + r.offset, data, size); 515| | 516| 55.7M| if (ref != NULL) ------------------ | Branch (516:7): [True: 28.0M, False: 27.7M] ------------------ 517| 28.0M| { 518| 28.0M| ref->buffer_id = r.buffer_id; 519| 28.0M| ref->offset = r.offset; 520| 28.0M| } 521| | 522| 55.7M| return ERROR_SUCCESS; ------------------ | | 40| 55.7M|#define ERROR_SUCCESS 0 ------------------ 523| 55.7M|} yr_arena_write_string: 530| 229|{ 531| 229| return yr_arena_write_data(arena, buffer_id, string, strlen(string) + 1, ref); 532| 229|} arena.c:_yr_arena_allocate_memory: 138| 61.0M|{ 139| 61.0M| if (buffer_id > arena->num_buffers) ------------------ | Branch (139:7): [True: 0, False: 61.0M] ------------------ 140| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 74| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 141| | 142| 61.0M| 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| 61.0M| if (b->size - b->used < size) ------------------ | Branch (148:7): [True: 6.58k, False: 61.0M] ------------------ 149| 6.58k| { 150| 6.58k| size_t new_size = (b->size == 0) ? arena->initial_buffer_size : b->size * 2; ------------------ | Branch (150:23): [True: 6.51k, False: 77] ------------------ 151| | 152| 6.58k| while (new_size < b->used + size) new_size *= 2; ------------------ | Branch (152:12): [True: 0, False: 6.58k] ------------------ 153| | 154| | // Make sure that buffer size if not larger than 4GB. 155| 6.58k| if (new_size > 1ULL << 32) ------------------ | Branch (155:9): [True: 0, False: 6.58k] ------------------ 156| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 157| | 158| 6.58k| uint8_t* new_data = yr_realloc(b->data, new_size); 159| | 160| 6.58k| if (new_data == NULL) ------------------ | Branch (160:9): [True: 0, False: 6.58k] ------------------ 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| 6.58k|#if !defined(_WIN32) && !defined(__CYGWIN__) 167| 6.58k| if (flags & YR_ARENA_ZERO_MEMORY) ------------------ | | 114| 6.58k|#define YR_ARENA_ZERO_MEMORY 1 ------------------ | Branch (167:9): [True: 3.62k, False: 2.96k] ------------------ 168| 3.62k| memset(new_data + b->used, 0, new_size - b->used); 169| 6.58k|#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| 6.58k| if (b->data != NULL && b->data != new_data) ------------------ | Branch (173:9): [True: 77, False: 6.51k] | Branch (173:28): [True: 74, False: 3] ------------------ 174| 74| { 175| 74| YR_RELOC* reloc = arena->reloc_list_head; 176| | 177| 30.9M| while (reloc != NULL) ------------------ | Branch (177:14): [True: 30.9M, False: 74] ------------------ 178| 30.9M| { 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| 30.9M| uint8_t* base = buffer_id == reloc->buffer_id ------------------ | Branch (183:25): [True: 30.8M, False: 62.3k] ------------------ 184| 30.9M| ? new_data 185| 30.9M| : 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| 30.9M| void** reloc_address = (void**) (base + reloc->offset); 190| | 191| | // reloc_target is the value of the relocatable pointer. 192| 30.9M| void* reloc_target = *reloc_address; 193| | 194| 30.9M| if ((uint8_t*) reloc_target >= b->data && ------------------ | Branch (194:13): [True: 8.68M, False: 22.2M] ------------------ 195| 30.9M| (uint8_t*) reloc_target < b->data + b->used) ------------------ | Branch (195:13): [True: 6.97M, False: 1.71M] ------------------ 196| 6.97M| { 197| | // reloc_target points to some data inside the buffer being moved, so 198| | // the pointer needs to be adjusted. 199| 6.97M| *reloc_address = (uint8_t*) reloc_target - b->data + new_data; 200| 6.97M| } 201| | 202| 30.9M| reloc = reloc->next; 203| 30.9M| } 204| 74| } 205| | 206| 6.58k| b->size = new_size; 207| 6.58k| b->data = new_data; 208| 6.58k| } 209| | 210| 61.0M| if (ref != NULL) ------------------ | Branch (210:7): [True: 61.0M, False: 3.07k] ------------------ 211| 61.0M| { 212| 61.0M| ref->buffer_id = buffer_id; 213| 61.0M| ref->offset = (uint32_t) b->used; 214| 61.0M| } 215| | 216| 61.0M| b->used += size; 217| | 218| 61.0M| return ERROR_SUCCESS; ------------------ | | 40| 61.0M|#define ERROR_SUCCESS 0 ------------------ 219| 61.0M|} arena.c:_yr_arena_make_ptr_relocatable: 80| 6.40M|{ 81| 6.40M| size_t offset; 82| | 83| 6.40M| int result = ERROR_SUCCESS; ------------------ | | 40| 6.40M|#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| 6.40M| offset = va_arg(offsets, size_t); 88| | 89| 28.6M| while (offset != EOL) ------------------ | | 38| 28.6M|#define EOL ((size_t) -1) ------------------ | Branch (89:10): [True: 22.2M, False: 6.40M] ------------------ 90| 22.2M| { 91| 22.2M| YR_RELOC* reloc = (YR_RELOC*) yr_malloc(sizeof(YR_RELOC)); 92| | 93| 22.2M| if (reloc == NULL) ------------------ | Branch (93:9): [True: 0, False: 22.2M] ------------------ 94| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 95| | 96| 22.2M| reloc->buffer_id = buffer_id; 97| 22.2M| reloc->offset = base_offset + (yr_arena_off_t) offset; 98| 22.2M| reloc->next = NULL; 99| | 100| 22.2M| if (arena->reloc_list_head == NULL) ------------------ | Branch (100:9): [True: 1.27k, False: 22.2M] ------------------ 101| 1.27k| arena->reloc_list_head = reloc; 102| | 103| 22.2M| if (arena->reloc_list_tail != NULL) ------------------ | Branch (103:9): [True: 22.2M, False: 1.27k] ------------------ 104| 22.2M| arena->reloc_list_tail->next = reloc; 105| | 106| 22.2M| arena->reloc_list_tail = reloc; 107| 22.2M| offset = va_arg(offsets, size_t); 108| 22.2M| } 109| | 110| 6.40M| return result; 111| 6.40M|} yr_atoms_heuristic_quality: 107| 1.31M|{ 108| 1.31M| YR_BITMASK seen_bytes[YR_BITMASK_SIZE(256)]; ------------------ | | 54| 1.31M|#define YR_BITMASK unsigned long ------------------ 109| | 110| 1.31M| int quality = 0; 111| 1.31M| int unique_bytes = 0; 112| | 113| 1.31M| assert(atom->length <= YR_MAX_ATOM_LENGTH); 114| | 115| 1.31M| yr_bitmask_clear_all(seen_bytes); ------------------ | | 72| 1.31M|#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| 6.07M| for (int i = 0; i < atom->length; i++) ------------------ | Branch (136:19): [True: 4.75M, False: 1.31M] ------------------ 137| 4.75M| { 138| 4.75M| switch (atom->mask[i]) ------------------ | Branch (138:13): [True: 0, False: 4.75M] ------------------ 139| 4.75M| { 140| 8.76k| case 0x00: ------------------ | Branch (140:5): [True: 8.76k, False: 4.74M] ------------------ 141| 8.76k| quality -= 10; 142| 8.76k| break; 143| 866| case 0x0F: ------------------ | Branch (143:5): [True: 866, False: 4.75M] ------------------ 144| 866| quality += 4; 145| 866| break; 146| 1.11k| case 0xF0: ------------------ | Branch (146:5): [True: 1.11k, False: 4.75M] ------------------ 147| 1.11k| quality += 4; 148| 1.11k| break; 149| 4.74M| case 0xFF: ------------------ | Branch (149:5): [True: 4.74M, False: 10.7k] ------------------ 150| 4.74M| switch (atom->bytes[i]) 151| 4.74M| { 152| 1.71M| case 0x00: ------------------ | Branch (152:7): [True: 1.71M, False: 3.03M] ------------------ 153| 1.71M| case 0x20: ------------------ | Branch (153:7): [True: 2.93k, False: 4.74M] ------------------ 154| 1.71M| case 0xCC: ------------------ | Branch (154:7): [True: 2.15k, False: 4.74M] ------------------ 155| 1.74M| case 0xFF: ------------------ | Branch (155:7): [True: 22.0k, False: 4.72M] ------------------ 156| | // Common bytes contribute less to the quality than the rest. 157| 1.74M| quality += 12; 158| 1.74M| break; 159| 3.00M| default: ------------------ | Branch (159:7): [True: 3.00M, False: 1.74M] ------------------ 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| 3.00M| if (yr_lowercase[atom->bytes[i]] >= 'a' && ------------------ | Branch (164:13): [True: 2.56M, False: 441k] ------------------ 165| 3.00M| yr_lowercase[atom->bytes[i]] <= 'z') ------------------ | Branch (165:13): [True: 2.13M, False: 428k] ------------------ 166| 2.13M| quality += 18; 167| 870k| else 168| 870k| quality += 20; 169| 4.74M| } 170| | 171| 4.74M| if (!yr_bitmask_is_set(seen_bytes, atom->bytes[i])) ------------------ | | 75| 4.74M| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 4.74M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 4.74M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ | Branch (171:11): [True: 3.47M, False: 1.27M] ------------------ 172| 3.47M| { 173| 3.47M| yr_bitmask_set(seen_bytes, atom->bytes[i]); ------------------ | | 60| 3.47M| do \ | | 61| 3.47M| { \ | | 62| 3.47M| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 3.47M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 3.47M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 3.47M| } while (0) | | ------------------ | | | Branch (63:12): [Folded - Ignored] | | ------------------ ------------------ 174| 3.47M| unique_bytes++; 175| 3.47M| } 176| 4.75M| } 177| 4.75M| } 178| | 179| | // If all the bytes in the atom are equal and very common, let's penalize 180| | // it heavily. 181| 1.31M| if (unique_bytes == 1 && (yr_bitmask_is_set(seen_bytes, 0x00) || ------------------ | | 75| 352k| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 176k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 176k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 344, False: 176k] | | ------------------ ------------------ | Branch (181:7): [True: 176k, False: 1.13M] ------------------ 182| 176k| yr_bitmask_is_set(seen_bytes, 0x20) || ------------------ | | 75| 352k| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 176k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 176k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 833, False: 175k] | | ------------------ ------------------ 183| 176k| yr_bitmask_is_set(seen_bytes, 0x90) || ------------------ | | 75| 351k| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 175k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 175k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 390, False: 174k] | | ------------------ ------------------ 184| 176k| yr_bitmask_is_set(seen_bytes, 0xCC) || ------------------ | | 75| 351k| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 174k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 174k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 385, False: 174k] | | ------------------ ------------------ 185| 176k| yr_bitmask_is_set(seen_bytes, 0xFF))) ------------------ | | 75| 174k| ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 174k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | ((bm)[(i) / YR_BITMASK_SLOT_BITS] & (1UL << ((i) % YR_BITMASK_SLOT_BITS))) | | ------------------ | | | | 56| 174k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | | Branch (75:3): [True: 4.43k, False: 170k] | | ------------------ ------------------ 186| 6.38k| { 187| 6.38k| quality -= 10 * atom->length; 188| 6.38k| } 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| 1.30M| else 192| 1.30M| { 193| 1.30M| quality += 2 * unique_bytes; 194| 1.30M| } 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| 1.31M| return YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + quality; ------------------ | | 72| 1.31M|#define YR_MAX_ATOM_QUALITY 255 ------------------ return YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + quality; ------------------ | | 68| 1.31M|#define YR_MAX_ATOM_LENGTH 4 ------------------ 202| 1.31M|} yr_atoms_list_destroy: 410| 55.3k|{ 411| 55.3k| YR_ATOM_LIST_ITEM* item = list_head; 412| 55.3k| YR_ATOM_LIST_ITEM* next; 413| | 414| 5.31M| while (item != NULL) ------------------ | Branch (414:10): [True: 5.25M, False: 55.3k] ------------------ 415| 5.25M| { 416| 5.25M| next = item->next; 417| 5.25M| yr_free(item); 418| 5.25M| item = next; 419| 5.25M| } 420| 55.3k|} _yr_atoms_trim: 458| 1.01M|{ 459| 1.01M| int mask_00 = 0; 460| 1.01M| int mask_ff = 0; 461| | 462| 1.01M| int trim_left = 0; 463| | 464| 1.01M| while (trim_left < atom->length && atom->mask[trim_left] == 0) trim_left++; ------------------ | Branch (464:10): [True: 1.01M, False: 2.23k] | Branch (464:38): [True: 3.89k, False: 1.00M] ------------------ 465| | 466| 1.01M| while (atom->length > trim_left && atom->mask[atom->length - 1] == 0) ------------------ | Branch (466:10): [True: 1.00M, False: 2.23k] | Branch (466:38): [True: 1.87k, False: 1.00M] ------------------ 467| 1.87k| atom->length--; 468| | 469| 1.01M| atom->length -= trim_left; 470| | 471| 1.01M| if (atom->length == 0) ------------------ | Branch (471:7): [True: 2.23k, False: 1.00M] ------------------ 472| 2.23k| 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| 4.99M| for (int i = 0; i < atom->length; i++) ------------------ | Branch (479:19): [True: 3.99M, False: 1.00M] ------------------ 480| 3.99M| { 481| 3.99M| if (atom->mask[trim_left + i] == 0xFF) ------------------ | Branch (481:9): [True: 3.98M, False: 11.5k] ------------------ 482| 3.98M| mask_ff++; 483| 11.5k| else if (atom->mask[trim_left + i] == 0x00) ------------------ | Branch (483:14): [True: 8.84k, False: 2.71k] ------------------ 484| 8.84k| mask_00++; 485| 3.99M| } 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| 1.00M| if (mask_00 >= mask_ff) ------------------ | Branch (496:7): [True: 1.73k, False: 1.00M] ------------------ 497| 1.73k| atom->length = 1; 498| | 499| 1.00M| if (trim_left == 0) ------------------ | Branch (499:7): [True: 1.00M, False: 2.30k] ------------------ 500| 1.00M| return 0; 501| | 502| | // Shift bytes and mask trim_left positions to the left. 503| | 504| 9.12k| for (int i = 0; i < YR_MAX_ATOM_LENGTH - trim_left; i++) ------------------ | | 68| 9.12k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (504:19): [True: 6.82k, False: 2.30k] ------------------ 505| 6.82k| { 506| 6.82k| atom->bytes[i] = atom->bytes[trim_left + i]; 507| 6.82k| atom->mask[i] = atom->mask[trim_left + i]; 508| 6.82k| } 509| | 510| 2.30k| return trim_left; 511| 1.00M|} yr_atoms_extract_from_re: 1281| 7.09k|{ 1282| 7.09k| YR_ATOM_TREE* atom_tree = (YR_ATOM_TREE*) yr_malloc(sizeof(YR_ATOM_TREE)); 1283| | 1284| 7.09k| YR_ATOM_LIST_ITEM* wide_atoms; 1285| 7.09k| YR_ATOM_LIST_ITEM* case_insensitive_atoms; 1286| | 1287| 7.09k| if (atom_tree == NULL) ------------------ | Branch (1287:7): [True: 0, False: 7.09k] ------------------ 1288| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1289| | 1290| 7.09k| atom_tree->root_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 7.09k|#define ATOM_TREE_OR 3 ------------------ 1291| | 1292| 7.09k| if (atom_tree->root_node == NULL) ------------------ | Branch (1292:7): [True: 0, False: 7.09k] ------------------ 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| 7.09k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 7.09k| { \ | | 140| 7.09k| int __error = (x); \ | | 141| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 7.09k] | | ------------------ | | 142| 7.09k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 7.09k| } ------------------ 1299| 7.09k| _yr_atoms_extract_from_re(config, re_ast, atom_tree->root_node), 1300| 7.09k| _yr_atoms_tree_destroy(atom_tree)); 1301| | 1302| | // Initialize atom list 1303| 7.09k| *atoms = NULL; 1304| | 1305| | // Choose the atoms that will be used. 1306| 7.09k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 7.09k| { \ | | 140| 7.09k| int __error = (x); \ | | 141| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 7.09k] | | ------------------ | | 142| 7.09k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 7.09k| } ------------------ 1307| 7.09k| _yr_atoms_choose(config, atom_tree->root_node, atoms, min_atom_quality), 1308| 7.09k| _yr_atoms_tree_destroy(atom_tree)); 1309| | 1310| 7.09k| _yr_atoms_tree_destroy(atom_tree); 1311| | 1312| 7.09k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 7.09k| { \ | | 140| 7.09k| int __error = (x); \ | | 141| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 7.09k] | | ------------------ | | 142| 7.09k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 7.09k| } ------------------ 1313| 7.09k| _yr_atoms_expand_wildcards(*atoms), 1314| 7.09k| { // Cleanup 1315| 7.09k| yr_atoms_list_destroy(*atoms); 1316| 7.09k| *atoms = NULL; 1317| 7.09k| }); 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| 7.09k| if (modifier.flags & STRING_FLAGS_WIDE && ------------------ | | 70| 14.1k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (1322:7): [True: 1.58k, False: 5.51k] ------------------ 1323| 7.09k| !(modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 3.16k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (1323:9): [True: 375, False: 1.20k] ------------------ 1324| 1.58k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 1.20k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (1324:9): [True: 285, False: 920] ------------------ 1325| 920| { 1326| 920| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 920| { \ | | 140| 920| int __error = (x); \ | | 141| 920| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 920|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 920] | | ------------------ | | 142| 920| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 920| } ------------------ 1327| 920| _yr_atoms_wide(*atoms, &wide_atoms), 1328| 920| { // Cleanup 1329| 920| yr_atoms_list_destroy(*atoms); 1330| 920| yr_atoms_list_destroy(wide_atoms); 1331| 920| *atoms = NULL; 1332| 920| }); 1333| | 1334| 920| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 920|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (1334:9): [True: 388, False: 532] ------------------ 1335| 388| { 1336| 388| *atoms = _yr_atoms_list_concat(*atoms, wide_atoms); 1337| 388| } 1338| 532| else 1339| 532| { 1340| 532| yr_atoms_list_destroy(*atoms); 1341| 532| *atoms = wide_atoms; 1342| 532| } 1343| 920| } 1344| | 1345| 7.09k| if (modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 7.09k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (1345:7): [True: 1.25k, False: 5.83k] ------------------ 1346| 1.25k| { 1347| 1.25k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 1.25k| { \ | | 140| 1.25k| int __error = (x); \ | | 141| 1.25k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.25k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 1.25k] | | ------------------ | | 142| 1.25k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 1.25k| } ------------------ 1348| 1.25k| _yr_atoms_case_insensitive(*atoms, &case_insensitive_atoms), 1349| 1.25k| { // Cleanup 1350| 1.25k| yr_atoms_list_destroy(*atoms); 1351| 1.25k| yr_atoms_list_destroy(case_insensitive_atoms); 1352| 1.25k| *atoms = NULL; 1353| 1.25k| }); 1354| | 1355| 1.25k| *atoms = _yr_atoms_list_concat(*atoms, case_insensitive_atoms); 1356| 1.25k| } 1357| | 1358| | // No atoms has been extracted, let's add a zero-length atom. 1359| | 1360| 7.09k| if (*atoms == NULL) ------------------ | Branch (1360:7): [True: 2.09k, False: 5.00k] ------------------ 1361| 2.09k| { 1362| 2.09k| *atoms = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 1363| | 1364| 2.09k| if (*atoms == NULL) ------------------ | Branch (1364:9): [True: 0, False: 2.09k] ------------------ 1365| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1366| | 1367| 2.09k| (*atoms)->atom.length = 0; 1368| 2.09k| (*atoms)->backtrack = 0; 1369| 2.09k| (*atoms)->forward_code_ref = re_ast->root_node->forward_code_ref; 1370| 2.09k| (*atoms)->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 2.09k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 1371| 2.09k| (*atoms)->next = NULL; 1372| 2.09k| } 1373| | 1374| 7.09k| return ERROR_SUCCESS; ------------------ | | 40| 7.09k|#define ERROR_SUCCESS 0 ------------------ 1375| 7.09k|} yr_atoms_extract_from_string: 1387| 17.8k|{ 1388| 17.8k| YR_ATOM_LIST_ITEM* item; 1389| 17.8k| YR_ATOM_LIST_ITEM* case_insensitive_atoms; 1390| 17.8k| YR_ATOM_LIST_ITEM* xor_atoms; 1391| 17.8k| YR_ATOM_LIST_ITEM* wide_atoms; 1392| | 1393| 17.8k| YR_ATOM atom; 1394| | 1395| 17.8k| int quality, max_quality; 1396| 17.8k| int i; 1397| | 1398| 17.8k| item = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 1399| | 1400| 17.8k| if (item == NULL) ------------------ | Branch (1400:7): [True: 0, False: 17.8k] ------------------ 1401| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1402| | 1403| 17.8k| item->forward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 17.8k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 1404| 17.8k| item->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 17.8k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 1405| 17.8k| item->next = NULL; 1406| 17.8k| item->backtrack = 0; 1407| | 1408| 17.8k| item->atom.length = yr_min(string_length, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 17.8k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 12.1k, False: 5.65k] | | ------------------ ------------------ 1409| | 1410| 64.2k| for (i = 0; i < item->atom.length; i++) ------------------ | Branch (1410:15): [True: 46.4k, False: 17.8k] ------------------ 1411| 46.4k| { 1412| 46.4k| item->atom.bytes[i] = string[i]; 1413| 46.4k| item->atom.mask[i] = 0xFF; 1414| 46.4k| } 1415| | 1416| 17.8k| max_quality = config->get_atom_quality(config, &item->atom); 1417| | 1418| 17.8k| atom.length = YR_MAX_ATOM_LENGTH; ------------------ | | 68| 17.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1419| 17.8k| memset(atom.mask, 0xFF, atom.length); 1420| | 1421| 17.8k| for (i = YR_MAX_ATOM_LENGTH; ------------------ | | 68| 17.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1422| 74.4k| i < string_length && max_quality < YR_MAX_ATOM_QUALITY; ------------------ | | 72| 58.0k|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (1422:8): [True: 58.0k, False: 16.4k] | Branch (1422:29): [True: 56.6k, False: 1.34k] ------------------ 1423| 56.6k| i++) 1424| 56.6k| { 1425| 56.6k| atom.length = YR_MAX_ATOM_LENGTH; ------------------ | | 68| 56.6k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1426| 56.6k| memcpy(atom.bytes, string + i - YR_MAX_ATOM_LENGTH + 1, atom.length); ------------------ | | 68| 56.6k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1427| | 1428| 56.6k| quality = config->get_atom_quality(config, &atom); 1429| | 1430| 56.6k| if (quality > max_quality) ------------------ | Branch (1430:9): [True: 4.26k, False: 52.4k] ------------------ 1431| 4.26k| { 1432| 4.26k| memcpy(&item->atom, &atom, sizeof(atom)); 1433| 4.26k| item->backtrack = i - YR_MAX_ATOM_LENGTH + 1; ------------------ | | 68| 4.26k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1434| 4.26k| max_quality = quality; 1435| 4.26k| } 1436| 56.6k| } 1437| | 1438| 17.8k| *atoms = item; 1439| 17.8k| *min_atom_quality = max_quality; 1440| | 1441| 17.8k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 17.8k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (1441:7): [True: 1.49k, False: 16.3k] ------------------ 1442| 1.49k| { 1443| 1.49k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 1.49k| { \ | | 140| 1.49k| int __error = (x); \ | | 141| 1.49k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.49k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 1.49k] | | ------------------ | | 142| 1.49k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 1.49k| } ------------------ 1444| 1.49k| _yr_atoms_wide(*atoms, &wide_atoms), 1445| 1.49k| { // Cleanup 1446| 1.49k| yr_atoms_list_destroy(*atoms); 1447| 1.49k| yr_atoms_list_destroy(wide_atoms); 1448| 1.49k| *atoms = NULL; 1449| 1.49k| }); 1450| | 1451| 1.49k| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 1.49k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (1451:9): [True: 738, False: 756] ------------------ 1452| 738| { 1453| 738| *atoms = _yr_atoms_list_concat(*atoms, wide_atoms); 1454| 738| } 1455| 756| else 1456| 756| { 1457| 756| yr_atoms_list_destroy(*atoms); 1458| 756| *atoms = wide_atoms; 1459| 756| } 1460| 1.49k| } 1461| | 1462| 17.8k| if (modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 17.8k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (1462:7): [True: 4.02k, False: 13.8k] ------------------ 1463| 4.02k| { 1464| 4.02k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 4.02k| { \ | | 140| 4.02k| int __error = (x); \ | | 141| 4.02k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.02k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 4.02k] | | ------------------ | | 142| 4.02k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 4.02k| } ------------------ 1465| 4.02k| _yr_atoms_case_insensitive(*atoms, &case_insensitive_atoms), 1466| 4.02k| { // Cleanup 1467| 4.02k| yr_atoms_list_destroy(*atoms); 1468| 4.02k| yr_atoms_list_destroy(case_insensitive_atoms); 1469| 4.02k| *atoms = NULL; 1470| 4.02k| }); 1471| | 1472| 4.02k| *atoms = _yr_atoms_list_concat(*atoms, case_insensitive_atoms); 1473| 4.02k| } 1474| | 1475| 17.8k| if (modifier.flags & STRING_FLAGS_XOR) ------------------ | | 85| 17.8k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (1475:7): [True: 989, False: 16.8k] ------------------ 1476| 989| { 1477| 989| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 989| { \ | | 140| 989| int __error = (x); \ | | 141| 989| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 989|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 989] | | ------------------ | | 142| 989| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 989| } ------------------ 1478| 989| _yr_atoms_xor(*atoms, modifier.xor_min, modifier.xor_max, &xor_atoms), 1479| 989| { // Cleanup 1480| 989| yr_atoms_list_destroy(*atoms); 1481| 989| yr_atoms_list_destroy(xor_atoms); 1482| 989| *atoms = NULL; 1483| 989| }); 1484| | 1485| 989| yr_atoms_list_destroy(*atoms); 1486| 989| *atoms = xor_atoms; 1487| 989| } 1488| | 1489| | // Recheck the atom quality, in case we have just generated some poor atoms. 1490| | // https://github.com/VirusTotal/yara/issues/1172 1491| 249k| for (item = *atoms; item != NULL; item = item->next) ------------------ | Branch (1491:23): [True: 231k, False: 17.8k] ------------------ 1492| 231k| { 1493| 231k| quality = config->get_atom_quality(config, &item->atom); 1494| 231k| if (quality < *min_atom_quality) ------------------ | Branch (1494:9): [True: 1.70k, False: 229k] ------------------ 1495| 1.70k| *min_atom_quality = quality; 1496| 231k| } 1497| | 1498| 17.8k| return ERROR_SUCCESS; ------------------ | | 40| 17.8k|#define ERROR_SUCCESS 0 ------------------ 1499| 17.8k|} atoms.c:_yr_atoms_tree_node_create: 339| 58.8k|{ 340| 58.8k| YR_ATOM_TREE_NODE* new_node = (YR_ATOM_TREE_NODE*) yr_malloc( 341| 58.8k| sizeof(YR_ATOM_TREE_NODE)); 342| | 343| 58.8k| if (new_node != NULL) ------------------ | Branch (343:7): [True: 58.8k, False: 0] ------------------ 344| 58.8k| { 345| 58.8k| new_node->type = type; 346| 58.8k| new_node->atom.length = 0; 347| 58.8k| new_node->next_sibling = NULL; 348| 58.8k| new_node->children_head = NULL; 349| 58.8k| new_node->children_tail = NULL; 350| 58.8k| } 351| | 352| 58.8k| return new_node; 353| 58.8k|} atoms.c:_yr_atoms_tree_destroy: 401| 7.09k|{ 402| 7.09k| _yr_atoms_tree_node_destroy(atom_tree->root_node); 403| 7.09k| yr_free(atom_tree); 404| 7.09k|} atoms.c:_yr_atoms_tree_node_destroy: 359| 58.8k|{ 360| 58.8k| YR_ATOM_TREE_NODE* child; 361| 58.8k| YR_ATOM_TREE_NODE* next_child; 362| | 363| 58.8k| if (node == NULL) ------------------ | Branch (363:7): [True: 0, False: 58.8k] ------------------ 364| 0| return; 365| | 366| 58.8k| if (node->type == ATOM_TREE_OR || node->type == ATOM_TREE_AND) ------------------ | | 38| 117k|#define ATOM_TREE_OR 3 ------------------ if (node->type == ATOM_TREE_OR || node->type == ATOM_TREE_AND) ------------------ | | 37| 28.2k|#define ATOM_TREE_AND 2 ------------------ | Branch (366:7): [True: 30.6k, False: 28.2k] | Branch (366:37): [True: 11.7k, False: 16.4k] ------------------ 367| 42.4k| { 368| 42.4k| child = node->children_head; 369| | 370| 94.2k| while (child != NULL) ------------------ | Branch (370:12): [True: 51.7k, False: 42.4k] ------------------ 371| 51.7k| { 372| 51.7k| next_child = child->next_sibling; 373| 51.7k| _yr_atoms_tree_node_destroy(child); 374| 51.7k| child = next_child; 375| 51.7k| } 376| 42.4k| } 377| | 378| 58.8k| yr_free(node); 379| 58.8k|} atoms.c:_yr_atoms_extract_from_re: 878| 7.09k|{ 879| 7.09k| YR_STACK* stack; 880| 7.09k| RE_NODE* re_node; 881| | 882| 7.09k| YR_ATOM atom = {0}; 883| 7.09k| YR_ATOM best_atom = {0}; 884| | 885| 7.09k| struct STACK_ITEM si; 886| | 887| 7.09k| int i, shift; 888| 7.09k| int quality; 889| 7.09k| int best_quality = -1; 890| 7.09k| int n = 0; 891| | 892| 7.09k| YR_ATOM_TREE_NODE* and_node; 893| 7.09k| YR_ATOM_TREE_NODE* left_node; 894| 7.09k| 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| 7.09k| 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| 7.09k| 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| 7.09k| YR_ATOM_TREE_NODE* current_appending_node = NULL; 908| | 909| | // This holds the ATOM_TREE_LEAF node whose atom is currently being updated. 910| 7.09k| YR_ATOM_TREE_NODE* leaf = NULL; 911| | 912| 7.09k| FAIL_ON_ERROR(yr_stack_create(1024, sizeof(si), &stack)); ------------------ | | 131| 7.09k| { \ | | 132| 7.09k| int __error = (x); \ | | 133| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 7.09k] | | ------------------ | | 134| 7.09k| return __error; \ | | 135| 7.09k| } ------------------ 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| 7.09k| si.re_node = NULL; 918| 7.09k| si.new_appending_node = appending_node; 919| | 920| 7.09k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 7.09k| { \ | | 140| 7.09k| int __error = (x); \ | | 141| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 7.09k] | | ------------------ | | 142| 7.09k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 7.09k| } ------------------ 921| 7.09k| yr_stack_push(stack, (void*) &si), yr_stack_destroy(stack)); 922| | 923| | // Start processing the root node. 924| 7.09k| 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| 7.09k| si.new_appending_node = appending_node; 929| | 930| 7.09k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 7.09k| { \ | | 140| 7.09k| int __error = (x); \ | | 141| 7.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 7.09k] | | ------------------ | | 142| 7.09k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 7.09k| } ------------------ 931| 7.09k| yr_stack_push(stack, (void*) &si), yr_stack_destroy(stack)); 932| | 933| 1.19M| while (yr_stack_pop(stack, (void*) &si)) ------------------ | Branch (933:10): [True: 1.18M, False: 7.09k] ------------------ 934| 1.18M| { 935| | // Change the appending node if the item poped from the stack says so. 936| 1.18M| if (si.new_appending_node != NULL) ------------------ | Branch (936:9): [True: 57.2k, False: 1.12M] ------------------ 937| 57.2k| { 938| | // Before changing the appending node let's append any pending leaf to 939| | // the current appending node. 940| 57.2k| if (n > 0) ------------------ | Branch (940:11): [True: 16.4k, False: 40.7k] ------------------ 941| 16.4k| { 942| 16.4k| make_atom_from_re_nodes(atom, n, recent_re_nodes); ------------------ | | 858| 16.4k| { \ | | 859| 16.4k| atom.length = nodes_length; \ | | 860| 61.7k| for (i = 0; i < atom.length; i++) \ | | ------------------ | | | Branch (860:17): [True: 45.2k, False: 16.4k] | | ------------------ | | 861| 45.2k| { \ | | 862| 45.2k| atom.bytes[i] = (uint8_t) (recent_re_nodes)[i]->value; \ | | 863| 45.2k| atom.mask[i] = (uint8_t) (recent_re_nodes)[i]->mask; \ | | 864| 45.2k| } \ | | 865| 16.4k| } ------------------ 943| 16.4k| shift = _yr_atoms_trim(&atom); 944| 16.4k| quality = config->get_atom_quality(config, &atom); 945| | 946| 16.4k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 149| 16.4k| { \ | | 150| 16.4k| if ((x) == NULL) \ | | ------------------ | | | Branch (150:9): [True: 0, False: 16.4k] | | ------------------ | | 151| 16.4k| { \ | | 152| 0| cleanup; \ | | 153| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 154| 0| } \ | | 155| 16.4k| } ------------------ 947| 16.4k| leaf = _yr_atoms_tree_node_create(ATOM_TREE_LEAF), 948| 16.4k| yr_stack_destroy(stack)); 949| | 950| 16.4k| if (quality > best_quality) ------------------ | Branch (950:13): [True: 12.0k, False: 4.43k] ------------------ 951| 12.0k| { 952| 12.0k| memcpy(&leaf->atom, &atom, sizeof(atom)); 953| 12.0k| memcpy( 954| 12.0k| &leaf->re_nodes, 955| 12.0k| &recent_re_nodes[shift], 956| 12.0k| sizeof(recent_re_nodes) - shift * sizeof(recent_re_nodes[0])); 957| 12.0k| } 958| 4.43k| else 959| 4.43k| { 960| 4.43k| memcpy(&leaf->atom, &best_atom, sizeof(best_atom)); 961| 4.43k| memcpy( 962| 4.43k| &leaf->re_nodes, &best_atom_re_nodes, sizeof(best_atom_re_nodes)); 963| 4.43k| } 964| | 965| 16.4k| _yr_atoms_tree_node_append(current_appending_node, leaf); 966| 16.4k| n = 0; 967| 16.4k| } 968| | 969| 57.2k| current_appending_node = si.new_appending_node; 970| 57.2k| best_quality = -1; 971| 57.2k| } 972| | 973| 1.18M| if (si.re_node != NULL) ------------------ | Branch (973:9): [True: 1.15M, False: 26.5k] ------------------ 974| 1.15M| { 975| 1.15M| switch (si.re_node->type) 976| 1.15M| { 977| 1.08M| case RE_NODE_LITERAL: ------------------ | | 41| 1.08M|#define RE_NODE_LITERAL 1 ------------------ | Branch (977:7): [True: 1.08M, False: 76.6k] ------------------ 978| 1.08M| case RE_NODE_MASKED_LITERAL: ------------------ | | 42| 1.08M|#define RE_NODE_MASKED_LITERAL 2 ------------------ | Branch (978:7): [True: 1.31k, False: 1.15M] ------------------ 979| 1.09M| case RE_NODE_ANY: ------------------ | | 43| 1.09M|#define RE_NODE_ANY 3 ------------------ | Branch (979:7): [True: 6.15k, False: 1.15M] ------------------ 980| | 981| 1.09M| if (n < YR_MAX_ATOM_LENGTH) ------------------ | | 68| 1.09M|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (981:13): [True: 45.2k, False: 1.04M] ------------------ 982| 45.2k| { 983| 45.2k| recent_re_nodes[n] = si.re_node; 984| 45.2k| best_atom_re_nodes[n] = si.re_node; 985| 45.2k| best_atom.bytes[n] = (uint8_t) si.re_node->value; 986| 45.2k| best_atom.mask[n] = (uint8_t) si.re_node->mask; 987| 45.2k| best_atom.length = ++n; 988| 45.2k| } 989| 1.04M| else if (best_quality < YR_MAX_ATOM_QUALITY) ------------------ | | 72| 1.04M|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (989:18): [True: 977k, False: 68.1k] ------------------ 990| 977k| { 991| 977k| make_atom_from_re_nodes(atom, n, recent_re_nodes); ------------------ | | 858| 977k| { \ | | 859| 977k| atom.length = nodes_length; \ | | 860| 4.88M| for (i = 0; i < atom.length; i++) \ | | ------------------ | | | Branch (860:17): [True: 3.90M, False: 977k] | | ------------------ | | 861| 3.90M| { \ | | 862| 3.90M| atom.bytes[i] = (uint8_t) (recent_re_nodes)[i]->value; \ | | 863| 3.90M| atom.mask[i] = (uint8_t) (recent_re_nodes)[i]->mask; \ | | 864| 3.90M| } \ | | 865| 977k| } ------------------ 992| 977k| shift = _yr_atoms_trim(&atom); 993| 977k| quality = config->get_atom_quality(config, &atom); 994| | 995| 977k| if (quality > best_quality) ------------------ | Branch (995:15): [True: 10.3k, False: 966k] ------------------ 996| 10.3k| { 997| 51.0k| for (i = 0; i < atom.length; i++) ------------------ | Branch (997:25): [True: 40.6k, False: 10.3k] ------------------ 998| 40.6k| { 999| 40.6k| best_atom.bytes[i] = atom.bytes[i]; 1000| 40.6k| best_atom.mask[i] = atom.mask[i]; 1001| 40.6k| best_atom_re_nodes[i] = recent_re_nodes[i + shift]; 1002| 40.6k| } 1003| | 1004| 10.3k| best_atom.length = atom.length; 1005| 10.3k| best_quality = quality; 1006| 10.3k| } 1007| | 1008| 3.90M| for (i = 1; i < YR_MAX_ATOM_LENGTH; i++) ------------------ | | 68| 3.90M|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (1008:23): [True: 2.93M, False: 977k] ------------------ 1009| 2.93M| recent_re_nodes[i - 1] = recent_re_nodes[i]; 1010| | 1011| 977k| recent_re_nodes[YR_MAX_ATOM_LENGTH - 1] = si.re_node; ------------------ | | 68| 977k|#define YR_MAX_ATOM_LENGTH 4 ------------------ 1012| 977k| } 1013| | 1014| 1.09M| break; 1015| | 1016| 49.7k| case RE_NODE_CONCAT: ------------------ | | 44| 49.7k|#define RE_NODE_CONCAT 4 ------------------ | Branch (1016:7): [True: 49.7k, False: 1.11M] ------------------ 1017| | 1018| 49.7k| re_node = si.re_node->children_tail; 1019| | 1020| | // Push children right to left, they are poped left to right. 1021| 1.17M| while (re_node != NULL) ------------------ | Branch (1021:16): [True: 1.12M, False: 49.7k] ------------------ 1022| 1.12M| { 1023| 1.12M| si.new_appending_node = NULL; 1024| 1.12M| si.re_node = re_node; 1025| | 1026| 1.12M| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 1.12M| { \ | | 140| 1.12M| int __error = (x); \ | | 141| 1.12M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.12M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 1.12M] | | ------------------ | | 142| 1.12M| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 1.12M| } ------------------ 1027| 1.12M| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1028| | 1029| 1.12M| re_node = re_node->prev_sibling; 1030| 1.12M| } 1031| | 1032| 49.7k| break; 1033| | 1034| 49.7k| case RE_NODE_ALT: ------------------ | | 45| 11.7k|#define RE_NODE_ALT 5 ------------------ | Branch (1034:7): [True: 11.7k, False: 1.14M] ------------------ 1035| | 1036| | // Create ATOM_TREE_AND node with two ATOM_TREE_OR children nodes. 1037| 11.7k| and_node = _yr_atoms_tree_node_create(ATOM_TREE_AND); ------------------ | | 37| 11.7k|#define ATOM_TREE_AND 2 ------------------ 1038| 11.7k| left_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 11.7k|#define ATOM_TREE_OR 3 ------------------ 1039| 11.7k| right_node = _yr_atoms_tree_node_create(ATOM_TREE_OR); ------------------ | | 38| 11.7k|#define ATOM_TREE_OR 3 ------------------ 1040| | 1041| 11.7k| if (and_node == NULL || left_node == NULL || right_node == NULL) ------------------ | Branch (1041:13): [True: 0, False: 11.7k] | Branch (1041:33): [True: 0, False: 11.7k] | Branch (1041:54): [True: 0, False: 11.7k] ------------------ 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| 11.7k| and_node->children_head = left_node; 1053| 11.7k| and_node->children_tail = right_node; 1054| 11.7k| left_node->next_sibling = right_node; 1055| | 1056| | // Add the ATOM_TREE_AND as children of the current node. 1057| 11.7k| _yr_atoms_tree_node_append(current_appending_node, and_node); 1058| | 1059| 11.7k| re_node = si.re_node; 1060| | 1061| 11.7k| si.new_appending_node = current_appending_node; 1062| 11.7k| si.re_node = NULL; 1063| | 1064| 11.7k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 11.7k| { \ | | 140| 11.7k| int __error = (x); \ | | 141| 11.7k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 11.7k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 11.7k] | | ------------------ | | 142| 11.7k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 11.7k| } ------------------ 1065| 11.7k| 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| 11.7k| si.new_appending_node = right_node; 1070| 11.7k| si.re_node = re_node->children_tail; 1071| | 1072| 11.7k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 11.7k| { \ | | 140| 11.7k| int __error = (x); \ | | 141| 11.7k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 11.7k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 11.7k] | | ------------------ | | 142| 11.7k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 11.7k| } ------------------ 1073| 11.7k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1074| | 1075| 11.7k| si.new_appending_node = left_node; 1076| 11.7k| si.re_node = re_node->children_head; 1077| | 1078| 11.7k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 11.7k| { \ | | 140| 11.7k| int __error = (x); \ | | 141| 11.7k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 11.7k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 11.7k] | | ------------------ | | 142| 11.7k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 11.7k| } ------------------ 1079| 11.7k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1080| | 1081| 11.7k| break; 1082| | 1083| 656| case RE_NODE_PLUS: ------------------ | | 48| 656|#define RE_NODE_PLUS 8 ------------------ | Branch (1083:7): [True: 656, False: 1.15M] ------------------ 1084| | 1085| 656| re_node = si.re_node; 1086| | 1087| 656| si.new_appending_node = current_appending_node; 1088| 656| si.re_node = NULL; 1089| | 1090| 656| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 656| { \ | | 140| 656| int __error = (x); \ | | 141| 656| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 656|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 656] | | ------------------ | | 142| 656| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 656| } ------------------ 1091| 656| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1092| | 1093| 656| si.new_appending_node = NULL; 1094| | // RE_NODE_PLUS nodes has a single child, which is children_head. 1095| 656| si.re_node = re_node->children_head; 1096| | 1097| 656| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 656| { \ | | 140| 656| int __error = (x); \ | | 141| 656| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 656|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 656] | | ------------------ | | 142| 656| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 656| } ------------------ 1098| 656| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1099| | 1100| 656| break; 1101| | 1102| 402| case RE_NODE_RANGE: ------------------ | | 46| 402|#define RE_NODE_RANGE 6 ------------------ | Branch (1102:7): [True: 402, False: 1.15M] ------------------ 1103| | 1104| 402| re_node = si.re_node; 1105| | 1106| 402| si.new_appending_node = current_appending_node; 1107| 402| si.re_node = NULL; 1108| | 1109| 402| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 402| { \ | | 140| 402| int __error = (x); \ | | 141| 402| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 402|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 402] | | ------------------ | | 142| 402| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 402| } ------------------ 1110| 402| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1111| | 1112| 402| si.new_appending_node = NULL; 1113| | 1114| | // RE_NODE_RANGE nodes has a single child, which is children_head. 1115| 402| 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| 402| for (i = 0; i < yr_min(re_node->start, YR_MAX_ATOM_LENGTH); i++) ------------------ | | 107| 402|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 402, False: 0] | | ------------------ ------------------ | Branch (1123:21): [True: 0, False: 402] ------------------ 1124| 0| { 1125| 0| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 0| { \ | | 140| 0| int __error = (x); \ | | 141| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 0] | | ------------------ | | 142| 0| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 0| } ------------------ 1126| 0| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1127| 0| } 1128| | 1129| 402| break; 1130| | 1131| 1.56k| case RE_NODE_RANGE_ANY: ------------------ | | 61| 1.56k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (1131:7): [True: 1.56k, False: 1.15M] ------------------ 1132| 1.90k| case RE_NODE_STAR: ------------------ | | 47| 1.90k|#define RE_NODE_STAR 7 ------------------ | Branch (1132:7): [True: 336, False: 1.15M] ------------------ 1133| 2.03k| case RE_NODE_CLASS: ------------------ | | 49| 2.03k|#define RE_NODE_CLASS 9 ------------------ | Branch (1133:7): [True: 131, False: 1.15M] ------------------ 1134| 2.16k| case RE_NODE_WORD_CHAR: ------------------ | | 50| 2.16k|#define RE_NODE_WORD_CHAR 10 ------------------ | Branch (1134:7): [True: 128, False: 1.15M] ------------------ 1135| 2.29k| case RE_NODE_NON_WORD_CHAR: ------------------ | | 51| 2.29k|#define RE_NODE_NON_WORD_CHAR 11 ------------------ | Branch (1135:7): [True: 128, False: 1.15M] ------------------ 1136| 2.29k| case RE_NODE_SPACE: ------------------ | | 52| 2.29k|#define RE_NODE_SPACE 12 ------------------ | Branch (1136:7): [True: 0, False: 1.15M] ------------------ 1137| 2.41k| case RE_NODE_NON_SPACE: ------------------ | | 53| 2.41k|#define RE_NODE_NON_SPACE 13 ------------------ | Branch (1137:7): [True: 128, False: 1.15M] ------------------ 1138| 2.55k| case RE_NODE_DIGIT: ------------------ | | 54| 2.55k|#define RE_NODE_DIGIT 14 ------------------ | Branch (1138:7): [True: 134, False: 1.15M] ------------------ 1139| 2.55k| case RE_NODE_NON_DIGIT: ------------------ | | 55| 2.55k|#define RE_NODE_NON_DIGIT 15 ------------------ | Branch (1139:7): [True: 3, False: 1.15M] ------------------ 1140| 4.99k| case RE_NODE_EMPTY: ------------------ | | 56| 4.99k|#define RE_NODE_EMPTY 16 ------------------ | Branch (1140:7): [True: 2.43k, False: 1.15M] ------------------ 1141| 5.16k| case RE_NODE_ANCHOR_START: ------------------ | | 57| 5.16k|#define RE_NODE_ANCHOR_START 17 ------------------ | Branch (1141:7): [True: 176, False: 1.15M] ------------------ 1142| 6.11k| case RE_NODE_ANCHOR_END: ------------------ | | 58| 6.11k|#define RE_NODE_ANCHOR_END 18 ------------------ | Branch (1142:7): [True: 951, False: 1.15M] ------------------ 1143| 6.24k| case RE_NODE_WORD_BOUNDARY: ------------------ | | 59| 6.24k|#define RE_NODE_WORD_BOUNDARY 19 ------------------ | Branch (1143:7): [True: 128, False: 1.15M] ------------------ 1144| 6.37k| case RE_NODE_NON_WORD_BOUNDARY: ------------------ | | 60| 6.37k|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ | Branch (1144:7): [True: 128, False: 1.15M] ------------------ 1145| 6.50k| case RE_NODE_NOT_LITERAL: ------------------ | | 62| 6.50k|#define RE_NODE_NOT_LITERAL 22 ------------------ | Branch (1145:7): [True: 133, False: 1.15M] ------------------ 1146| 6.63k| case RE_NODE_MASKED_NOT_LITERAL: ------------------ | | 63| 6.63k|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ | Branch (1146:7): [True: 130, False: 1.15M] ------------------ 1147| | 1148| 6.63k| si.new_appending_node = current_appending_node; 1149| 6.63k| si.re_node = NULL; 1150| | 1151| 6.63k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 6.63k| { \ | | 140| 6.63k| int __error = (x); \ | | 141| 6.63k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.63k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 6.63k] | | ------------------ | | 142| 6.63k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 6.63k| } ------------------ 1152| 6.63k| yr_stack_push(stack, &si), yr_stack_destroy(stack)); 1153| | 1154| 6.63k| break; 1155| | 1156| 0| default: ------------------ | Branch (1156:7): [True: 0, False: 1.15M] ------------------ 1157| 0| assert(false); 1158| 1.15M| } 1159| 1.15M| } 1160| 1.18M| } 1161| | 1162| 7.09k| yr_stack_destroy(stack); 1163| | 1164| 7.09k| return ERROR_SUCCESS; ------------------ | | 40| 7.09k|#define ERROR_SUCCESS 0 ------------------ 1165| 7.09k|} atoms.c:_yr_atoms_tree_node_append: 387| 28.2k|{ 388| 28.2k| if (dest->children_head == NULL) ------------------ | Branch (388:7): [True: 27.2k, False: 985] ------------------ 389| 27.2k| dest->children_head = node; 390| | 391| 28.2k| if (dest->children_tail != NULL) ------------------ | Branch (391:7): [True: 985, False: 27.2k] ------------------ 392| 985| dest->children_tail->next_sibling = node; 393| | 394| 28.2k| dest->children_tail = node; 395| 28.2k|} atoms.c:_yr_atoms_choose: 522| 58.8k|{ 523| 58.8k| YR_ATOM_TREE_NODE* child; 524| 58.8k| YR_ATOM_LIST_ITEM* item; 525| 58.8k| YR_ATOM_LIST_ITEM* tail; 526| | 527| 58.8k| int shift, quality; 528| | 529| 58.8k| int max_quality = YR_MIN_ATOM_QUALITY; ------------------ | | 76| 58.8k|#define YR_MIN_ATOM_QUALITY 0 ------------------ 530| 58.8k| int min_quality = YR_MAX_ATOM_QUALITY; ------------------ | | 72| 58.8k|#define YR_MAX_ATOM_QUALITY 255 ------------------ 531| | 532| 58.8k| *chosen_atoms = NULL; 533| 58.8k| *atoms_quality = YR_MIN_ATOM_QUALITY; ------------------ | | 76| 58.8k|#define YR_MIN_ATOM_QUALITY 0 ------------------ 534| | 535| 58.8k| switch (node->type) ------------------ | Branch (535:11): [True: 0, False: 58.8k] ------------------ 536| 58.8k| { 537| 16.4k| case ATOM_TREE_LEAF: ------------------ | | 36| 16.4k|#define ATOM_TREE_LEAF 1 ------------------ | Branch (537:3): [True: 16.4k, False: 42.4k] ------------------ 538| | 539| 16.4k| item = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 540| | 541| 16.4k| if (item == NULL) ------------------ | Branch (541:9): [True: 0, False: 16.4k] ------------------ 542| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 543| | 544| 16.4k| memcpy(&item->atom, &node->atom, sizeof(YR_ATOM)); 545| | 546| 16.4k| shift = _yr_atoms_trim(&item->atom); 547| | 548| 16.4k| if (item->atom.length > 0) ------------------ | Branch (548:9): [True: 15.3k, False: 1.07k] ------------------ 549| 15.3k| { 550| 15.3k| item->forward_code_ref = node->re_nodes[shift]->forward_code_ref; 551| 15.3k| item->backward_code_ref = node->re_nodes[shift]->backward_code_ref; 552| 15.3k| item->backtrack = 0; 553| 15.3k| item->next = NULL; 554| | 555| 15.3k| *chosen_atoms = item; 556| 15.3k| *atoms_quality = config->get_atom_quality(config, &item->atom); 557| 15.3k| } 558| 1.07k| else 559| 1.07k| { 560| 1.07k| yr_free(item); 561| 1.07k| } 562| | 563| 16.4k| break; 564| | 565| 30.6k| case ATOM_TREE_OR: ------------------ | | 38| 30.6k|#define ATOM_TREE_OR 3 ------------------ | Branch (565:3): [True: 30.6k, False: 28.1k] ------------------ 566| | 567| | // The choosen nodes are those coming from the highest quality child. 568| | 569| 30.6k| child = node->children_head; 570| | 571| 57.6k| while (child != NULL) ------------------ | Branch (571:12): [True: 28.1k, False: 29.4k] ------------------ 572| 28.1k| { 573| 28.1k| FAIL_ON_ERROR(_yr_atoms_choose(config, child, &item, &quality)); ------------------ | | 131| 28.1k| { \ | | 132| 28.1k| int __error = (x); \ | | 133| 28.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 28.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 28.1k] | | ------------------ | | 134| 28.1k| return __error; \ | | 135| 28.1k| } ------------------ 574| | 575| 28.1k| if (quality > max_quality) ------------------ | Branch (575:11): [True: 23.8k, False: 4.34k] ------------------ 576| 23.8k| { 577| 23.8k| max_quality = quality; 578| 23.8k| yr_atoms_list_destroy(*chosen_atoms); 579| 23.8k| *chosen_atoms = item; 580| 23.8k| } 581| 4.34k| else 582| 4.34k| { 583| 4.34k| yr_atoms_list_destroy(item); 584| 4.34k| } 585| | 586| 28.1k| if (max_quality == YR_MAX_ATOM_QUALITY) ------------------ | | 72| 28.1k|#define YR_MAX_ATOM_QUALITY 255 ------------------ | Branch (586:11): [True: 1.18k, False: 26.9k] ------------------ 587| 1.18k| break; 588| | 589| 26.9k| child = child->next_sibling; 590| 26.9k| } 591| | 592| 30.6k| *atoms_quality = max_quality; 593| 30.6k| break; 594| | 595| 11.7k| case ATOM_TREE_AND: ------------------ | | 37| 11.7k|#define ATOM_TREE_AND 2 ------------------ | Branch (595:3): [True: 11.7k, False: 47.0k] ------------------ 596| | 597| | // The choosen nodes are the concatenation of the the nodes choosen from 598| | // all the children. 599| | 600| 11.7k| child = node->children_head; 601| | 602| 35.3k| while (child != NULL) ------------------ | Branch (602:12): [True: 23.5k, False: 11.7k] ------------------ 603| 23.5k| { 604| 23.5k| FAIL_ON_ERROR(_yr_atoms_choose(config, child, &item, &quality)); ------------------ | | 131| 23.5k| { \ | | 132| 23.5k| int __error = (x); \ | | 133| 23.5k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 23.5k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 23.5k] | | ------------------ | | 134| 23.5k| return __error; \ | | 135| 23.5k| } ------------------ 605| | 606| 23.5k| if (quality < min_quality) ------------------ | Branch (606:11): [True: 12.7k, False: 10.8k] ------------------ 607| 12.7k| min_quality = quality; 608| | 609| 23.5k| if (item != NULL) ------------------ | Branch (609:11): [True: 18.6k, False: 4.94k] ------------------ 610| 18.6k| { 611| 18.6k| tail = item; 612| 134k| while (tail->next != NULL) tail = tail->next; ------------------ | Branch (612:16): [True: 116k, False: 18.6k] ------------------ 613| | 614| 18.6k| tail->next = *chosen_atoms; 615| 18.6k| *chosen_atoms = item; 616| 18.6k| } 617| | 618| 23.5k| child = child->next_sibling; 619| 23.5k| } 620| | 621| 11.7k| *atoms_quality = min_quality; 622| 11.7k| break; 623| 58.8k| } 624| | 625| 58.8k| return ERROR_SUCCESS; ------------------ | | 40| 58.8k|#define ERROR_SUCCESS 0 ------------------ 626| 58.8k|} atoms.c:_yr_atoms_expand_wildcards: 1197| 7.09k|{ 1198| 7.09k| int i; 1199| | 1200| 7.09k| YR_ATOM_LIST_ITEM* atom = atoms; 1201| 7.09k| YR_ATOM_LIST_ITEM* new_atom; 1202| 7.09k| YR_ATOM_LIST_ITEM* prev_atom; 1203| 7.09k| YR_ATOM_LIST_ITEM* next_atom; 1204| | 1205| 650k| while (atom != NULL) ------------------ | Branch (1205:10): [True: 643k, False: 7.09k] ------------------ 1206| 643k| { 1207| 643k| bool expanded = false; 1208| | 1209| 3.13M| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (1209:17): [True: 2.48M, False: 643k] ------------------ 1210| 2.48M| { 1211| 2.48M| uint16_t a, s, e, incr = 1; 1212| | 1213| 2.48M| switch (atom->atom.mask[i]) 1214| 2.48M| { 1215| 2.29k| case 0x00: ------------------ | Branch (1215:7): [True: 2.29k, False: 2.48M] ------------------ 1216| 2.29k| expanded = true; 1217| 2.29k| s = 0x00; 1218| 2.29k| e = 0xFF; 1219| 2.29k| break; 1220| | 1221| 1.43k| case 0x0F: ------------------ | Branch (1221:7): [True: 1.43k, False: 2.48M] ------------------ 1222| 1.43k| expanded = true; 1223| 1.43k| s = atom->atom.bytes[i]; 1224| 1.43k| e = atom->atom.bytes[i] | 0xF0; 1225| 1.43k| incr = 0x10; 1226| 1.43k| break; 1227| | 1228| 1.22k| case 0xF0: ------------------ | Branch (1228:7): [True: 1.22k, False: 2.48M] ------------------ 1229| 1.22k| expanded = true; 1230| 1.22k| s = atom->atom.bytes[i]; 1231| 1.22k| e = atom->atom.bytes[i] | 0x0F; 1232| 1.22k| break; 1233| | 1234| 2.48M| default: ------------------ | Branch (1234:7): [True: 2.48M, False: 4.95k] ------------------ 1235| 2.48M| s = 0; 1236| 2.48M| e = 0; 1237| 2.48M| } 1238| | 1239| 2.48M| if (s != e) ------------------ | Branch (1239:11): [True: 4.95k, False: 2.48M] ------------------ 1240| 4.95k| { 1241| 4.95k| atom->atom.bytes[i] = (uint8_t) s; 1242| 4.95k| atom->atom.mask[i] = 0xFF; 1243| 4.95k| } 1244| | 1245| 2.48M| prev_atom = atom; 1246| 2.48M| next_atom = atom->next; 1247| | 1248| 3.11M| for (a = s + incr; a <= e; a += incr) ------------------ | Branch (1248:26): [True: 624k, False: 2.48M] ------------------ 1249| 624k| { 1250| 624k| new_atom = _yr_atoms_clone_list_item(atom); 1251| | 1252| 624k| if (new_atom == NULL) ------------------ | Branch (1252:13): [True: 0, False: 624k] ------------------ 1253| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1254| | 1255| 624k| new_atom->atom.bytes[i] = (uint8_t) a; 1256| 624k| new_atom->atom.mask[i] = 0xFF; 1257| 624k| new_atom->next = next_atom; 1258| 624k| prev_atom->next = new_atom; 1259| 624k| prev_atom = new_atom; 1260| 624k| } 1261| 2.48M| } 1262| | 1263| 643k| if (!expanded) ------------------ | Branch (1263:9): [True: 638k, False: 4.83k] ------------------ 1264| 638k| atom = atom->next; 1265| 643k| } 1266| | 1267| 7.09k| return ERROR_SUCCESS; ------------------ | | 40| 7.09k|#define ERROR_SUCCESS 0 ------------------ 1268| 7.09k|} atoms.c:_yr_atoms_clone_list_item: 1171| 624k|{ 1172| 624k| YR_ATOM_LIST_ITEM* clone = (YR_ATOM_LIST_ITEM*) yr_malloc( 1173| 624k| sizeof(YR_ATOM_LIST_ITEM)); 1174| | 1175| 624k| if (clone == NULL) ------------------ | Branch (1175:7): [True: 0, False: 624k] ------------------ 1176| 0| return NULL; 1177| | 1178| 624k| memcpy(clone, item, sizeof(YR_ATOM_LIST_ITEM)); 1179| | 1180| 624k| return clone; 1181| 624k|} atoms.c:_yr_atoms_wide: 807| 2.41k|{ 808| 2.41k| YR_ATOM_LIST_ITEM* atom; 809| 2.41k| YR_ATOM_LIST_ITEM* new_atom; 810| | 811| 2.41k| int i; 812| | 813| 2.41k| *wide_atoms = NULL; 814| 2.41k| atom = atoms; 815| | 816| 29.6k| while (atom != NULL) ------------------ | Branch (816:10): [True: 27.2k, False: 2.41k] ------------------ 817| 27.2k| { 818| 27.2k| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 819| | 820| 27.2k| if (new_atom == NULL) ------------------ | Branch (820:9): [True: 0, False: 27.2k] ------------------ 821| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 822| | 823| 136k| for (i = 0; i < YR_MAX_ATOM_LENGTH; i++) ------------------ | | 68| 136k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (823:17): [True: 109k, False: 27.2k] ------------------ 824| 109k| { 825| 109k| new_atom->atom.bytes[i] = 0; 826| 109k| new_atom->atom.mask[i] = 0xFF; 827| 109k| } 828| | 829| 80.7k| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (829:17): [True: 79.3k, False: 1.45k] ------------------ 830| 79.3k| { 831| 79.3k| if (i * 2 < YR_MAX_ATOM_LENGTH) ------------------ | | 68| 79.3k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (831:11): [True: 53.4k, False: 25.8k] ------------------ 832| 53.4k| new_atom->atom.bytes[i * 2] = atom->atom.bytes[i]; 833| 25.8k| else 834| 25.8k| break; 835| 79.3k| } 836| | 837| 27.2k| new_atom->atom.length = yr_min(atom->atom.length * 2, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 27.2k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 1.07k, False: 26.2k] | | ------------------ ------------------ 838| 27.2k| new_atom->forward_code_ref = atom->forward_code_ref; 839| 27.2k| new_atom->backward_code_ref = atom->backward_code_ref; 840| 27.2k| new_atom->backtrack = atom->backtrack * 2; 841| 27.2k| new_atom->next = *wide_atoms; 842| | 843| 27.2k| *wide_atoms = new_atom; 844| | 845| 27.2k| atom = atom->next; 846| 27.2k| } 847| | 848| 2.41k| return ERROR_SUCCESS; ------------------ | | 40| 2.41k|#define ERROR_SUCCESS 0 ------------------ 849| 2.41k|} atoms.c:_yr_atoms_list_concat: 428| 6.40k|{ 429| 6.40k| YR_ATOM_LIST_ITEM* item; 430| | 431| 6.40k| if (list1 == NULL) ------------------ | Branch (431:7): [True: 678, False: 5.72k] ------------------ 432| 678| return list2; 433| | 434| 5.72k| item = list1; 435| | 436| 568k| while (item->next != NULL) ------------------ | Branch (436:10): [True: 562k, False: 5.72k] ------------------ 437| 562k| { 438| 562k| item = item->next; 439| 562k| } 440| | 441| 5.72k| item->next = list2; 442| 5.72k| return list1; 443| 6.40k|} atoms.c:_yr_atoms_case_insensitive: 700| 5.28k|{ 701| 5.28k| YR_ATOM_LIST_ITEM* atom; 702| 5.28k| YR_ATOM_LIST_ITEM* new_atom; 703| | 704| 5.28k| uint8_t buffer[CASE_COMBINATIONS_BUFFER_SIZE]; 705| 5.28k| uint8_t atom_length; 706| 5.28k| uint8_t* atoms_cursor; 707| | 708| 5.28k| int i; 709| | 710| 5.28k| *case_insensitive_atoms = NULL; 711| 5.28k| atom = atoms; 712| | 713| 556k| while (atom != NULL) ------------------ | Branch (713:10): [True: 551k, False: 5.28k] ------------------ 714| 551k| { 715| 551k| _yr_atoms_case_combinations(atom->atom.bytes, atom->atom.length, 0, buffer); 716| | 717| 551k| atoms_cursor = buffer; 718| 551k| atom_length = *atoms_cursor; 719| 551k| atoms_cursor++; 720| | 721| 4.91M| while (atom_length != 0) ------------------ | Branch (721:12): [True: 4.36M, False: 551k] ------------------ 722| 4.36M| { 723| 4.36M| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 724| | 725| 4.36M| if (new_atom == NULL) ------------------ | Branch (725:11): [True: 0, False: 4.36M] ------------------ 726| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 727| | 728| 21.7M| for (i = 0; i < atom_length; i++) ------------------ | Branch (728:19): [True: 17.4M, False: 4.36M] ------------------ 729| 17.4M| { 730| 17.4M| new_atom->atom.bytes[i] = atoms_cursor[i]; 731| 17.4M| new_atom->atom.mask[i] = 0xFF; 732| 17.4M| } 733| | 734| 4.36M| new_atom->atom.length = atom_length; 735| 4.36M| new_atom->forward_code_ref = atom->forward_code_ref; 736| 4.36M| new_atom->backward_code_ref = atom->backward_code_ref; 737| 4.36M| new_atom->backtrack = atom->backtrack; 738| 4.36M| new_atom->next = *case_insensitive_atoms; 739| | 740| 4.36M| *case_insensitive_atoms = new_atom; 741| | 742| 4.36M| atoms_cursor += atom_length; 743| 4.36M| atom_length = *atoms_cursor; 744| 4.36M| atoms_cursor++; 745| 4.36M| } 746| | 747| 551k| atom = atom->next; 748| 551k| } 749| | 750| 5.28k| return ERROR_SUCCESS; ------------------ | | 40| 5.28k|#define ERROR_SUCCESS 0 ------------------ 751| 5.28k|} atoms.c:_yr_atoms_case_combinations: 645| 5.53M|{ 646| 5.53M| uint8_t c; 647| 5.53M| uint8_t* new_atom; 648| | 649| 5.53M| if (atom_offset + 1 < atom_length) ------------------ | Branch (649:7): [True: 2.98M, False: 2.55M] ------------------ 650| 2.98M| output_buffer = _yr_atoms_case_combinations( 651| 2.98M| atom, atom_length, atom_offset + 1, output_buffer); 652| | 653| 5.53M| c = atom[atom_offset]; 654| | 655| 5.53M| if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) ------------------ | Branch (655:8): [True: 4.75M, False: 777k] | Branch (655:20): [True: 4.13M, False: 621k] | Branch (655:34): [True: 940k, False: 459k] | Branch (655:46): [True: 225k, False: 715k] ------------------ 656| 4.36M| { 657| | // Write atom length. 658| 4.36M| *output_buffer = atom_length; 659| 4.36M| output_buffer++; 660| | 661| 4.36M| memcpy(output_buffer, atom, atom_length); 662| | 663| 4.36M| new_atom = output_buffer; 664| 4.36M| output_buffer += atom_length; 665| | 666| | // Swap character case. 667| 4.36M| if (c >= 'a' && c <= 'z') ------------------ | Branch (667:9): [True: 4.13M, False: 225k] | Branch (667:21): [True: 4.13M, False: 0] ------------------ 668| 4.13M| new_atom[atom_offset] -= 32; 669| 225k| else 670| 225k| new_atom[atom_offset] += 32; 671| | 672| 4.36M| if (atom_offset + 1 < atom_length) ------------------ | Branch (672:9): [True: 2.00M, False: 2.35M] ------------------ 673| 2.00M| output_buffer = _yr_atoms_case_combinations( 674| 2.00M| new_atom, atom_length, atom_offset + 1, output_buffer); 675| 4.36M| } 676| | 677| 5.53M| if (atom_offset == 0) ------------------ | Branch (677:7): [True: 551k, False: 4.98M] ------------------ 678| 551k| *output_buffer = 0; 679| | 680| 5.53M| return output_buffer; 681| 5.53M|} atoms.c:_yr_atoms_xor: 762| 989|{ 763| 989| YR_ATOM_LIST_ITEM* atom; 764| 989| YR_ATOM_LIST_ITEM* new_atom; 765| | 766| 989| int i, j; 767| 989| *xor_atoms = NULL; 768| 989| atom = atoms; 769| | 770| 2.25k| while (atom != NULL) ------------------ | Branch (770:10): [True: 1.26k, False: 989] ------------------ 771| 1.26k| { 772| 209k| for (j = min; j <= max; j++) ------------------ | Branch (772:19): [True: 207k, False: 1.26k] ------------------ 773| 207k| { 774| 207k| new_atom = (YR_ATOM_LIST_ITEM*) yr_malloc(sizeof(YR_ATOM_LIST_ITEM)); 775| | 776| 207k| if (new_atom == NULL) ------------------ | Branch (776:11): [True: 0, False: 207k] ------------------ 777| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 778| | 779| 634k| for (i = 0; i < atom->atom.length; i++) ------------------ | Branch (779:19): [True: 426k, False: 207k] ------------------ 780| 426k| { 781| 426k| new_atom->atom.bytes[i] = atom->atom.bytes[i] ^ j; 782| 426k| new_atom->atom.mask[i] = 0xFF; 783| 426k| } 784| | 785| 207k| new_atom->atom.length = yr_min(atom->atom.length, YR_MAX_ATOM_LENGTH); ------------------ | | 107| 207k|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 168k, False: 39.8k] | | ------------------ ------------------ 786| 207k| new_atom->forward_code_ref = atom->forward_code_ref; 787| 207k| new_atom->backward_code_ref = atom->backward_code_ref; 788| 207k| new_atom->backtrack = atom->backtrack; 789| 207k| new_atom->next = *xor_atoms; 790| | 791| 207k| *xor_atoms = new_atom; 792| 207k| } 793| | 794| 1.26k| atom = atom->next; 795| 1.26k| } 796| 989| return ERROR_SUCCESS; ------------------ | | 40| 989|#define ERROR_SUCCESS 0 ------------------ 797| 989|} _yr_base64_create_regexp: 306| 2.36k|{ 307| 2.36k| BASE64_NODE* p = head; 308| 2.36k| char* re_str; 309| 2.36k| char* s; 310| 2.36k| uint32_t length = 0; 311| | 312| | // The number of nodes in the list, used to know how many '|'. 313| 2.36k| uint32_t c = 0; 314| | 315| 9.89k| while (p != NULL) ------------------ | Branch (315:10): [True: 7.53k, False: 2.36k] ------------------ 316| 7.53k| { 317| 7.53k| length += (p->str->length + p->escaped); 318| 7.53k| c++; 319| 7.53k| p = p->next; 320| 7.53k| } 321| | 322| 2.36k| if (c == 0) ------------------ | Branch (322:7): [True: 0, False: 2.36k] ------------------ 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| 2.36k| re_str = (char*) yr_malloc(length + 2 + (c - 1) + 1); 328| 2.36k| if (re_str == NULL) ------------------ | Branch (328:7): [True: 0, False: 2.36k] ------------------ 329| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 330| | 331| 2.36k| s = re_str; 332| 2.36k| p = head; 333| 2.36k| *s++ = '('; 334| 9.89k| while (p != NULL) ------------------ | Branch (334:10): [True: 7.53k, False: 2.36k] ------------------ 335| 7.53k| { 336| 1.78M| for (uint32_t i = 0; i < p->str->length; i++) ------------------ | Branch (336:26): [True: 1.78M, False: 7.53k] ------------------ 337| 1.78M| { 338| 1.78M| if (IS_METACHAR(p->str->c_string[i])) ------------------ | | 174| 1.78M| (x == '\\' || x == '^' || x == '$' || x == '|' || x == '(' || x == ')' || \ | | ------------------ | | | Branch (174:4): [True: 0, False: 1.78M] | | | Branch (174:17): [True: 14, False: 1.78M] | | | Branch (174:29): [True: 6.46k, False: 1.77M] | | | Branch (174:41): [True: 509, False: 1.77M] | | | Branch (174:53): [True: 87, False: 1.77M] | | | Branch (174:65): [True: 5.18k, False: 1.76M] | | ------------------ | | 175| 1.78M| x == '[' || x == ']' || x == '*' || x == '?' || x == '{' || x == ',' || \ | | ------------------ | | | Branch (175:4): [True: 27, False: 1.76M] | | | Branch (175:16): [True: 1.60k, False: 1.76M] | | | Branch (175:28): [True: 9, False: 1.76M] | | | Branch (175:40): [True: 2, False: 1.76M] | | | Branch (175:52): [True: 1, False: 1.76M] | | | Branch (175:64): [True: 994, False: 1.76M] | | ------------------ | | 176| 1.78M| x == '.' || x == '+' || x == '}') | | ------------------ | | | Branch (176:4): [True: 18.7k, False: 1.74M] | | | Branch (176:16): [True: 3.18k, False: 1.74M] | | | Branch (176:28): [True: 1, False: 1.74M] | | ------------------ ------------------ 339| 36.8k| *s++ = '\\'; 340| | 341| 1.78M| if (p->str->c_string[i] == '\x00') ------------------ | Branch (341:11): [True: 658k, False: 1.12M] ------------------ 342| 658k| { 343| 658k| *s++ = '\\'; 344| 658k| *s++ = 'x'; 345| 658k| *s++ = '0'; 346| 658k| *s++ = '0'; 347| 658k| } 348| 1.12M| else 349| 1.12M| *s++ = p->str->c_string[i]; 350| 1.78M| } 351| | 352| 7.53k| if (p->next != NULL) ------------------ | Branch (352:9): [True: 5.17k, False: 2.36k] ------------------ 353| 5.17k| *s++ = '|'; 354| | 355| 7.53k| p = p->next; 356| 7.53k| } 357| 2.36k| *s++ = ')'; 358| 2.36k| *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| 2.36k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 2.36k| { \ | | 140| 2.36k| int __error = (x); \ | | 141| 2.36k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.36k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 2.36k] | | ------------------ | | 142| 2.36k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 2.36k| } ------------------ 364| 2.36k| yr_re_parse(re_str, re_ast, re_error), yr_free(re_str)); 365| | 366| 2.36k| yr_free(re_str); 367| | 368| 2.36k| return ERROR_SUCCESS; ------------------ | | 40| 2.36k|#define ERROR_SUCCESS 0 ------------------ 369| 2.36k|} yr_base64_ast_from_string: 388| 2.36k|{ 389| 2.36k| BASE64_NODE* head = NULL; 390| 2.36k| BASE64_NODE* tail = NULL; 391| 2.36k| SIZED_STRING* wide_str; 392| | 393| 2.36k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 2.36k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (393:7): [True: 672, False: 1.68k] ------------------ 394| 672| { 395| 672| wide_str = ss_convert_to_wide(in_str); 396| | 397| 672| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 672|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (397:9): [True: 384, False: 288] ------------------ 398| 384| { 399| 384| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 384| { \ | | 140| 384| int __error = (x); \ | | 141| 384| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 384|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 384] | | ------------------ | | 142| 384| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 384| } ------------------ 400| 384| _yr_base64_create_nodes(wide_str, modifier.alphabet, 0, &head, &tail), 401| 384| { // Cleanup 402| 384| strcpy(error->message, "Failure encoding base64 wide string"); 403| 384| yr_free(wide_str); 404| 384| _yr_base64_destroy_nodes(head); 405| 384| }); 406| 384| } 407| | 408| 672| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 672|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (408:9): [True: 294, False: 378] ------------------ 409| 294| { 410| 294| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 294| { \ | | 140| 294| int __error = (x); \ | | 141| 294| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 294|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 294] | | ------------------ | | 142| 294| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 294| } ------------------ 411| 294| _yr_base64_create_nodes(wide_str, modifier.alphabet, 1, &head, &tail), 412| 294| { // Cleanup 413| 294| strcpy(error->message, "Failure encoding base64wide wide string"); 414| 294| yr_free(wide_str); 415| 294| _yr_base64_destroy_nodes(head); 416| 294| }); 417| 294| } 418| | 419| 672| yr_free(wide_str); 420| 672| } 421| | 422| 2.36k| if (modifier.flags & STRING_FLAGS_ASCII) ------------------ | | 69| 2.36k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (422:7): [True: 368, False: 1.99k] ------------------ 423| 368| { 424| 368| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 368|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (424:9): [True: 190, False: 178] ------------------ 425| 190| { 426| 190| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 190| { \ | | 140| 190| int __error = (x); \ | | 141| 190| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 190|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 190] | | ------------------ | | 142| 190| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 190| } ------------------ 427| 190| _yr_base64_create_nodes(in_str, modifier.alphabet, 0, &head, &tail), 428| 190| { // Cleanup 429| 190| strcpy(error->message, "Failure encoding base64 ascii string"); 430| 190| _yr_base64_destroy_nodes(head); 431| 190| }); 432| 190| } 433| | 434| 368| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 368|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (434:9): [True: 178, False: 190] ------------------ 435| 178| { 436| 178| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 178| { \ | | 140| 178| int __error = (x); \ | | 141| 178| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 178|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 178] | | ------------------ | | 142| 178| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 178| } ------------------ 437| 178| _yr_base64_create_nodes(in_str, modifier.alphabet, 1, &head, &tail), 438| 178| { // Cleanup 439| 178| strcpy(error->message, "Failure encoding base64wide ascii string"); 440| 178| _yr_base64_destroy_nodes(head); 441| 178| }); 442| 178| } 443| 368| } 444| | 445| 2.36k| if (!(modifier.flags & STRING_FLAGS_WIDE) && ------------------ | | 70| 2.36k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (445:7): [True: 1.68k, False: 672] ------------------ 446| 2.36k| !(modifier.flags & STRING_FLAGS_ASCII)) ------------------ | | 69| 1.68k|#define STRING_FLAGS_ASCII 0x08 ------------------ | Branch (446:7): [True: 1.32k, False: 368] ------------------ 447| 1.32k| { 448| 1.32k| if (modifier.flags & STRING_FLAGS_BASE64) ------------------ | | 87| 1.32k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (448:9): [True: 817, False: 503] ------------------ 449| 817| { 450| 817| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 817| { \ | | 140| 817| int __error = (x); \ | | 141| 817| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 817|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 817] | | ------------------ | | 142| 817| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 817| } ------------------ 451| 817| _yr_base64_create_nodes(in_str, modifier.alphabet, 0, &head, &tail), 452| 817| { // Cleanup 453| 817| strcpy(error->message, "Failure encoding base64 string"); 454| 817| _yr_base64_destroy_nodes(head); 455| 817| }); 456| 817| } 457| | 458| 1.32k| if (modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 1.32k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (458:9): [True: 968, False: 352] ------------------ 459| 968| { 460| 968| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 968| { \ | | 140| 968| int __error = (x); \ | | 141| 968| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 968|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 968] | | ------------------ | | 142| 968| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 968| } ------------------ 461| 968| _yr_base64_create_nodes(in_str, modifier.alphabet, 1, &head, &tail), 462| 968| { // Cleanup 463| 968| strcpy(error->message, "Failure encoding base64wide string"); 464| 968| _yr_base64_destroy_nodes(head); 465| 968| }); 466| 968| } 467| 1.32k| } 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| 2.36k| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 2.36k| { \ | | 140| 2.36k| int __error = (x); \ | | 141| 2.36k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.36k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 2.36k] | | ------------------ | | 142| 2.36k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 2.36k| } ------------------ 476| 2.36k| _yr_base64_create_regexp(head, re_ast, error), 477| 2.36k| _yr_base64_destroy_nodes(head)); 478| | 479| 2.36k| _yr_base64_destroy_nodes(head); 480| | 481| 2.36k| return ERROR_SUCCESS; ------------------ | | 40| 2.36k|#define ERROR_SUCCESS 0 ------------------ 482| 2.36k|} base64.c:_yr_base64_create_nodes: 207| 2.83k|{ 208| 2.83k| SIZED_STRING* encoded_str; 209| 2.83k| SIZED_STRING* final_str; 210| 2.83k| BASE64_NODE* node; 211| | 212| 2.83k| int pad; 213| | 214| 11.3k| for (int i = 0; i <= 2; i++) ------------------ | Branch (214:19): [True: 8.49k, False: 2.83k] ------------------ 215| 8.49k| { 216| 8.49k| if (i == 1 && str->length == 1) ------------------ | Branch (216:9): [True: 2.83k, False: 5.66k] | Branch (216:19): [True: 957, False: 1.87k] ------------------ 217| 957| continue; 218| | 219| 7.53k| node = (BASE64_NODE*) yr_malloc(sizeof(BASE64_NODE)); 220| 7.53k| if (node == NULL) ------------------ | Branch (220:9): [True: 0, False: 7.53k] ------------------ 221| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 222| | 223| 7.53k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 149| 7.53k| { \ | | 150| 7.53k| if ((x) == NULL) \ | | ------------------ | | | Branch (150:9): [True: 0, False: 7.53k] | | ------------------ | | 151| 7.53k| { \ | | 152| 0| cleanup; \ | | 153| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 154| 0| } \ | | 155| 7.53k| } ------------------ 224| 7.53k| encoded_str = _yr_modified_base64_encode(str, alphabet, i, &pad), 225| 7.53k| 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| 7.53k| FAIL_ON_NULL_WITH_CLEANUP( ------------------ | | 149| 7.53k| { \ | | 150| 7.53k| if ((x) == NULL) \ | | ------------------ | | | Branch (150:9): [True: 0, False: 7.53k] | | ------------------ | | 151| 7.53k| { \ | | 152| 0| cleanup; \ | | 153| 0| return ERROR_INSUFFICIENT_MEMORY; \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | 154| 0| } \ | | 155| 7.53k| } ------------------ 230| 7.53k| final_str = _yr_base64_get_base64_substring(encoded_str, wide, i, pad), 231| 7.53k| { 232| 7.53k| yr_free(encoded_str); 233| 7.53k| yr_free(node); 234| 7.53k| }); 235| | 236| 7.53k| yr_free(encoded_str); 237| | 238| 7.53k| node->str = final_str; 239| 7.53k| node->escaped = _yr_base64_count_escaped(node->str); 240| 7.53k| node->next = NULL; 241| | 242| 7.53k| if (*head == NULL) ------------------ | Branch (242:9): [True: 2.36k, False: 5.17k] ------------------ 243| 2.36k| *head = node; 244| | 245| 7.53k| if (*tail == NULL) ------------------ | Branch (245:9): [True: 2.36k, False: 5.17k] ------------------ 246| 2.36k| { 247| 2.36k| *tail = node; 248| 2.36k| } 249| 5.17k| else 250| 5.17k| { 251| 5.17k| (*tail)->next = node; 252| 5.17k| *tail = node; 253| 5.17k| } 254| 7.53k| } 255| | 256| 2.83k| return ERROR_SUCCESS; ------------------ | | 40| 2.83k|#define ERROR_SUCCESS 0 ------------------ 257| 2.83k|} base64.c:_yr_modified_base64_encode: 52| 7.53k|{ 53| 7.53k| uint8_t* src = (uint8_t*) in->c_string; 54| 7.53k| size_t len = in->length; 55| 7.53k| SIZED_STRING* out; 56| 7.53k| uint8_t* p; 57| 7.53k| uint8_t* end; 58| 7.53k| char* alphabet_str = alphabet->c_string; 59| 7.53k| uint8_t* tmp; 60| 7.53k| int j; 61| | 62| 7.53k| *pad = ((i + len) % 3) ? 3 - ((i + len) % 3) : 0; ------------------ | Branch (62:10): [True: 4.70k, False: 2.83k] ------------------ 63| | 64| | // Add "i" for the number of prepended bytes. 65| 7.53k| out = (SIZED_STRING*) yr_malloc( 66| 7.53k| sizeof(SIZED_STRING) + i + ((len * 4 + 3) / 3) + *pad); 67| | 68| 7.53k| if (out == NULL) ------------------ | Branch (68:7): [True: 0, False: 7.53k] ------------------ 69| 0| return NULL; 70| | 71| 7.53k| tmp = (uint8_t*) yr_malloc(sizeof(uint8_t) * (len + i)); 72| 7.53k| if (tmp == NULL) ------------------ | Branch (72:7): [True: 0, False: 7.53k] ------------------ 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| 15.0k| for (j = 0; j < i; j++) tmp[j] = 'A'; ------------------ | Branch (80:15): [True: 7.53k, False: 7.53k] ------------------ 81| | 82| 7.53k| memcpy(tmp + j, src, len); 83| 7.53k| src = tmp; 84| | 85| 7.53k| p = (uint8_t*) out->c_string; 86| 7.53k| end = src + len + j; 87| | 88| 289k| while (end - src >= 3) ------------------ | Branch (88:10): [True: 281k, False: 7.53k] ------------------ 89| 281k| { 90| 281k| *p++ = alphabet_str[src[0] >> 2]; 91| 281k| *p++ = alphabet_str[((src[0] & 0x03) << 4 | src[1] >> 4)]; 92| 281k| *p++ = alphabet_str[((src[1] & 0x0f) << 2 | (src[2] >> 6))]; 93| 281k| *p++ = alphabet_str[src[2] & 0x3f]; 94| 281k| src += 3; 95| 281k| } 96| | 97| | // Handle remaining bytes and padding. 98| 7.53k| if (end - src) ------------------ | Branch (98:7): [True: 4.70k, False: 2.83k] ------------------ 99| 4.70k| { 100| 4.70k| *p++ = alphabet_str[src[0] >> 2]; 101| 4.70k| if (end - src == 1) ------------------ | Branch (101:9): [True: 2.83k, False: 1.87k] ------------------ 102| 2.83k| { 103| 2.83k| *p++ = alphabet_str[(src[0] & 0x03) << 4]; 104| 2.83k| *p++ = '='; 105| 2.83k| } 106| 1.87k| else 107| 1.87k| { 108| 1.87k| *p++ = alphabet_str[((src[0] & 0x03) << 4 | src[1] >> 4)]; 109| 1.87k| *p++ = alphabet_str[(src[1] & 0x0f) << 2]; 110| 1.87k| } 111| 4.70k| *p++ = '='; 112| 4.70k| } 113| | 114| 7.53k| yr_free(tmp); 115| 7.53k| out->length = (uint32_t)(p - (uint8_t*) out->c_string); 116| | 117| 7.53k| return out; 118| 7.53k|} base64.c:_yr_base64_get_base64_substring: 134| 7.53k|{ 135| 7.53k| SIZED_STRING* new_str; 136| 7.53k| SIZED_STRING* final_str; 137| 7.53k| char* start; 138| 7.53k| uint32_t length; 139| 7.53k| int trailing; 140| 7.53k| int leading; 141| | 142| 7.53k| trailing = pad ? pad + 1 : 0; ------------------ | Branch (142:14): [True: 4.70k, False: 2.83k] ------------------ 143| 7.53k| leading = i ? i + 1 : 0; ------------------ | Branch (143:13): [True: 4.70k, False: 2.83k] ------------------ 144| | 145| 7.53k| length = encoded_str->length - (leading + trailing); 146| | 147| 7.53k| new_str = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 148| | 149| 7.53k| if (new_str == NULL) ------------------ | Branch (149:7): [True: 0, False: 7.53k] ------------------ 150| 0| return NULL; 151| | 152| 7.53k| start = encoded_str->c_string + leading; 153| | 154| 7.53k| memcpy(new_str->c_string, start, length); 155| | 156| 7.53k| new_str->length = length; 157| 7.53k| new_str->c_string[length] = '\0'; 158| | 159| 7.53k| if (wide) ------------------ | Branch (159:7): [True: 3.92k, False: 3.61k] ------------------ 160| 3.92k| { 161| 3.92k| final_str = ss_convert_to_wide(new_str); 162| 3.92k| yr_free(new_str); 163| 3.92k| } 164| 3.61k| else 165| 3.61k| { 166| 3.61k| final_str = new_str; 167| 3.61k| } 168| | 169| 7.53k| return final_str; 170| 7.53k|} base64.c:_yr_base64_count_escaped: 183| 7.53k|{ 184| 7.53k| int c = 0; 185| | 186| 1.78M| for (uint32_t i = 0; i < str->length; i++) ------------------ | Branch (186:24): [True: 1.78M, False: 7.53k] ------------------ 187| 1.78M| { 188| | // We must be careful to escape null bytes because they break the RE lexer. 189| 1.78M| if (IS_METACHAR(str->c_string[i])) ------------------ | | 174| 1.78M| (x == '\\' || x == '^' || x == '$' || x == '|' || x == '(' || x == ')' || \ | | ------------------ | | | Branch (174:4): [True: 0, False: 1.78M] | | | Branch (174:17): [True: 14, False: 1.78M] | | | Branch (174:29): [True: 6.46k, False: 1.77M] | | | Branch (174:41): [True: 509, False: 1.77M] | | | Branch (174:53): [True: 87, False: 1.77M] | | | Branch (174:65): [True: 5.18k, False: 1.76M] | | ------------------ | | 175| 1.78M| x == '[' || x == ']' || x == '*' || x == '?' || x == '{' || x == ',' || \ | | ------------------ | | | Branch (175:4): [True: 27, False: 1.76M] | | | Branch (175:16): [True: 1.60k, False: 1.76M] | | | Branch (175:28): [True: 9, False: 1.76M] | | | Branch (175:40): [True: 2, False: 1.76M] | | | Branch (175:52): [True: 1, False: 1.76M] | | | Branch (175:64): [True: 994, False: 1.76M] | | ------------------ | | 176| 1.78M| x == '.' || x == '+' || x == '}') | | ------------------ | | | Branch (176:4): [True: 18.7k, False: 1.74M] | | | Branch (176:16): [True: 3.18k, False: 1.74M] | | | Branch (176:28): [True: 1, False: 1.74M] | | ------------------ ------------------ 190| 36.8k| c++; 191| 1.74M| else if (str->c_string[i] == '\x00') ------------------ | Branch (191:14): [True: 658k, False: 1.08M] ------------------ 192| 658k| c += 4; 193| 1.78M| } 194| | 195| 7.53k| return c; 196| 7.53k|} base64.c:_yr_base64_destroy_nodes: 285| 2.36k|{ 286| 2.36k| BASE64_NODE* p = head; 287| 2.36k| BASE64_NODE* next; 288| | 289| 9.89k| while (p != NULL) ------------------ | Branch (289:10): [True: 7.53k, False: 2.36k] ------------------ 290| 7.53k| { 291| 7.53k| yr_free(p->str); 292| 7.53k| next = p->next; 293| 7.53k| yr_free(p); 294| 7.53k| p = next; 295| 7.53k| } 296| 2.36k|} yr_bitmask_find_non_colliding_offset: 64| 182k|{ 65| 182k| 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| 182k| 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| 182k| for (i = *off_a / YR_BITMASK_SLOT_BITS; ------------------ | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 75| 35.9M| i <= len_a / YR_BITMASK_SLOT_BITS && a[i] == -1L; ------------------ | | 56| 71.8M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (75:8): [True: 35.9M, False: 0] | Branch (75:45): [True: 35.7M, False: 182k] ------------------ 76| 35.7M| i++) 77| 35.7M| ; 78| | 79| 182k| *off_a = i; 80| | 81| 8.10M| for (; i <= len_a / YR_BITMASK_SLOT_BITS; i++) ------------------ | | 56| 8.10M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (81:10): [True: 8.10M, False: 0] ------------------ 82| 8.10M| { 83| | // The slot is filled with 1s, we can safely skip it. 84| 8.10M| if (a[i] == -1L) ------------------ | Branch (84:9): [True: 1.58M, False: 6.52M] ------------------ 85| 1.58M| continue; 86| | 87| 417M| for (j = 0; j <= yr_min(len_a, YR_BITMASK_SLOT_BITS - 1); j++) ------------------ | | 107| 417M|#define yr_min(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (107:23): [True: 0, False: 417M] | | ------------------ ------------------ | Branch (87:17): [True: 411M, False: 6.33M] ------------------ 88| 411M| { 89| 411M| bool found = true; 90| | 91| 498M| for (k = 0; k <= len_b / YR_BITMASK_SLOT_BITS; k++) ------------------ | | 56| 498M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (91:19): [True: 498M, False: 182k] ------------------ 92| 498M| { 93| 498M| YR_BITMASK m = b[k] << j; ------------------ | | 54| 498M|#define YR_BITMASK unsigned long ------------------ 94| | 95| 498M| if (j > 0 && k > 0) ------------------ | Branch (95:13): [True: 490M, False: 7.67M] | Branch (95:22): [True: 85.5M, False: 405M] ------------------ 96| 85.5M| m |= b[k - 1] >> (YR_BITMASK_SLOT_BITS - j); ------------------ | | 56| 85.5M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 97| | 98| 498M| if ((i + k <= len_a / YR_BITMASK_SLOT_BITS) && (m & a[i + k]) != 0) ------------------ | | 56| 498M|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ | Branch (98:13): [True: 498M, False: 371] | Branch (98:56): [True: 411M, False: 86.8M] ------------------ 99| 411M| { 100| 411M| found = false; 101| 411M| break; 102| 411M| } 103| 498M| } 104| | 105| 411M| if (found) ------------------ | Branch (105:11): [True: 182k, False: 411M] ------------------ 106| 182k| return i * YR_BITMASK_SLOT_BITS + j; ------------------ | | 56| 182k|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) ------------------ 107| 411M| } 108| 6.52M| } 109| | 110| 0| return len_a; 111| 182k|} _yr_compiler_default_include_callback: 69| 565|{ 70| 565|#ifndef _MSC_VER 71| 565| struct stat stbuf; 72| 565|#endif 73| | 74| 565| char* file_buffer; 75| | 76| |#ifdef _MSC_VER 77| | long file_size; 78| |#else 79| 565| off_t file_size; 80| 565|#endif 81| | 82| 565| 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| 565| fd = open(include_name, O_RDONLY); 90| 565|#endif 91| | 92| 565| if (fd == -1) ------------------ | Branch (92:7): [True: 405, False: 160] ------------------ 93| 405| 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| 38.0k|{ 161| 38.0k| return (YR_RULE*) yr_arena_get_ptr( 162| 38.0k| compiler->arena, YR_RULES_TABLE, rule_idx * sizeof(YR_RULE)); ------------------ | | 58| 38.0k|#define YR_RULES_TABLE 1 ------------------ 163| 38.0k|} _yr_compiler_store_data: 177| 57.6k|{ 178| | // Check if the data is already in YR_SZ_POOL by using a hash table. 179| 57.6k| uint32_t offset = yr_hash_table_lookup_uint32_raw_key( 180| 57.6k| compiler->sz_table, data, data_length, NULL); 181| | 182| 57.6k| if (offset == UINT32_MAX) ------------------ | Branch (182:7): [True: 11.3k, False: 46.2k] ------------------ 183| 11.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| 11.3k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 11.3k| { \ | | 132| 11.3k| int __error = (x); \ | | 133| 11.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 11.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 11.3k] | | ------------------ | | 134| 11.3k| return __error; \ | | 135| 11.3k| } ------------------ 188| 11.3k| compiler->arena, YR_SZ_POOL, data, data_length, ref)); 189| | 190| 11.3k| FAIL_ON_ERROR(yr_hash_table_add_uint32_raw_key( ------------------ | | 131| 11.3k| { \ | | 132| 11.3k| int __error = (x); \ | | 133| 11.3k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 11.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 11.3k] | | ------------------ | | 134| 11.3k| return __error; \ | | 135| 11.3k| } ------------------ 191| 11.3k| compiler->sz_table, data, data_length, NULL, ref->offset)); 192| 11.3k| } 193| 46.2k| else 194| 46.2k| { 195| 46.2k| ref->buffer_id = YR_SZ_POOL; ------------------ | | 62| 46.2k|#define YR_SZ_POOL 5 ------------------ 196| 46.2k| ref->offset = offset; 197| 46.2k| } 198| | 199| 57.6k| return ERROR_SUCCESS; ------------------ | | 40| 57.6k|#define ERROR_SUCCESS 0 ------------------ 200| 57.6k|} _yr_compiler_store_string: 209| 37.0k|{ 210| 37.0k| return _yr_compiler_store_data( 211| 37.0k| compiler, 212| 37.0k| (void*) string, 213| 37.0k| strlen(string) + 1, // include the null terminator 214| 37.0k| ref); 215| 37.0k|} yr_compiler_create: 218| 1.27k|{ 219| 1.27k| int result; 220| 1.27k| YR_COMPILER* new_compiler; 221| | 222| 1.27k| new_compiler = (YR_COMPILER*) yr_calloc(1, sizeof(YR_COMPILER)); 223| | 224| 1.27k| if (new_compiler == NULL) ------------------ | Branch (224:7): [True: 0, False: 1.27k] ------------------ 225| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 226| | 227| 1.27k| new_compiler->current_rule_idx = UINT32_MAX; 228| 1.27k| new_compiler->next_rule_idx = 0; 229| 1.27k| new_compiler->current_string_idx = 0; 230| 1.27k| new_compiler->current_namespace_idx = 0; 231| 1.27k| new_compiler->current_meta_idx = 0; 232| 1.27k| new_compiler->num_namespaces = 0; 233| 1.27k| new_compiler->errors = 0; 234| 1.27k| new_compiler->callback = NULL; 235| 1.27k| new_compiler->rules = NULL; 236| 1.27k| new_compiler->include_callback = _yr_compiler_default_include_callback; 237| 1.27k| new_compiler->incl_clbk_user_data = NULL; 238| 1.27k| new_compiler->include_free = _yr_compiler_default_include_free; 239| 1.27k| new_compiler->re_ast_callback = NULL; 240| 1.27k| new_compiler->re_ast_clbk_user_data = NULL; 241| 1.27k| new_compiler->last_error = ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 242| 1.27k| new_compiler->last_error_line = 0; 243| 1.27k| new_compiler->current_line = 0; 244| 1.27k| new_compiler->file_name_stack_ptr = 0; 245| 1.27k| new_compiler->fixup_stack_head = NULL; 246| 1.27k| new_compiler->loop_index = -1; 247| 1.27k| new_compiler->loop_for_of_var_index = -1; 248| | 249| 1.27k| new_compiler->atoms_config.get_atom_quality = yr_atoms_heuristic_quality; 250| 1.27k| new_compiler->atoms_config.quality_warning_threshold = 251| 1.27k| YR_ATOM_QUALITY_WARNING_THRESHOLD; ------------------ | | 85| 1.27k| YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 72| 1.27k|#define YR_MAX_ATOM_QUALITY 255 | | ------------------ | | YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 68| 1.27k|#define YR_MAX_ATOM_LENGTH 4 | | ------------------ ------------------ 252| | 253| 1.27k| result = yr_hash_table_create(5000, &new_compiler->rules_table); 254| | 255| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (255:7): [True: 1.27k, False: 0] ------------------ 256| 1.27k| result = yr_hash_table_create(1000, &new_compiler->objects_table); 257| | 258| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (258:7): [True: 1.27k, False: 0] ------------------ 259| 1.27k| result = yr_hash_table_create(10000, &new_compiler->strings_table); 260| | 261| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (261:7): [True: 1.27k, False: 0] ------------------ 262| 1.27k| result = yr_hash_table_create( 263| 1.27k| 1000, &new_compiler->wildcard_identifiers_table); 264| | 265| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (265:7): [True: 1.27k, False: 0] ------------------ 266| 1.27k| result = yr_hash_table_create(10000, &new_compiler->sz_table); 267| | 268| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (268:7): [True: 1.27k, False: 0] ------------------ 269| 1.27k| result = yr_arena_create(YR_NUM_SECTIONS, 1048576, &new_compiler->arena); ------------------ | | 72| 1.27k|#define YR_NUM_SECTIONS 12 ------------------ 270| | 271| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (271:7): [True: 1.27k, False: 0] ------------------ 272| 1.27k| result = yr_ac_automaton_create( 273| 1.27k| new_compiler->arena, &new_compiler->automaton); 274| | 275| 1.27k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (275:7): [True: 1.27k, False: 0] ------------------ 276| 1.27k| { 277| 1.27k| *compiler = new_compiler; 278| 1.27k| } 279| 0| else // if error, do cleanup 280| 0| { 281| 0| yr_compiler_destroy(new_compiler); 282| 0| } 283| | 284| 1.27k| return result; 285| 1.27k|} yr_compiler_destroy: 288| 1.27k|{ 289| 1.27k| if (compiler->arena != NULL) ------------------ | Branch (289:7): [True: 1.27k, False: 0] ------------------ 290| 1.27k| yr_arena_release(compiler->arena); 291| | 292| 1.27k| if (compiler->automaton != NULL) ------------------ | Branch (292:7): [True: 1.27k, False: 0] ------------------ 293| 1.27k| yr_ac_automaton_destroy(compiler->automaton); 294| | 295| 1.27k| if (compiler->rules_table != NULL) ------------------ | Branch (295:7): [True: 1.27k, False: 0] ------------------ 296| 1.27k| yr_hash_table_destroy(compiler->rules_table, NULL); 297| | 298| 1.27k| if (compiler->strings_table != NULL) ------------------ | Branch (298:7): [True: 1.27k, False: 0] ------------------ 299| 1.27k| yr_hash_table_destroy(compiler->strings_table, NULL); 300| | 301| 1.27k| if (compiler->wildcard_identifiers_table != NULL) ------------------ | Branch (301:7): [True: 1.27k, False: 0] ------------------ 302| 1.27k| yr_hash_table_destroy(compiler->wildcard_identifiers_table, NULL); 303| | 304| 1.27k| if (compiler->sz_table != NULL) ------------------ | Branch (304:7): [True: 1.27k, False: 0] ------------------ 305| 1.27k| yr_hash_table_destroy(compiler->sz_table, NULL); 306| | 307| 1.27k| if (compiler->objects_table != NULL) ------------------ | Branch (307:7): [True: 1.27k, False: 0] ------------------ 308| 1.27k| yr_hash_table_destroy( 309| 1.27k| compiler->objects_table, 310| 1.27k| (YR_HASH_TABLE_FREE_VALUE_FUNC) yr_object_destroy); 311| | 312| 1.27k| if (compiler->atoms_config.free_quality_table) ------------------ | Branch (312:7): [True: 0, False: 1.27k] ------------------ 313| 0| yr_free(compiler->atoms_config.quality_table); 314| | 315| 1.27k| for (int i = 0; i < compiler->file_name_stack_ptr; i++) ------------------ | Branch (315:19): [True: 0, False: 1.27k] ------------------ 316| 0| yr_free(compiler->file_name_stack[i]); 317| | 318| 1.27k| YR_FIXUP* fixup = compiler->fixup_stack_head; 319| | 320| 9.34k| while (fixup != NULL) ------------------ | Branch (320:10): [True: 8.07k, False: 1.27k] ------------------ 321| 8.07k| { 322| 8.07k| YR_FIXUP* next_fixup = fixup->next; 323| 8.07k| yr_free(fixup); 324| 8.07k| fixup = next_fixup; 325| 8.07k| } 326| | 327| 1.27k| yr_free(compiler); 328| 1.27k|} _yr_compiler_get_var_frame: 491| 2.19k|{ 492| 2.19k| int i, result = 0; 493| | 494| 3.22k| for (i = 0; i < compiler->loop_index; i++) ------------------ | Branch (494:15): [True: 1.03k, False: 2.19k] ------------------ 495| 1.03k| { 496| 1.03k| result += compiler->loop[i].vars_count + 497| 1.03k| compiler->loop[i].vars_internal_count; 498| 1.03k| } 499| | 500| 2.19k| return result; 501| 2.19k|} yr_compiler_get_current_file_name: 504| 565|{ 505| 565| if (compiler->file_name_stack_ptr > 0) ------------------ | Branch (505:7): [True: 0, False: 565] ------------------ 506| 0| { 507| 0| return compiler->file_name_stack[compiler->file_name_stack_ptr - 1]; 508| 0| } 509| 565| else 510| 565| { 511| 565| return NULL; 512| 565| } 513| 565|} yr_compiler_add_string: 636| 1.27k|{ 637| | // Don't allow calls to yr_compiler_add_string() after 638| | // yr_compiler_get_rules() has been called. 639| 1.27k| assert(compiler->rules == NULL); 640| | 641| | // Don't allow calls to yr_compiler_add_string() if a previous call to 642| | // yr_compiler_add_XXXX failed. 643| 1.27k| assert(compiler->errors == 0); 644| | 645| 1.27k| if (namespace_ != NULL) ------------------ | Branch (645:7): [True: 0, False: 1.27k] ------------------ 646| 0| compiler->last_error = _yr_compiler_set_namespace(compiler, namespace_); 647| 1.27k| else 648| 1.27k| compiler->last_error = _yr_compiler_set_namespace(compiler, "default"); 649| | 650| 1.27k| if (compiler->last_error != ERROR_SUCCESS) ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ | Branch (650:7): [True: 0, False: 1.27k] ------------------ 651| 0| return ++compiler->errors; 652| | 653| 1.27k| return yr_lex_parse_rules_string(rules_string, compiler); 654| 1.27k|} yr_compiler_get_rules: 704| 132|{ 705| | // Don't allow calls to yr_compiler_get_rules() if a previous call to 706| | // yr_compiler_add_XXXX failed. 707| 132| assert(compiler->errors == 0); 708| | 709| 132| *rules = NULL; 710| | 711| 132| if (compiler->rules == NULL) ------------------ | Branch (711:7): [True: 132, False: 0] ------------------ 712| 132| FAIL_ON_ERROR(_yr_compiler_compile_rules(compiler)); ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 713| | 714| 132| *rules = compiler->rules; 715| | 716| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 717| 132|} compiler.c:_yr_compiler_set_namespace: 518| 1.27k|{ 519| 1.27k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 520| 1.27k| compiler->arena, YR_NAMESPACES_TABLE, 0); ------------------ | | 57| 1.27k|#define YR_NAMESPACES_TABLE 0 ------------------ 521| | 522| 1.27k| bool found = false; 523| | 524| 1.27k| for (int i = 0; i < compiler->num_namespaces; i++, ns++) ------------------ | Branch (524:19): [True: 0, False: 1.27k] ------------------ 525| 0| { 526| 0| if (strcmp(ns->name, namespace_) == 0) ------------------ | Branch (526:9): [True: 0, False: 0] ------------------ 527| 0| { 528| 0| found = true; 529| 0| compiler->current_namespace_idx = i; 530| 0| break; 531| 0| } 532| 0| } 533| | 534| 1.27k| if (!found) ------------------ | Branch (534:7): [True: 1.27k, False: 0] ------------------ 535| 1.27k| { 536| 1.27k| YR_ARENA_REF ref; 537| | 538| 1.27k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 1.27k| { \ | | 132| 1.27k| int __error = (x); \ | | 133| 1.27k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.27k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.27k] | | ------------------ | | 134| 1.27k| return __error; \ | | 135| 1.27k| } ------------------ 539| 1.27k| compiler->arena, 540| 1.27k| YR_NAMESPACES_TABLE, 541| 1.27k| sizeof(YR_NAMESPACE), 542| 1.27k| &ref, 543| 1.27k| offsetof(YR_NAMESPACE, name), 544| 1.27k| EOL)); 545| | 546| 1.27k| ns = (YR_NAMESPACE*) yr_arena_ref_to_ptr(compiler->arena, &ref); 547| | 548| 1.27k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, namespace_, &ref)); ------------------ | | 131| 1.27k| { \ | | 132| 1.27k| int __error = (x); \ | | 133| 1.27k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.27k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.27k] | | ------------------ | | 134| 1.27k| return __error; \ | | 135| 1.27k| } ------------------ 549| | 550| 1.27k| ns->name = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 551| 1.27k| ns->idx = compiler->num_namespaces; 552| | 553| 1.27k| compiler->current_namespace_idx = compiler->num_namespaces; 554| 1.27k| compiler->num_namespaces++; 555| 1.27k| } 556| | 557| 1.27k| return ERROR_SUCCESS; ------------------ | | 40| 1.27k|#define ERROR_SUCCESS 0 ------------------ 558| 1.27k|} compiler.c:_yr_compiler_compile_rules: 657| 132|{ 658| 132| YR_RULE null_rule; 659| 132| YR_EXTERNAL_VARIABLE null_external; 660| | 661| 132| uint8_t halt = OP_HALT; ------------------ | | 46| 132|#define OP_HALT 255 ------------------ 662| | 663| | // Write halt instruction at the end of code. 664| 132| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 665| 132| compiler->arena, YR_CODE_SECTION, &halt, sizeof(uint8_t), NULL)); 666| | 667| | // Write a null rule indicating the end. 668| 132| memset(&null_rule, 0xFA, sizeof(YR_RULE)); 669| 132| null_rule.flags = RULE_FLAGS_NULL; ------------------ | | 54| 132|#define RULE_FLAGS_NULL 0x04 ------------------ 670| | 671| 132| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 672| 132| compiler->arena, YR_RULES_TABLE, &null_rule, sizeof(YR_RULE), NULL)); 673| | 674| | // Write a null external indicating the end. 675| 132| memset(&null_external, 0xFA, sizeof(YR_EXTERNAL_VARIABLE)); 676| 132| null_external.type = EXTERNAL_VARIABLE_TYPE_NULL; ------------------ | | 144| 132|#define EXTERNAL_VARIABLE_TYPE_NULL 0 ------------------ 677| | 678| 132| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 679| 132| compiler->arena, 680| 132| YR_EXTERNAL_VARIABLES_TABLE, 681| 132| &null_external, 682| 132| sizeof(YR_EXTERNAL_VARIABLE), 683| 132| NULL)); 684| | 685| | // Write Aho-Corasick automaton to arena. 686| 132| FAIL_ON_ERROR(yr_ac_compile(compiler->automaton, compiler->arena)); ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 687| | 688| 132| YR_ARENA_REF ref; 689| | 690| 132| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 691| 132| compiler->arena, YR_SUMMARY_SECTION, sizeof(YR_SUMMARY), &ref, EOL)); 692| | 693| 132| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_ref_to_ptr( 694| 132| compiler->arena, &ref); 695| | 696| 132| summary->num_namespaces = compiler->num_namespaces; 697| 132| summary->num_rules = compiler->next_rule_idx; 698| 132| summary->num_strings = compiler->current_string_idx; 699| | 700| 132| return yr_rules_from_arena(compiler->arena, &compiler->rules); 701| 132|} yara_yyparse: 1881| 1.27k|{ 1882| |/* Lookahead token kind. */ 1883| 1.27k|int yychar; 1884| | 1885| | 1886| |/* The semantic value of the lookahead symbol. */ 1887| |/* Default value used for initialization, for pacifying older GCCs 1888| | or non-GCC compilers. */ 1889| 1.27k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 726| 1.27k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1890| 1.27k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 726| 1.27k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1891| | 1892| | /* Number of syntax errors so far. */ 1893| 1.27k| int yynerrs = 0; 1894| | 1895| 1.27k| yy_state_fast_t yystate = 0; 1896| | /* Number of tokens to shift before error messages enabled. */ 1897| 1.27k| int yyerrstatus = 0; 1898| | 1899| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1900| | to reallocate them elsewhere. */ 1901| | 1902| | /* Their size. */ 1903| 1.27k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 633| 1.27k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1470| 1.27k|# define YYINITDEPTH 200 ------------------ 1904| | 1905| | /* The state stack: array, bottom, top. */ 1906| 1.27k| yy_state_t yyssa[YYINITDEPTH]; 1907| 1.27k| yy_state_t *yyss = yyssa; 1908| 1.27k| yy_state_t *yyssp = yyss; 1909| | 1910| | /* The semantic value stack: array, bottom, top. */ 1911| 1.27k| YYSTYPE yyvsa[YYINITDEPTH]; 1912| 1.27k| YYSTYPE *yyvs = yyvsa; 1913| 1.27k| YYSTYPE *yyvsp = yyvs; 1914| | 1915| 1.27k| int yyn; 1916| | /* The return value of yyparse. */ 1917| 1.27k| int yyresult; 1918| | /* Lookahead symbol kind. */ 1919| 1.27k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1920| | /* The variables used to return semantic value and location from the 1921| | action routines. */ 1922| 1.27k| YYSTYPE yyval; 1923| | 1924| | /* Buffer for error messages, and its allocated size. */ 1925| 1.27k| char yymsgbuf[128]; 1926| 1.27k| char *yymsg = yymsgbuf; 1927| 1.27k| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 633| 1.27k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1928| | 1929| 1.27k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1930| | 1931| | /* The number of symbols on the RHS of the reduced rule. 1932| | Keep to zero when no symbol should be popped. */ 1933| 1.27k| int yylen = 0; 1934| | 1935| 1.27k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1461| 1.27k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1936| | 1937| 1.27k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 52| 1.27k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 312| 1.27k|#define YYEMPTY -2 ------------------ 1938| | 1939| 1.27k| goto yysetstate; 1940| | 1941| | 1942| |/*------------------------------------------------------------. 1943| || yynewstate -- push a new state, which is found in yystate. | 1944| |`------------------------------------------------------------*/ 1945| 726k|yynewstate: 1946| | /* In all cases, when you get here, the value and location stacks 1947| | have just been pushed. So pushing a state here evens the stacks. */ 1948| 726k| yyssp++; 1949| | 1950| | 1951| |/*--------------------------------------------------------------------. 1952| || yysetstate -- set current state (the top of the stack) to yystate. | 1953| |`--------------------------------------------------------------------*/ 1954| 727k|yysetstate: 1955| 727k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1461| 727k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1956| 727k| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 749| 727k|#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] | | ------------------ ------------------ 1957| 727k| YY_IGNORE_USELESS_CAST_BEGIN 1958| 727k| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 210| 727k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1959| 727k| YY_IGNORE_USELESS_CAST_END 1960| 727k| YY_STACK_PRINT (yyss, yyssp); 1961| | 1962| 727k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1962:7): [True: 83, False: 727k] ------------------ 1963| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1964| | YYNOMEM; 1965| |#else 1966| 83| { 1967| | /* Get the current used size of the three stacks, in elements. */ 1968| 83| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 633| 83|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1969| | 1970| |# if defined yyoverflow 1971| | { 1972| | /* Give user a chance to reallocate the stack. Use copies of 1973| | these so that the &'s don't force the real ones into 1974| | memory. */ 1975| | yy_state_t *yyss1 = yyss; 1976| | YYSTYPE *yyvs1 = yyvs; 1977| | 1978| | /* Each stack pointer address is followed by the size of the 1979| | data in use in that stack, in bytes. This used to be a 1980| | conditional around just the two extra args, but that might 1981| | be undefined if yyoverflow is a macro. */ 1982| | yyoverflow (YY_("memory exhausted"), 1983| | &yyss1, yysize * YYSIZEOF (*yyssp), 1984| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 1985| | &yystacksize); 1986| | yyss = yyss1; 1987| | yyvs = yyvs1; 1988| | } 1989| |# else /* defined YYSTACK_RELOCATE */ 1990| | /* Extend the stack our own way. */ 1991| 83| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1481| 83|# define YYMAXDEPTH 10000 ------------------ | Branch (1991:11): [True: 1, False: 82] ------------------ 1992| 1| YYNOMEM; ------------------ | | 1312| 1|#define YYNOMEM goto yyexhaustedlab ------------------ 1993| 82| yystacksize *= 2; 1994| 82| if (YYMAXDEPTH < yystacksize) ------------------ | | 1481| 82|# define YYMAXDEPTH 10000 ------------------ | Branch (1994:11): [True: 3, False: 79] ------------------ 1995| 3| yystacksize = YYMAXDEPTH; ------------------ | | 1481| 3|# define YYMAXDEPTH 10000 ------------------ 1996| | 1997| 82| { 1998| 82| yy_state_t *yyss1 = yyss; 1999| 82| union yyalloc *yyptr = 2000| 82| YY_CAST (union yyalloc *, ------------------ | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2001| 82| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2002| 82| if (! yyptr) ------------------ | Branch (2002:13): [True: 0, False: 82] ------------------ 2003| 0| YYNOMEM; ------------------ | | 1312| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2004| 82| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 846| 82| do \ | | 847| 82| { \ | | 848| 82| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 633| 82|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 849| 82| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 864| 82| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 850| 82| Stack = &yyptr->Stack_alloc; \ | | 851| 82| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 830| 82|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 852| 82| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 853| 82| } \ | | 854| 82| while (0) | | ------------------ | | | Branch (854:12): [Folded - Ignored] | | ------------------ ------------------ 2005| 82| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 846| 82| do \ | | 847| 82| { \ | | 848| 82| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 633| 82|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 849| 82| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 864| 82| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 850| 82| Stack = &yyptr->Stack_alloc; \ | | 851| 82| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 830| 82|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 852| 82| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 666| 82|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 82|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 853| 82| } \ | | 854| 82| while (0) | | ------------------ | | | Branch (854:12): [Folded - Ignored] | | ------------------ ------------------ 2006| 82|# undef YYSTACK_RELOCATE 2007| 82| if (yyss1 != yyssa) ------------------ | Branch (2007:13): [True: 42, False: 40] ------------------ 2008| 42| YYSTACK_FREE (yyss1); ------------------ | | 791| 42|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 42|#define YYFREE yr_free | | ------------------ ------------------ 2009| 82| } 2010| 0|# endif 2011| | 2012| 0| yyssp = yyss + yysize - 1; 2013| 82| yyvsp = yyvs + yysize - 1; 2014| | 2015| 82| YY_IGNORE_USELESS_CAST_BEGIN 2016| 82| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1461| 82|# define YYDPRINTF(Args) ((void) 0) ------------------ 2017| 82| YY_CAST (long, yystacksize))); 2018| 82| YY_IGNORE_USELESS_CAST_END 2019| | 2020| 82| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2020:11): [True: 0, False: 82] ------------------ 2021| 0| YYABORT; ------------------ | | 1310| 0|#define YYABORT goto yyabortlab ------------------ 2022| 82| } 2023| 727k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2024| | 2025| | 2026| 727k| if (yystate == YYFINAL) ------------------ | | 879| 727k|#define YYFINAL 2 ------------------ | Branch (2026:7): [True: 154, False: 727k] ------------------ 2027| 154| YYACCEPT; ------------------ | | 1309| 154|#define YYACCEPT goto yyacceptlab ------------------ 2028| | 2029| 727k| goto yybackup; 2030| | 2031| | 2032| |/*-----------. 2033| || yybackup. | 2034| |`-----------*/ 2035| 727k|yybackup: 2036| | /* Do appropriate processing given the current state. Read a 2037| | lookahead token if we need one and don't already have one. */ 2038| | 2039| | /* First try to decide what to do without reference to lookahead token. */ 2040| 727k| yyn = yypact[yystate]; 2041| 727k| if (yypact_value_is_default (yyn)) ------------------ | | 1020| 727k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 727k|#define YYPACT_NINF (-172) | | ------------------ | | | Branch (1020:3): [True: 168k, False: 558k] | | ------------------ ------------------ 2042| 168k| goto yydefault; 2043| | 2044| | /* Not known => get a lookahead token if don't already have one. */ 2045| | 2046| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2047| 558k| if (yychar == YYEMPTY) ------------------ | | 52| 558k|#define yychar yara_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 312| 558k|#define YYEMPTY -2 ------------------ | Branch (2047:7): [True: 351k, False: 207k] ------------------ 2048| 351k| { 2049| 351k| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1461| 351k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2050| 351k| yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 52| 351k|#define yychar yara_yychar ------------------ yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 48| 351k|#define yylex yara_yylex ------------------ 2051| 351k| } 2052| | 2053| 558k| if (yychar <= _END_OF_FILE_) ------------------ | | 52| 558k|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 558k|#define _END_OF_FILE_ 0 ------------------ | Branch (2053:7): [True: 3.49k, False: 555k] ------------------ 2054| 3.49k| { 2055| 3.49k| yychar = _END_OF_FILE_; ------------------ | | 52| 3.49k|#define yychar yara_yychar ------------------ yychar = _END_OF_FILE_; ------------------ | | 313| 3.49k|#define _END_OF_FILE_ 0 ------------------ 2056| 3.49k| yytoken = YYSYMBOL_YYEOF; 2057| 3.49k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1461| 3.49k|# define YYDPRINTF(Args) ((void) 0) ------------------ 2058| 3.49k| } 2059| 555k| else if (yychar == YYerror) ------------------ | | 52| 555k|#define yychar yara_yychar ------------------ else if (yychar == YYerror) ------------------ | | 314| 555k|#define YYerror 256 ------------------ | Branch (2059:12): [True: 0, False: 555k] ------------------ 2060| 0| { 2061| | /* The scanner already issued an error message, process directly 2062| | to error recovery. But do not keep the error token as 2063| | lookahead, it is too special and may lead us to an endless 2064| | loop in error recovery. */ 2065| 0| yychar = YYUNDEF; ------------------ | | 52| 0|#define yychar yara_yychar ------------------ yychar = YYUNDEF; ------------------ | | 315| 0|#define YYUNDEF 257 ------------------ 2066| 0| yytoken = YYSYMBOL_YYerror; 2067| 0| goto yyerrlab1; 2068| 0| } 2069| 555k| else 2070| 555k| { 2071| 555k| yytoken = YYTRANSLATE (yychar); ------------------ | | 899| 555k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 555k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 555k, False: 0] | | | Branch (899:18): [True: 555k, False: 0] | | ------------------ | | 900| 555k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 555k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 555k| : YYSYMBOL_YYUNDEF) ------------------ 2072| 555k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2073| 555k| } 2074| | 2075| | /* If the proper action on seeing token YYTOKEN is to reduce or to 2076| | detect an error, take that action. */ 2077| 558k| yyn += yytoken; 2078| 558k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 881| 518k|#define YYLAST 476 ------------------ | Branch (2078:7): [True: 39.8k, False: 518k] | Branch (2078:18): [True: 261, False: 518k] | Branch (2078:34): [True: 203k, False: 315k] ------------------ 2079| 243k| goto yydefault; 2080| 315k| yyn = yytable[yyn]; 2081| 315k| if (yyn <= 0) ------------------ | Branch (2081:7): [True: 21.0k, False: 294k] ------------------ 2082| 21.0k| { 2083| 21.0k| if (yytable_value_is_error (yyn)) ------------------ | | 1025| 21.0k| 0 | | ------------------ | | | Branch (1025:3): [Folded - Ignored] | | ------------------ ------------------ 2084| 0| goto yyerrlab; 2085| 21.0k| yyn = -yyn; 2086| 21.0k| goto yyreduce; 2087| 21.0k| } 2088| | 2089| | /* Count tokens shifted since error; after three, turn off error 2090| | status. */ 2091| 294k| if (yyerrstatus) ------------------ | Branch (2091:7): [True: 39.2k, False: 254k] ------------------ 2092| 39.2k| yyerrstatus--; 2093| | 2094| | /* Shift the lookahead token. */ 2095| 294k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2096| 294k| yystate = yyn; 2097| 294k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2098| 294k| *++yyvsp = yylval; 2099| 294k| YY_IGNORE_MAYBE_UNINITIALIZED_END 2100| | 2101| | /* Discard the shifted token. */ 2102| 294k| yychar = YYEMPTY; ------------------ | | 52| 294k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 294k|#define YYEMPTY -2 ------------------ 2103| 294k| goto yynewstate; 2104| | 2105| | 2106| |/*-----------------------------------------------------------. 2107| || yydefault -- do the default action for the current state. | 2108| |`-----------------------------------------------------------*/ 2109| 412k|yydefault: 2110| 412k| yyn = yydefact[yystate]; 2111| 412k| if (yyn == 0) ------------------ | Branch (2111:7): [True: 63.7k, False: 348k] ------------------ 2112| 63.7k| goto yyerrlab; 2113| 348k| goto yyreduce; 2114| | 2115| | 2116| |/*-----------------------------. 2117| || yyreduce -- do a reduction. | 2118| |`-----------------------------*/ 2119| 369k|yyreduce: 2120| | /* yyn is the number of a rule to reduce with. */ 2121| 369k| yylen = yyr2[yyn]; 2122| | 2123| | /* If YYLEN is nonzero, implement the default value of the action: 2124| | '$$ = $1'. 2125| | 2126| | Otherwise, the following line sets YYVAL to garbage. 2127| | This behavior is undocumented and Bison 2128| | users should not rely upon it. Assigning to YYVAL 2129| | unconditionally makes the parser a bit smaller, and it avoids a 2130| | GCC warning that YYVAL may be used uninitialized. */ 2131| 369k| yyval = yyvsp[1-yylen]; 2132| | 2133| | 2134| 369k| YY_REDUCE_PRINT (yyn); 2135| 369k| switch (yyn) 2136| 369k| { 2137| 0| case 8: /* rules: rules "end of included file" */ ------------------ | Branch (2137:3): [True: 0, False: 369k] ------------------ 2138| 0|#line 368 "libyara/grammar.y" 2139| 0| { 2140| 0| _yr_compiler_pop_file_name(compiler); 2141| 0| } 2142| 0|#line 2143 "libyara/grammar.c" 2143| 0| break; 2144| | 2145| 9.15k| case 9: /* import: "" "text string" */ ------------------ | Branch (2145:3): [True: 9.15k, False: 360k] ------------------ 2146| 9.15k|#line 376 "libyara/grammar.y" 2147| 9.15k| { 2148| 9.15k| int result = yr_parser_reduce_import(yyscanner, (yyvsp[0].sized_string)); 2149| | 2150| 9.15k| yr_free((yyvsp[0].sized_string)); 2151| | 2152| 9.15k| fail_if_error(result); ------------------ | | 135| 9.15k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 18.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8.21k, False: 940] | | ------------------ | | 136| 9.15k| { \ | | 137| 8.21k| fail_with_error(e); \ | | ------------------ | | | | 120| 8.21k| { \ | | | | 121| 8.21k| compiler->last_error = e; \ | | | | 122| 8.21k| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 8.21k|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 8.21k| switch (e) \ | | | | 124| 8.21k| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 8.21k] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8.21k| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8.21k, False: 0] | | | | ------------------ | | | | 128| 8.21k| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8.21k|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8.21k| } \ | | | | 130| 8.21k| } | | ------------------ | | 138| 0| } ------------------ 2153| 940| } 2154| 0|#line 2155 "libyara/grammar.c" 2155| 0| break; 2156| | 2157| 8.73k| case 10: /* @1: %empty */ ------------------ | Branch (2157:3): [True: 8.73k, False: 360k] ------------------ 2158| 8.73k|#line 388 "libyara/grammar.y" 2159| 8.73k| { 2160| 8.73k| fail_if_error(yr_parser_reduce_rule_declaration_phase_1( ------------------ | | 135| 8.73k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 17.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 1.93k, False: 6.80k] | | ------------------ | | 136| 8.73k| { \ | | 137| 1.93k| fail_with_error(e); \ | | ------------------ | | | | 120| 1.93k| { \ | | | | 121| 1.93k| compiler->last_error = e; \ | | | | 122| 1.93k| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 1.93k|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 1.93k| switch (e) \ | | | | 124| 1.93k| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 1.93k] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 1.93k| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 1.93k, False: 0] | | | | ------------------ | | | | 128| 1.93k| YYERROR; \ | | | | ------------------ | | | | | | 1311| 1.93k|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 1.93k| } \ | | | | 130| 1.93k| } | | ------------------ | | 138| 0| } ------------------ 2161| 8.73k| yyscanner, (int32_t) (yyvsp[-2].integer), (yyvsp[0].c_string), &(yyval.rule))); 2162| 6.80k| } 2163| 0|#line 2164 "libyara/grammar.c" 2164| 0| break; 2165| | 2166| 4.32k| case 11: /* $@2: %empty */ ------------------ | Branch (2166:3): [True: 4.32k, False: 365k] ------------------ 2167| 4.32k|#line 393 "libyara/grammar.y" 2168| 4.32k| { 2169| 4.32k| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr( 2170| 4.32k| compiler->arena, &(yyvsp[-4].rule)); 2171| | 2172| 4.32k| rule->tags = (char*) yr_arena_ref_to_ptr( 2173| 4.32k| compiler->arena, &(yyvsp[-3].tag)); 2174| | 2175| 4.32k| rule->metas = (YR_META*) yr_arena_ref_to_ptr( 2176| 4.32k| compiler->arena, &(yyvsp[-1].meta)); 2177| | 2178| 4.32k| rule->strings = (YR_STRING*) yr_arena_ref_to_ptr( 2179| 4.32k| compiler->arena, &(yyvsp[0].string)); 2180| 4.32k| } 2181| 4.32k|#line 2182 "libyara/grammar.c" 2182| 4.32k| break; 2183| | 2184| 120| case 12: /* rule: rule_modifiers "" "identifier" @1 tags '{' meta strings $@2 condition '}' */ ------------------ | Branch (2184:3): [True: 120, False: 369k] ------------------ 2185| 120|#line 407 "libyara/grammar.y" 2186| 120| { 2187| 120| int result = yr_parser_reduce_rule_declaration_phase_2( 2188| 120| yyscanner, &(yyvsp[-7].rule)); // rule created in phase 1 2189| | 2190| 120| yr_free((yyvsp[-8].c_string)); 2191| | 2192| 120| fail_if_error(result); ------------------ | | 135| 120| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 240|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 1, False: 119] | | ------------------ | | 136| 120| { \ | | 137| 1| fail_with_error(e); \ | | ------------------ | | | | 120| 1| { \ | | | | 121| 1| compiler->last_error = e; \ | | | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 1| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 1, False: 0] | | | | ------------------ | | | | 128| 1| YYERROR; \ | | | | ------------------ | | | | | | 1311| 1|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 1| } \ | | | | 130| 1| } | | ------------------ | | 138| 0| } ------------------ 2193| 119| } 2194| 0|#line 2195 "libyara/grammar.c" 2195| 0| break; 2196| | 2197| 4.93k| case 13: /* meta: %empty */ ------------------ | Branch (2197:3): [True: 4.93k, False: 364k] ------------------ 2198| 4.93k|#line 420 "libyara/grammar.y" 2199| 4.93k| { 2200| 4.93k| (yyval.meta) = YR_ARENA_NULL_REF; ------------------ | | 43| 4.93k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 2201| 4.93k| } 2202| 4.93k|#line 2203 "libyara/grammar.c" 2203| 4.93k| break; 2204| | 2205| 5| case 14: /* meta: "" ':' meta_declarations */ ------------------ | Branch (2205:3): [True: 5, False: 369k] ------------------ 2206| 5|#line 424 "libyara/grammar.y" 2207| 5| { 2208| 5| YR_META* meta = yr_arena_get_ptr( 2209| 5| compiler->arena, 2210| 5| YR_METAS_TABLE, ------------------ | | 59| 5|#define YR_METAS_TABLE 2 ------------------ 2211| 5| (compiler->current_meta_idx - 1) * sizeof(YR_META)); 2212| | 2213| 5| meta->flags |= META_FLAGS_LAST_IN_RULE; ------------------ | | 140| 5|#define META_FLAGS_LAST_IN_RULE 1 ------------------ 2214| | 2215| 5| (yyval.meta) = (yyvsp[0].meta); 2216| 5| } 2217| 5|#line 2218 "libyara/grammar.c" 2218| 5| break; 2219| | 2220| 3.81k| case 15: /* strings: %empty */ ------------------ | Branch (2220:3): [True: 3.81k, False: 365k] ------------------ 2221| 3.81k|#line 439 "libyara/grammar.y" 2222| 3.81k| { 2223| 3.81k| (yyval.string) = YR_ARENA_NULL_REF; ------------------ | | 43| 3.81k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 2224| 3.81k| } 2225| 3.81k|#line 2226 "libyara/grammar.c" 2226| 3.81k| break; 2227| | 2228| 516| case 16: /* strings: "" ':' string_declarations */ ------------------ | Branch (2228:3): [True: 516, False: 369k] ------------------ 2229| 516|#line 443 "libyara/grammar.y" 2230| 516| { 2231| 516| YR_STRING* string = (YR_STRING*) yr_arena_get_ptr( 2232| 516| compiler->arena, 2233| 516| YR_STRINGS_TABLE, ------------------ | | 60| 516|#define YR_STRINGS_TABLE 3 ------------------ 2234| 516| (compiler->current_string_idx - 1) * sizeof(YR_STRING)); 2235| | 2236| 516| string->flags |= STRING_FLAGS_LAST_IN_RULE; ------------------ | | 78| 516|#define STRING_FLAGS_LAST_IN_RULE 0x1000 ------------------ 2237| | 2238| 516| (yyval.string) = (yyvsp[0].string); 2239| 516| } 2240| 516|#line 2241 "libyara/grammar.c" 2241| 516| break; 2242| | 2243| 66.8k| case 18: /* rule_modifiers: %empty */ ------------------ | Branch (2243:3): [True: 66.8k, False: 302k] ------------------ 2244| 66.8k|#line 462 "libyara/grammar.y" 2245| 66.8k| { (yyval.integer) = 0; } 2246| 66.8k|#line 2247 "libyara/grammar.c" 2247| 66.8k| break; 2248| | 2249| 1.05k| case 19: /* rule_modifiers: rule_modifiers rule_modifier */ ------------------ | Branch (2249:3): [True: 1.05k, False: 368k] ------------------ 2250| 1.05k|#line 463 "libyara/grammar.y" 2251| 1.05k| { (yyval.integer) = (yyvsp[-1].integer) | (yyvsp[0].integer); } 2252| 1.05k|#line 2253 "libyara/grammar.c" 2253| 1.05k| break; 2254| | 2255| 160| case 20: /* rule_modifier: "" */ ------------------ | Branch (2255:3): [True: 160, False: 369k] ------------------ 2256| 160|#line 468 "libyara/grammar.y" 2257| 160| { (yyval.integer) = RULE_FLAGS_PRIVATE; } ------------------ | | 52| 160|#define RULE_FLAGS_PRIVATE 0x01 ------------------ 2258| 160|#line 2259 "libyara/grammar.c" 2259| 160| break; 2260| | 2261| 892| case 21: /* rule_modifier: "" */ ------------------ | Branch (2261:3): [True: 892, False: 368k] ------------------ 2262| 892|#line 469 "libyara/grammar.y" 2263| 892| { (yyval.integer) = RULE_FLAGS_GLOBAL; } ------------------ | | 53| 892|#define RULE_FLAGS_GLOBAL 0x02 ------------------ 2264| 892|#line 2265 "libyara/grammar.c" 2265| 892| break; 2266| | 2267| 6.53k| case 22: /* tags: %empty */ ------------------ | Branch (2267:3): [True: 6.53k, False: 363k] ------------------ 2268| 6.53k|#line 475 "libyara/grammar.y" 2269| 6.53k| { 2270| 6.53k| (yyval.tag) = YR_ARENA_NULL_REF; ------------------ | | 43| 6.53k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 2271| 6.53k| } 2272| 6.53k|#line 2273 "libyara/grammar.c" 2273| 6.53k| break; 2274| | 2275| 84| case 23: /* tags: ':' tag_list */ ------------------ | Branch (2275:3): [True: 84, False: 369k] ------------------ 2276| 84|#line 479 "libyara/grammar.y" 2277| 84| { 2278| | // Tags list is represented in the arena as a sequence 2279| | // of null-terminated strings, the sequence ends with an 2280| | // additional null character. Here we write the ending null 2281| | //character. Example: tag1\0tag2\0tag3\0\0 2282| | 2283| 84| fail_if_error(yr_arena_write_string( ------------------ | | 135| 84| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 168|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 84] | | ------------------ | | 136| 84| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2284| 84| yyget_extra(yyscanner)->arena, YR_SZ_POOL, "", NULL)); 2285| | 2286| 84| (yyval.tag) = (yyvsp[0].tag); 2287| 84| } 2288| 0|#line 2289 "libyara/grammar.c" 2289| 0| break; 2290| | 2291| 108| case 24: /* tag_list: "identifier" */ ------------------ | Branch (2291:3): [True: 108, False: 369k] ------------------ 2292| 108|#line 495 "libyara/grammar.y" 2293| 108| { 2294| 108| int result = yr_arena_write_string( 2295| 108| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 55| 108|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 62| 108|#define YR_SZ_POOL 5 ------------------ 2296| | 2297| 108| yr_free((yyvsp[0].c_string)); 2298| | 2299| 108| fail_if_error(result); ------------------ | | 135| 108| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 216|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 108] | | ------------------ | | 136| 108| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2300| 108| } 2301| 0|#line 2302 "libyara/grammar.c" 2302| 0| break; 2303| | 2304| 37| case 25: /* tag_list: tag_list "identifier" */ ------------------ | Branch (2304:3): [True: 37, False: 369k] ------------------ 2305| 37|#line 504 "libyara/grammar.y" 2306| 37| { 2307| 37| YR_ARENA_REF ref; 2308| | 2309| | // Write the new tag identifier. 2310| 37| int result = yr_arena_write_string( 2311| 37| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 55| 37|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 62| 37|#define YR_SZ_POOL 5 ------------------ 2312| | 2313| 37| yr_free((yyvsp[0].c_string)); 2314| | 2315| 37| fail_if_error(result); ------------------ | | 135| 37| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 74|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 37] | | ------------------ | | 136| 37| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2316| | 2317| | // Get the address for the tag identifier just written. 2318| 37| char* new_tag = (char*) yr_arena_ref_to_ptr( 2319| 37| compiler->arena, &ref); 2320| | 2321| | // Take the address of first tag's identifier in the list. 2322| 37| char* tag = (char*) yr_arena_ref_to_ptr( 2323| 37| compiler->arena, &(yyval.tag)); 2324| | 2325| | // Search for duplicated tags. Tags are written one after 2326| | // the other, with zeroes in between (i.e: tag1/0tag2/0tag3) 2327| | // that's why can use tag < new_tag as the condition for the 2328| | // loop. 2329| 50| while (tag < new_tag) ------------------ | Branch (2329:16): [True: 37, False: 13] ------------------ 2330| 37| { 2331| 37| if (strcmp(tag, new_tag) == 0) ------------------ | Branch (2331:15): [True: 24, False: 13] ------------------ 2332| 24| { 2333| 24| yr_compiler_set_error_extra_info(compiler, tag); ------------------ | | 298| 24| strlcpy( \ | | 299| 24| compiler->last_error_extra_info, \ | | 300| 24| info, \ | | 301| 24| sizeof(compiler->last_error_extra_info)); ------------------ 2334| 24| fail_with_error(ERROR_DUPLICATED_TAG_IDENTIFIER); ------------------ | | 120| 24| { \ | | 121| 24| compiler->last_error = e; \ | | 122| 24| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 24|#define yyerror yara_yyerror | | ------------------ | | 123| 24| switch (e) \ | | 124| 24| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 24] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 24| default: \ | | ------------------ | | | Branch (127:7): [True: 24, False: 0] | | ------------------ | | 128| 24| YYERROR; \ | | ------------------ | | | | 1311| 24|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 24| } \ | | 130| 24| } ------------------ 2335| 0| } 2336| | 2337| 13| tag += strlen(tag) + 1; 2338| 13| } 2339| | 2340| 13| (yyval.tag) = (yyvsp[-1].tag); 2341| 13| } 2342| 0|#line 2343 "libyara/grammar.c" 2343| 0| break; 2344| | 2345| 13| case 26: /* meta_declarations: meta_declaration */ ------------------ | Branch (2345:3): [True: 13, False: 369k] ------------------ 2346| 13|#line 545 "libyara/grammar.y" 2347| 13| { (yyval.meta) = (yyvsp[0].meta); } 2348| 13|#line 2349 "libyara/grammar.c" 2349| 13| break; 2350| | 2351| 1.60k| case 27: /* meta_declarations: meta_declarations meta_declaration */ ------------------ | Branch (2351:3): [True: 1.60k, False: 368k] ------------------ 2352| 1.60k|#line 546 "libyara/grammar.y" 2353| 1.60k| { (yyval.meta) = (yyvsp[-1].meta); } 2354| 1.60k|#line 2355 "libyara/grammar.c" 2355| 1.60k| break; 2356| | 2357| 403| case 28: /* meta_declaration: "identifier" '=' "text string" */ ------------------ | Branch (2357:3): [True: 403, False: 369k] ------------------ 2358| 403|#line 552 "libyara/grammar.y" 2359| 403| { 2360| 403| SIZED_STRING* sized_string = (yyvsp[0].sized_string); 2361| | 2362| 403| int result = yr_parser_reduce_meta_declaration( 2363| 403| yyscanner, 2364| 403| META_TYPE_STRING, ------------------ | | 137| 403|#define META_TYPE_STRING 2 ------------------ 2365| 403| (yyvsp[-2].c_string), 2366| 403| sized_string->c_string, 2367| 403| 0, 2368| 403| &(yyval.meta)); 2369| | 2370| 403| yr_free((yyvsp[-2].c_string)); 2371| 403| yr_free((yyvsp[0].sized_string)); 2372| | 2373| 403| fail_if_error(result); ------------------ | | 135| 403| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 806|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 403] | | ------------------ | | 136| 403| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2374| 403| } 2375| 0|#line 2376 "libyara/grammar.c" 2376| 0| break; 2377| | 2378| 181| case 29: /* meta_declaration: "identifier" '=' "integer number" */ ------------------ | Branch (2378:3): [True: 181, False: 369k] ------------------ 2379| 181|#line 569 "libyara/grammar.y" 2380| 181| { 2381| 181| int result = yr_parser_reduce_meta_declaration( 2382| 181| yyscanner, 2383| 181| META_TYPE_INTEGER, ------------------ | | 136| 181|#define META_TYPE_INTEGER 1 ------------------ 2384| 181| (yyvsp[-2].c_string), 2385| 181| NULL, 2386| 181| (yyvsp[0].integer), 2387| 181| &(yyval.meta)); 2388| | 2389| 181| yr_free((yyvsp[-2].c_string)); 2390| | 2391| 181| fail_if_error(result); ------------------ | | 135| 181| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 362|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 181] | | ------------------ | | 136| 181| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2392| 181| } 2393| 0|#line 2394 "libyara/grammar.c" 2394| 0| break; 2395| | 2396| 746| case 30: /* meta_declaration: "identifier" '=' '-' "integer number" */ ------------------ | Branch (2396:3): [True: 746, False: 368k] ------------------ 2397| 746|#line 583 "libyara/grammar.y" 2398| 746| { 2399| 746| int result = yr_parser_reduce_meta_declaration( 2400| 746| yyscanner, 2401| 746| META_TYPE_INTEGER, ------------------ | | 136| 746|#define META_TYPE_INTEGER 1 ------------------ 2402| 746| (yyvsp[-3].c_string), 2403| 746| NULL, 2404| 746| -(yyvsp[0].integer), 2405| 746| &(yyval.meta)); 2406| | 2407| 746| yr_free((yyvsp[-3].c_string)); 2408| | 2409| 746| fail_if_error(result); ------------------ | | 135| 746| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.49k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 746] | | ------------------ | | 136| 746| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2410| 746| } 2411| 0|#line 2412 "libyara/grammar.c" 2412| 0| break; 2413| | 2414| 128| case 31: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2414:3): [True: 128, False: 369k] ------------------ 2415| 128|#line 597 "libyara/grammar.y" 2416| 128| { 2417| 128| int result = yr_parser_reduce_meta_declaration( 2418| 128| yyscanner, 2419| 128| META_TYPE_BOOLEAN, ------------------ | | 138| 128|#define META_TYPE_BOOLEAN 3 ------------------ 2420| 128| (yyvsp[-2].c_string), 2421| 128| NULL, 2422| 128| true, 2423| 128| &(yyval.meta)); 2424| | 2425| 128| yr_free((yyvsp[-2].c_string)); 2426| | 2427| 128| fail_if_error(result); ------------------ | | 135| 128| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 256|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 128] | | ------------------ | | 136| 128| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2428| 128| } 2429| 0|#line 2430 "libyara/grammar.c" 2430| 0| break; 2431| | 2432| 160| case 32: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2432:3): [True: 160, False: 369k] ------------------ 2433| 160|#line 611 "libyara/grammar.y" 2434| 160| { 2435| 160| int result = yr_parser_reduce_meta_declaration( 2436| 160| yyscanner, 2437| 160| META_TYPE_BOOLEAN, ------------------ | | 138| 160|#define META_TYPE_BOOLEAN 3 ------------------ 2438| 160| (yyvsp[-2].c_string), 2439| 160| NULL, 2440| 160| false, 2441| 160| &(yyval.meta)); 2442| | 2443| 160| yr_free((yyvsp[-2].c_string)); 2444| | 2445| 160| fail_if_error(result); ------------------ | | 135| 160| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 320|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 160] | | ------------------ | | 136| 160| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2446| 160| } 2447| 0|#line 2448 "libyara/grammar.c" 2448| 0| break; 2449| | 2450| 613| case 33: /* string_declarations: string_declaration */ ------------------ | Branch (2450:3): [True: 613, False: 369k] ------------------ 2451| 613|#line 628 "libyara/grammar.y" 2452| 613| { (yyval.string) = (yyvsp[0].string); } 2453| 613|#line 2454 "libyara/grammar.c" 2454| 613| break; 2455| | 2456| 21.3k| case 34: /* string_declarations: string_declarations string_declaration */ ------------------ | Branch (2456:3): [True: 21.3k, False: 348k] ------------------ 2457| 21.3k|#line 629 "libyara/grammar.y" 2458| 21.3k| { (yyval.string) = (yyvsp[-1].string); } 2459| 21.3k|#line 2460 "libyara/grammar.c" 2460| 21.3k| break; 2461| | 2462| 4.25k| case 35: /* $@3: %empty */ ------------------ | Branch (2462:3): [True: 4.25k, False: 365k] ------------------ 2463| 4.25k|#line 635 "libyara/grammar.y" 2464| 4.25k| { 2465| 4.25k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 56| 4.25k|#define yyget_lineno yara_yyget_lineno ------------------ 2466| 4.25k| } 2467| 4.25k|#line 2468 "libyara/grammar.c" 2468| 4.25k| break; 2469| | 2470| 4.15k| case 36: /* string_declaration: "string identifier" '=' $@3 "text string" string_modifiers */ ------------------ | Branch (2470:3): [True: 4.15k, False: 365k] ------------------ 2471| 4.15k|#line 639 "libyara/grammar.y" 2472| 4.15k| { 2473| 4.15k| int result = yr_parser_reduce_string_declaration( 2474| 4.15k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2475| | 2476| 4.15k| yr_free((yyvsp[-4].c_string)); 2477| 4.15k| yr_free((yyvsp[-1].sized_string)); 2478| 4.15k| yr_free((yyvsp[0].modifier).alphabet); 2479| | 2480| 4.15k| fail_if_error(result); ------------------ | | 135| 4.15k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.30k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 37, False: 4.11k] | | ------------------ | | 136| 4.15k| { \ | | 137| 37| fail_with_error(e); \ | | ------------------ | | | | 120| 37| { \ | | | | 121| 37| compiler->last_error = e; \ | | | | 122| 37| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 37|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 37| switch (e) \ | | | | 124| 37| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 37] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 37| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 37, False: 0] | | | | ------------------ | | | | 128| 37| YYERROR; \ | | | | ------------------ | | | | | | 1311| 37|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 37| } \ | | | | 130| 37| } | | ------------------ | | 138| 0| } ------------------ 2481| 4.11k| compiler->current_line = 0; 2482| 4.11k| } 2483| 0|#line 2484 "libyara/grammar.c" 2484| 0| break; 2485| | 2486| 17.1k| case 37: /* $@4: %empty */ ------------------ | Branch (2486:3): [True: 17.1k, False: 352k] ------------------ 2487| 17.1k|#line 651 "libyara/grammar.y" 2488| 17.1k| { 2489| 17.1k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 56| 17.1k|#define yyget_lineno yara_yyget_lineno ------------------ 2490| 17.1k| } 2491| 17.1k|#line 2492 "libyara/grammar.c" 2492| 17.1k| break; 2493| | 2494| 17.1k| case 38: /* string_declaration: "string identifier" '=' $@4 "regular expression" regexp_modifiers */ ------------------ | Branch (2494:3): [True: 17.1k, False: 352k] ------------------ 2495| 17.1k|#line 655 "libyara/grammar.y" 2496| 17.1k| { 2497| 17.1k| int result; 2498| | 2499| 17.1k| (yyvsp[0].modifier).flags |= STRING_FLAGS_REGEXP; ------------------ | | 71| 17.1k|#define STRING_FLAGS_REGEXP 0x20 ------------------ 2500| | 2501| 17.1k| result = yr_parser_reduce_string_declaration( 2502| 17.1k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2503| | 2504| 17.1k| yr_free((yyvsp[-4].c_string)); 2505| 17.1k| yr_free((yyvsp[-1].sized_string)); 2506| | 2507| 17.1k| fail_if_error(result); ------------------ | | 135| 17.1k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 34.3k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 158, False: 17.0k] | | ------------------ | | 136| 17.1k| { \ | | 137| 158| fail_with_error(e); \ | | ------------------ | | | | 120| 158| { \ | | | | 121| 158| compiler->last_error = e; \ | | | | 122| 158| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 158|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 158| switch (e) \ | | | | 124| 158| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 158] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 158| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 158, False: 0] | | | | ------------------ | | | | 128| 158| YYERROR; \ | | | | ------------------ | | | | | | 1311| 158|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 158| } \ | | | | 130| 158| } | | ------------------ | | 138| 0| } ------------------ 2508| | 2509| 17.0k| compiler->current_line = 0; 2510| 17.0k| } 2511| 0|#line 2512 "libyara/grammar.c" 2512| 0| break; 2513| | 2514| 1.07k| case 39: /* $@5: %empty */ ------------------ | Branch (2514:3): [True: 1.07k, False: 368k] ------------------ 2515| 1.07k|#line 671 "libyara/grammar.y" 2516| 1.07k| { 2517| 1.07k| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 56| 1.07k|#define yyget_lineno yara_yyget_lineno ------------------ 2518| 1.07k| } 2519| 1.07k|#line 2520 "libyara/grammar.c" 2520| 1.07k| break; 2521| | 2522| 1.07k| case 40: /* string_declaration: "string identifier" '=' $@5 "hex string" hex_modifiers */ ------------------ | Branch (2522:3): [True: 1.07k, False: 368k] ------------------ 2523| 1.07k|#line 675 "libyara/grammar.y" 2524| 1.07k| { 2525| 1.07k| int result; 2526| | 2527| 1.07k| (yyvsp[0].modifier).flags |= STRING_FLAGS_HEXADECIMAL; ------------------ | | 67| 1.07k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ 2528| | 2529| 1.07k| result = yr_parser_reduce_string_declaration( 2530| 1.07k| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2531| | 2532| 1.07k| yr_free((yyvsp[-4].c_string)); 2533| 1.07k| yr_free((yyvsp[-1].sized_string)); 2534| | 2535| 1.07k| fail_if_error(result); ------------------ | | 135| 1.07k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.15k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 254, False: 822] | | ------------------ | | 136| 1.07k| { \ | | 137| 254| fail_with_error(e); \ | | ------------------ | | | | 120| 254| { \ | | | | 121| 254| compiler->last_error = e; \ | | | | 122| 254| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 254|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 254| switch (e) \ | | | | 124| 254| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 254] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 254| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 254, False: 0] | | | | ------------------ | | | | 128| 254| YYERROR; \ | | | | ------------------ | | | | | | 1311| 254|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 254| } \ | | | | 130| 254| } | | ------------------ | | 138| 0| } ------------------ 2536| | 2537| 822| compiler->current_line = 0; 2538| 822| } 2539| 0|#line 2540 "libyara/grammar.c" 2540| 0| break; 2541| | 2542| 4.19k| case 41: /* string_modifiers: %empty */ ------------------ | Branch (2542:3): [True: 4.19k, False: 365k] ------------------ 2543| 4.19k|#line 695 "libyara/grammar.y" 2544| 4.19k| { 2545| 4.19k| (yyval.modifier).flags = 0; 2546| 4.19k| (yyval.modifier).xor_min = 0; 2547| 4.19k| (yyval.modifier).xor_max = 0; 2548| 4.19k| (yyval.modifier).alphabet = NULL; 2549| 4.19k| } 2550| 4.19k|#line 2551 "libyara/grammar.c" 2551| 4.19k| break; 2552| | 2553| 5.91k| case 42: /* string_modifiers: string_modifiers string_modifier */ ------------------ | Branch (2553:3): [True: 5.91k, False: 363k] ------------------ 2554| 5.91k|#line 702 "libyara/grammar.y" 2555| 5.91k| { 2556| 5.91k| (yyval.modifier) = (yyvsp[-1].modifier); 2557| | 2558| | // Only set the xor minimum and maximum if we are dealing with the 2559| | // xor modifier. If we don't check for this then we can end up with 2560| | // "xor wide" resulting in whatever is on the stack for "wide" 2561| | // overwriting the values for xor. 2562| 5.91k| if ((yyvsp[0].modifier).flags & STRING_FLAGS_XOR) ------------------ | | 85| 5.91k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (2562:13): [True: 989, False: 4.92k] ------------------ 2563| 989| { 2564| 989| (yyval.modifier).xor_min = (yyvsp[0].modifier).xor_min; 2565| 989| (yyval.modifier).xor_max = (yyvsp[0].modifier).xor_max; 2566| 989| } 2567| | 2568| | // Only set the base64 alphabet if we are dealing with the base64 2569| | // modifier. If we don't check for this then we can end up with 2570| | // "base64 ascii" resulting in whatever is on the stack for "ascii" 2571| | // overwriting the values for base64. 2572| 5.91k| if (((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64) || ------------------ | | 87| 5.91k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (2572:13): [True: 1.44k, False: 4.46k] ------------------ 2573| 5.91k| ((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 4.46k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (2573:13): [True: 1.44k, False: 3.01k] ------------------ 2574| 2.89k| { 2575| 2.89k| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2575:15): [True: 495, False: 2.39k] ------------------ 2576| 495| { 2577| 495| if (ss_compare((yyval.modifier).alphabet, (yyvsp[0].modifier).alphabet) != 0) ------------------ | Branch (2577:17): [True: 23, False: 472] ------------------ 2578| 23| { 2579| 23| yr_compiler_set_error_extra_info( ------------------ | | 298| 23| strlcpy( \ | | 299| 23| compiler->last_error_extra_info, \ | | 300| 23| info, \ | | 301| 23| sizeof(compiler->last_error_extra_info)); ------------------ 2580| 23| compiler, "can not specify multiple alphabets"); 2581| | 2582| 23| yr_free((yyvsp[0].modifier).alphabet); 2583| 23| yr_free((yyval.modifier).alphabet); 2584| | 2585| 23| fail_with_error(ERROR_INVALID_MODIFIER); ------------------ | | 120| 23| { \ | | 121| 23| compiler->last_error = e; \ | | 122| 23| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 23|#define yyerror yara_yyerror | | ------------------ | | 123| 23| switch (e) \ | | 124| 23| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 23] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 23| default: \ | | ------------------ | | | Branch (127:7): [True: 23, False: 0] | | ------------------ | | 128| 23| YYERROR; \ | | ------------------ | | | | 1311| 23|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 23| } \ | | 130| 23| } ------------------ 2586| 0| } 2587| 472| else 2588| 472| { 2589| 472| yr_free((yyvsp[0].modifier).alphabet); 2590| 472| } 2591| 495| } 2592| 2.39k| else 2593| 2.39k| { 2594| 2.39k| (yyval.modifier).alphabet = (yyvsp[0].modifier).alphabet; 2595| 2.39k| } 2596| 2.89k| } 2597| | 2598| 5.88k| if ((yyval.modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2598:13): [True: 1, False: 5.88k] ------------------ 2599| 1| { 2600| 1| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2600:15): [True: 1, False: 0] ------------------ 2601| 1| yr_free((yyval.modifier).alphabet); 2602| | 2603| 1| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 1| { \ | | 121| 1| compiler->last_error = e; \ | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 1| default: \ | | ------------------ | | | Branch (127:7): [True: 1, False: 0] | | ------------------ | | 128| 1| YYERROR; \ | | ------------------ | | | | 1311| 1|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 1| } \ | | 130| 1| } ------------------ 2604| 0| } 2605| 5.88k| else 2606| 5.88k| { 2607| 5.88k| (yyval.modifier).flags = (yyval.modifier).flags | (yyvsp[0].modifier).flags; 2608| 5.88k| } 2609| 5.88k| } 2610| 5.88k|#line 2611 "libyara/grammar.c" 2611| 5.88k| break; 2612| | 2613| 5.88k| case 43: /* string_modifier: "" */ ------------------ | Branch (2613:3): [True: 999, False: 368k] ------------------ 2614| 999|#line 761 "libyara/grammar.y" 2615| 999| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 999|#define STRING_FLAGS_WIDE 0x10 ------------------ 2616| 999|#line 2617 "libyara/grammar.c" 2617| 999| break; 2618| | 2619| 654| case 44: /* string_modifier: "" */ ------------------ | Branch (2619:3): [True: 654, False: 369k] ------------------ 2620| 654|#line 762 "libyara/grammar.y" 2621| 654| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 654|#define STRING_FLAGS_ASCII 0x08 ------------------ 2622| 654|#line 2623 "libyara/grammar.c" 2623| 654| break; 2624| | 2625| 176| case 45: /* string_modifier: "" */ ------------------ | Branch (2625:3): [True: 176, False: 369k] ------------------ 2626| 176|#line 763 "libyara/grammar.y" 2627| 176| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 176|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2628| 176|#line 2629 "libyara/grammar.c" 2629| 176| break; 2630| | 2631| 41| case 46: /* string_modifier: "" */ ------------------ | Branch (2631:3): [True: 41, False: 369k] ------------------ 2632| 41|#line 764 "libyara/grammar.y" 2633| 41| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 41|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2634| 41|#line 2635 "libyara/grammar.c" 2635| 41| break; 2636| | 2637| 160| case 47: /* string_modifier: "" */ ------------------ | Branch (2637:3): [True: 160, False: 369k] ------------------ 2638| 160|#line 765 "libyara/grammar.y" 2639| 160| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 160|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2640| 160|#line 2641 "libyara/grammar.c" 2641| 160| break; 2642| | 2643| 527| case 48: /* string_modifier: "" */ ------------------ | Branch (2643:3): [True: 527, False: 369k] ------------------ 2644| 527|#line 767 "libyara/grammar.y" 2645| 527| { 2646| 527| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 527|#define STRING_FLAGS_XOR 0x80000 ------------------ 2647| 527| (yyval.modifier).xor_min = 0; 2648| 527| (yyval.modifier).xor_max = 255; 2649| 527| } 2650| 527|#line 2651 "libyara/grammar.c" 2651| 527| break; 2652| | 2653| 286| case 49: /* string_modifier: "" '(' "integer number" ')' */ ------------------ | Branch (2653:3): [True: 286, False: 369k] ------------------ 2654| 286|#line 773 "libyara/grammar.y" 2655| 286| { 2656| 286| int result = ERROR_SUCCESS; ------------------ | | 40| 286|#define ERROR_SUCCESS 0 ------------------ 2657| | 2658| 286| if ((yyvsp[-1].integer) < 0 || (yyvsp[-1].integer) > 255) ------------------ | Branch (2658:13): [True: 0, False: 286] | Branch (2658:40): [True: 0, False: 286] ------------------ 2659| 0| { 2660| 0| yr_compiler_set_error_extra_info(compiler, "invalid xor range"); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2661| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2662| 0| } 2663| | 2664| 286| fail_if_error(result); ------------------ | | 135| 286| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 572|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 286] | | ------------------ | | 136| 286| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2665| | 2666| 286| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 286|#define STRING_FLAGS_XOR 0x80000 ------------------ 2667| 286| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-1].integer); 2668| 286| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2669| 286| } 2670| 0|#line 2671 "libyara/grammar.c" 2671| 0| break; 2672| | 2673| 176| case 50: /* string_modifier: "" '(' "integer number" '-' "integer number" ')' */ ------------------ | Branch (2673:3): [True: 176, False: 369k] ------------------ 2674| 176|#line 794 "libyara/grammar.y" 2675| 176| { 2676| 176| int result = ERROR_SUCCESS; ------------------ | | 40| 176|#define ERROR_SUCCESS 0 ------------------ 2677| | 2678| 176| if ((yyvsp[-3].integer) < 0) ------------------ | Branch (2678:13): [True: 0, False: 176] ------------------ 2679| 0| { 2680| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2681| 0| compiler, "lower bound for xor range exceeded (min: 0)"); 2682| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2683| 0| } 2684| | 2685| 176| if ((yyvsp[-1].integer) > 255) ------------------ | Branch (2685:13): [True: 0, False: 176] ------------------ 2686| 0| { 2687| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2688| 0| compiler, "upper bound for xor range exceeded (max: 255)"); 2689| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2690| 0| } 2691| | 2692| 176| if ((yyvsp[-3].integer) > (yyvsp[-1].integer)) ------------------ | Branch (2692:13): [True: 0, False: 176] ------------------ 2693| 0| { 2694| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2695| 0| compiler, "xor lower bound exceeds upper bound"); 2696| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2697| 0| } 2698| | 2699| 176| fail_if_error(result); ------------------ | | 135| 176| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 352|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 176] | | ------------------ | | 136| 176| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2700| | 2701| 176| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 176|#define STRING_FLAGS_XOR 0x80000 ------------------ 2702| 176| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-3].integer); 2703| 176| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2704| 176| } 2705| 0|#line 2706 "libyara/grammar.c" 2706| 0| break; 2707| | 2708| 1.22k| case 51: /* string_modifier: "" */ ------------------ | Branch (2708:3): [True: 1.22k, False: 368k] ------------------ 2709| 1.22k|#line 825 "libyara/grammar.y" 2710| 1.22k| { 2711| 1.22k| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 1.22k|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2712| 1.22k| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 1.22k| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2713| 1.22k| } 2714| 1.22k|#line 2715 "libyara/grammar.c" 2715| 1.22k| break; 2716| | 2717| 216| case 52: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2717:3): [True: 216, False: 369k] ------------------ 2718| 216|#line 830 "libyara/grammar.y" 2719| 216| { 2720| 216| int result = ERROR_SUCCESS; ------------------ | | 40| 216|#define ERROR_SUCCESS 0 ------------------ 2721| | 2722| 216| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2722:13): [True: 0, False: 216] ------------------ 2723| 0| { 2724| 0| yr_free((yyvsp[-1].sized_string)); 2725| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2726| 0| compiler, "length of base64 alphabet must be 64"); 2727| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2728| 0| } 2729| | 2730| 216| fail_if_error(result); ------------------ | | 135| 216| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 432|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 216] | | ------------------ | | 136| 216| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2731| | 2732| 216| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 216|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2733| 216| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2734| 216| } 2735| 0|#line 2736 "libyara/grammar.c" 2736| 0| break; 2737| | 2738| 1.24k| case 53: /* string_modifier: "" */ ------------------ | Branch (2738:3): [True: 1.24k, False: 368k] ------------------ 2739| 1.24k|#line 847 "libyara/grammar.y" 2740| 1.24k| { 2741| 1.24k| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 1.24k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2742| 1.24k| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 1.24k| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2743| 1.24k| } 2744| 1.24k|#line 2745 "libyara/grammar.c" 2745| 1.24k| break; 2746| | 2747| 207| case 54: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2747:3): [True: 207, False: 369k] ------------------ 2748| 207|#line 852 "libyara/grammar.y" 2749| 207| { 2750| 207| int result = ERROR_SUCCESS; ------------------ | | 40| 207|#define ERROR_SUCCESS 0 ------------------ 2751| | 2752| 207| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2752:13): [True: 5, False: 202] ------------------ 2753| 5| { 2754| 5| yr_free((yyvsp[-1].sized_string)); 2755| 5| yr_compiler_set_error_extra_info( ------------------ | | 298| 5| strlcpy( \ | | 299| 5| compiler->last_error_extra_info, \ | | 300| 5| info, \ | | 301| 5| sizeof(compiler->last_error_extra_info)); ------------------ 2756| 5| compiler, "length of base64 alphabet must be 64"); 2757| 5| result = ERROR_INVALID_MODIFIER; ------------------ | | 104| 5|#define ERROR_INVALID_MODIFIER 59 ------------------ 2758| 5| } 2759| | 2760| 207| fail_if_error(result); ------------------ | | 135| 207| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 414|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 5, False: 202] | | ------------------ | | 136| 207| { \ | | 137| 5| fail_with_error(e); \ | | ------------------ | | | | 120| 5| { \ | | | | 121| 5| compiler->last_error = e; \ | | | | 122| 5| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 5| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 5, False: 0] | | | | ------------------ | | | | 128| 5| YYERROR; \ | | | | ------------------ | | | | | | 1311| 5|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 5| } \ | | | | 130| 5| } | | ------------------ | | 138| 0| } ------------------ 2761| | 2762| 202| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 202|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2763| 202| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2764| 202| } 2765| 0|#line 2766 "libyara/grammar.c" 2766| 0| break; 2767| | 2768| 17.1k| case 55: /* regexp_modifiers: %empty */ ------------------ | Branch (2768:3): [True: 17.1k, False: 352k] ------------------ 2769| 17.1k|#line 871 "libyara/grammar.y" 2770| 17.1k| { (yyval.modifier).flags = 0; } 2771| 17.1k|#line 2772 "libyara/grammar.c" 2772| 17.1k| break; 2773| | 2774| 1.18k| case 56: /* regexp_modifiers: regexp_modifiers regexp_modifier */ ------------------ | Branch (2774:3): [True: 1.18k, False: 368k] ------------------ 2775| 1.18k|#line 873 "libyara/grammar.y" 2776| 1.18k| { 2777| 1.18k| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2777:13): [True: 8, False: 1.17k] ------------------ 2778| 8| { 2779| 8| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 8| { \ | | 121| 8| compiler->last_error = e; \ | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 8| default: \ | | ------------------ | | | Branch (127:7): [True: 8, False: 0] | | ------------------ | | 128| 8| YYERROR; \ | | ------------------ | | | | 1311| 8|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 8| } \ | | 130| 8| } ------------------ 2780| 0| } 2781| 1.17k| else 2782| 1.17k| { 2783| 1.17k| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2784| 1.17k| } 2785| 1.18k| } 2786| 1.17k|#line 2787 "libyara/grammar.c" 2787| 1.17k| break; 2788| | 2789| 1.17k| case 57: /* regexp_modifier: "" */ ------------------ | Branch (2789:3): [True: 426, False: 369k] ------------------ 2790| 426|#line 886 "libyara/grammar.y" 2791| 426| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 426|#define STRING_FLAGS_WIDE 0x10 ------------------ 2792| 426|#line 2793 "libyara/grammar.c" 2793| 426| break; 2794| | 2795| 247| case 58: /* regexp_modifier: "" */ ------------------ | Branch (2795:3): [True: 247, False: 369k] ------------------ 2796| 247|#line 887 "libyara/grammar.y" 2797| 247| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 247|#define STRING_FLAGS_ASCII 0x08 ------------------ 2798| 247|#line 2799 "libyara/grammar.c" 2799| 247| break; 2800| | 2801| 177| case 59: /* regexp_modifier: "" */ ------------------ | Branch (2801:3): [True: 177, False: 369k] ------------------ 2802| 177|#line 888 "libyara/grammar.y" 2803| 177| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 177|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2804| 177|#line 2805 "libyara/grammar.c" 2805| 177| break; 2806| | 2807| 160| case 60: /* regexp_modifier: "" */ ------------------ | Branch (2807:3): [True: 160, False: 369k] ------------------ 2808| 160|#line 889 "libyara/grammar.y" 2809| 160| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 160|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2810| 160|#line 2811 "libyara/grammar.c" 2811| 160| break; 2812| | 2813| 177| case 61: /* regexp_modifier: "" */ ------------------ | Branch (2813:3): [True: 177, False: 369k] ------------------ 2814| 177|#line 890 "libyara/grammar.y" 2815| 177| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 177|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2816| 177|#line 2817 "libyara/grammar.c" 2817| 177| break; 2818| | 2819| 1.07k| case 62: /* hex_modifiers: %empty */ ------------------ | Branch (2819:3): [True: 1.07k, False: 368k] ------------------ 2820| 1.07k|#line 894 "libyara/grammar.y" 2821| 1.07k| { (yyval.modifier).flags = 0; } 2822| 1.07k|#line 2823 "libyara/grammar.c" 2823| 1.07k| break; 2824| | 2825| 325| case 63: /* hex_modifiers: hex_modifiers hex_modifier */ ------------------ | Branch (2825:3): [True: 325, False: 369k] ------------------ 2826| 325|#line 896 "libyara/grammar.y" 2827| 325| { 2828| 325| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2828:13): [True: 0, False: 325] ------------------ 2829| 0| { 2830| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2831| 0| } 2832| 325| else 2833| 325| { 2834| 325| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2835| 325| } 2836| 325| } 2837| 325|#line 2838 "libyara/grammar.c" 2838| 325| break; 2839| | 2840| 325| case 64: /* hex_modifier: "" */ ------------------ | Branch (2840:3): [True: 325, False: 369k] ------------------ 2841| 325|#line 909 "libyara/grammar.y" 2842| 325| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 325|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2843| 325|#line 2844 "libyara/grammar.c" 2844| 325| break; 2845| | 2846| 11.4k| case 65: /* identifier: "identifier" */ ------------------ | Branch (2846:3): [True: 11.4k, False: 358k] ------------------ 2847| 11.4k|#line 914 "libyara/grammar.y" 2848| 11.4k| { 2849| 11.4k| YR_EXPRESSION expr; 2850| | 2851| 11.4k| int result = ERROR_SUCCESS; ------------------ | | 40| 11.4k|#define ERROR_SUCCESS 0 ------------------ 2852| 11.4k| int var_index = yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), &expr); 2853| | 2854| 11.4k| if (var_index >= 0) ------------------ | Branch (2854:13): [True: 7.21k, False: 4.20k] ------------------ 2855| 7.21k| { 2856| | // The identifier corresponds to a loop variable. 2857| 7.21k| result = yr_parser_emit_with_arg( 2858| 7.21k| yyscanner, 2859| 7.21k| OP_PUSH_M, ------------------ | | 82| 7.21k|#define OP_PUSH_M 34 ------------------ 2860| 7.21k| var_index, 2861| 7.21k| NULL, 2862| 7.21k| NULL); 2863| | 2864| | // The expression associated to this identifier is the same one 2865| | // associated to the loop variable. 2866| 7.21k| (yyval.expression) = expr; 2867| 7.21k| } 2868| 4.20k| else 2869| 4.20k| { 2870| | // Search for identifier within the global namespace, where the 2871| | // externals variables reside. 2872| | 2873| 4.20k| YR_OBJECT* object = (YR_OBJECT*) yr_hash_table_lookup( 2874| 4.20k| compiler->objects_table, (yyvsp[0].c_string), NULL); 2875| | 2876| 4.20k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 2877| 4.20k| compiler->arena, 2878| 4.20k| YR_NAMESPACES_TABLE, ------------------ | | 57| 4.20k|#define YR_NAMESPACES_TABLE 0 ------------------ 2879| 4.20k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 2880| | 2881| 4.20k| if (object == NULL) ------------------ | Branch (2881:15): [True: 4.20k, False: 0] ------------------ 2882| 4.20k| { 2883| | // If not found, search within the current namespace. 2884| 4.20k| object = (YR_OBJECT*) yr_hash_table_lookup( 2885| 4.20k| compiler->objects_table, (yyvsp[0].c_string), ns->name); 2886| 4.20k| } 2887| | 2888| 4.20k| if (object != NULL) ------------------ | Branch (2888:15): [True: 1.01k, False: 3.18k] ------------------ 2889| 1.01k| { 2890| 1.01k| YR_ARENA_REF ref; 2891| | 2892| 1.01k| result = _yr_compiler_store_string( 2893| 1.01k| compiler, (yyvsp[0].c_string), &ref); 2894| | 2895| 1.01k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.01k|#define ERROR_SUCCESS 0 ------------------ | Branch (2895:17): [True: 1.01k, False: 0] ------------------ 2896| 1.01k| result = yr_parser_emit_with_arg_reloc( 2897| 1.01k| yyscanner, 2898| 1.01k| OP_OBJ_LOAD, ------------------ | | 64| 1.01k|#define OP_OBJ_LOAD 16 ------------------ 2899| 1.01k| yr_arena_ref_to_ptr(compiler->arena, &ref), 2900| 1.01k| NULL, 2901| 1.01k| NULL); 2902| | 2903| 1.01k| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 1.01k|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 2904| 1.01k| (yyval.expression).value.object = object; 2905| 1.01k| (yyval.expression).identifier.ptr = NULL; 2906| 1.01k| (yyval.expression).identifier.ref = ref; 2907| 1.01k| } 2908| 3.18k| else 2909| 3.18k| { 2910| 3.18k| uint32_t rule_idx = yr_hash_table_lookup_uint32( 2911| 3.18k| compiler->rules_table, (yyvsp[0].c_string), ns->name); 2912| | 2913| 3.18k| if (rule_idx != UINT32_MAX) ------------------ | Branch (2913:17): [True: 3.10k, False: 77] ------------------ 2914| 3.10k| { 2915| 3.10k| result = yr_parser_emit_with_arg( 2916| 3.10k| yyscanner, 2917| 3.10k| OP_PUSH_RULE, ------------------ | | 75| 3.10k|#define OP_PUSH_RULE 27 ------------------ 2918| 3.10k| rule_idx, 2919| 3.10k| NULL, 2920| 3.10k| NULL); 2921| | 2922| 3.10k| YR_RULE* rule = _yr_compiler_get_rule_by_idx(compiler, rule_idx); 2923| | 2924| 3.10k| yr_arena_ptr_to_ref(compiler->arena, rule->identifier, &(yyval.expression).identifier.ref); 2925| | 2926| 3.10k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 3.10k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 2927| 3.10k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 3.10k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 2928| 3.10k| (yyval.expression).identifier.ptr = NULL; 2929| 3.10k| } 2930| 77| else 2931| 77| { 2932| 77| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 298| 77| strlcpy( \ | | 299| 77| compiler->last_error_extra_info, \ | | 300| 77| info, \ | | 301| 77| sizeof(compiler->last_error_extra_info)); ------------------ 2933| 77| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 77|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 2934| 77| } 2935| 3.18k| } 2936| 4.20k| } 2937| | 2938| 11.4k| yr_free((yyvsp[0].c_string)); 2939| | 2940| 11.4k| fail_if_error(result); ------------------ | | 135| 11.4k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 22.8k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 77, False: 11.3k] | | ------------------ | | 136| 11.4k| { \ | | 137| 77| fail_with_error(e); \ | | ------------------ | | | | 120| 77| { \ | | | | 121| 77| compiler->last_error = e; \ | | | | 122| 77| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 77|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 77| switch (e) \ | | | | 124| 77| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 77] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 77| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 77, False: 0] | | | | ------------------ | | | | 128| 77| YYERROR; \ | | | | ------------------ | | | | | | 1311| 77|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 77| } \ | | | | 130| 77| } | | ------------------ | | 138| 0| } ------------------ 2941| 11.3k| } 2942| 0|#line 2943 "libyara/grammar.c" 2943| 0| break; 2944| | 2945| 876| case 66: /* identifier: identifier '.' "identifier" */ ------------------ | Branch (2945:3): [True: 876, False: 368k] ------------------ 2946| 876|#line 1009 "libyara/grammar.y" 2947| 876| { 2948| 876| int result = ERROR_SUCCESS; ------------------ | | 40| 876|#define ERROR_SUCCESS 0 ------------------ 2949| 876| YR_OBJECT* field = NULL; 2950| | 2951| 876| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 1.75k|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (2951:13): [True: 852, False: 24] ------------------ 2952| 876| (yyvsp[-2].expression).value.object->type == OBJECT_TYPE_STRUCTURE) ------------------ | | 60| 852|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (2952:13): [True: 843, False: 9] ------------------ 2953| 843| { 2954| 843| field = yr_object_lookup_field((yyvsp[-2].expression).value.object, (yyvsp[0].c_string)); 2955| | 2956| 843| if (field != NULL) ------------------ | Branch (2956:15): [True: 824, False: 19] ------------------ 2957| 824| { 2958| 824| YR_ARENA_REF ref; 2959| | 2960| 824| result = _yr_compiler_store_string( 2961| 824| compiler, (yyvsp[0].c_string), &ref); 2962| | 2963| 824| if (result == ERROR_SUCCESS) ------------------ | | 40| 824|#define ERROR_SUCCESS 0 ------------------ | Branch (2963:17): [True: 824, False: 0] ------------------ 2964| 824| result = yr_parser_emit_with_arg_reloc( 2965| 824| yyscanner, 2966| 824| OP_OBJ_FIELD, ------------------ | | 66| 824|#define OP_OBJ_FIELD 18 ------------------ 2967| 824| yr_arena_ref_to_ptr(compiler->arena, &ref), 2968| 824| NULL, 2969| 824| NULL); 2970| | 2971| 824| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 824|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 2972| 824| (yyval.expression).value.object = field; 2973| 824| (yyval.expression).identifier.ref = ref; 2974| 824| (yyval.expression).identifier.ptr = NULL; 2975| 824| } 2976| 19| else 2977| 19| { 2978| 19| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 298| 19| strlcpy( \ | | 299| 19| compiler->last_error_extra_info, \ | | 300| 19| info, \ | | 301| 19| sizeof(compiler->last_error_extra_info)); ------------------ 2979| 19| result = ERROR_INVALID_FIELD_NAME; ------------------ | | 78| 19|#define ERROR_INVALID_FIELD_NAME 33 ------------------ 2980| 19| } 2981| 843| } 2982| 33| else 2983| 33| { 2984| 33| yr_compiler_set_error_extra_info( ------------------ | | 298| 33| strlcpy( \ | | 299| 33| compiler->last_error_extra_info, \ | | 300| 66| info, \ | | ------------------ | | | Branch (300:7): [True: 1, False: 32] | | ------------------ | | 301| 33| sizeof(compiler->last_error_extra_info)); ------------------ 2985| 33| compiler, expression_identifier((yyvsp[-2].expression))); 2986| | 2987| 33| result = ERROR_NOT_A_STRUCTURE; ------------------ | | 80| 33|#define ERROR_NOT_A_STRUCTURE 35 ------------------ 2988| 33| } 2989| | 2990| 876| yr_free((yyvsp[0].c_string)); 2991| | 2992| 876| fail_if_error(result); ------------------ | | 135| 876| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.75k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 52, False: 824] | | ------------------ | | 136| 876| { \ | | 137| 52| fail_with_error(e); \ | | ------------------ | | | | 120| 52| { \ | | | | 121| 52| compiler->last_error = e; \ | | | | 122| 52| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 52|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 52| switch (e) \ | | | | 124| 52| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 52] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 52| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 52, False: 0] | | | | ------------------ | | | | 128| 52| YYERROR; \ | | | | ------------------ | | | | | | 1311| 52|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 52| } \ | | | | 130| 52| } | | ------------------ | | 138| 0| } ------------------ 2993| 824| } 2994| 0|#line 2995 "libyara/grammar.c" 2995| 0| break; 2996| | 2997| 446| case 67: /* identifier: identifier '[' primary_expression ']' */ ------------------ | Branch (2997:3): [True: 446, False: 369k] ------------------ 2998| 446|#line 1057 "libyara/grammar.y" 2999| 446| { 3000| 446| int result = ERROR_SUCCESS; ------------------ | | 40| 446|#define ERROR_SUCCESS 0 ------------------ 3001| 446| YR_OBJECT_ARRAY* array; 3002| 446| YR_OBJECT_DICTIONARY* dict; 3003| | 3004| 446| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 892|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3004:13): [True: 446, False: 0] ------------------ 3005| 446| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_ARRAY) ------------------ | | 61| 446|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (3005:13): [True: 8, False: 438] ------------------ 3006| 8| { 3007| 8| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 8|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3007:15): [True: 8, False: 0] ------------------ 3008| 8| { 3009| 8| yr_compiler_set_error_extra_info( ------------------ | | 298| 8| strlcpy( \ | | 299| 8| compiler->last_error_extra_info, \ | | 300| 8| info, \ | | 301| 8| sizeof(compiler->last_error_extra_info)); ------------------ 3010| 8| compiler, "array indexes must be of integer type"); 3011| 8| result = ERROR_WRONG_TYPE; ------------------ | | 69| 8|#define ERROR_WRONG_TYPE 24 ------------------ 3012| 8| } 3013| | 3014| 8| fail_if_error(result); ------------------ | | 135| 8| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 16|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 0] | | ------------------ | | 136| 8| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 3015| | 3016| 0| result = yr_parser_emit( 3017| 0| yyscanner, OP_INDEX_ARRAY, NULL); ------------------ | | 67| 0|#define OP_INDEX_ARRAY 19 ------------------ 3018| | 3019| 0| array = object_as_array((yyvsp[-3].expression).value.object); ------------------ | | 893| 0|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 3020| | 3021| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3022| 0| (yyval.expression).value.object = array->prototype_item; 3023| 0| (yyval.expression).identifier.ptr = array->identifier; 3024| 0| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 3025| 0| } 3026| 438| else if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 876|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3026:18): [True: 438, False: 0] ------------------ 3027| 438| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_DICTIONARY) ------------------ | | 63| 438|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (3027:18): [True: 406, False: 32] ------------------ 3028| 406| { 3029| 406| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 406|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3029:15): [True: 8, False: 398] ------------------ 3030| 8| { 3031| 8| yr_compiler_set_error_extra_info( ------------------ | | 298| 8| strlcpy( \ | | 299| 8| compiler->last_error_extra_info, \ | | 300| 8| info, \ | | 301| 8| sizeof(compiler->last_error_extra_info)); ------------------ 3032| 8| compiler, "dictionary keys must be of string type"); 3033| 8| result = ERROR_WRONG_TYPE; ------------------ | | 69| 8|#define ERROR_WRONG_TYPE 24 ------------------ 3034| 8| } 3035| | 3036| 406| fail_if_error(result); ------------------ | | 135| 406| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 812|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 398] | | ------------------ | | 136| 406| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 3037| | 3038| 398| result = yr_parser_emit( 3039| 398| yyscanner, OP_LOOKUP_DICT, NULL); ------------------ | | 90| 398|#define OP_LOOKUP_DICT 42 ------------------ 3040| | 3041| 398| dict = object_as_dictionary((yyvsp[-3].expression).value.object); ------------------ | | 894| 398|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 3042| | 3043| 398| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 398|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3044| 398| (yyval.expression).value.object = dict->prototype_item; 3045| 398| (yyval.expression).identifier.ptr = dict->identifier; 3046| 398| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 398| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 3047| 398| } 3048| 32| else 3049| 32| { 3050| 32| yr_compiler_set_error_extra_info( ------------------ | | 298| 32| strlcpy( \ | | 299| 32| compiler->last_error_extra_info, \ | | 300| 64| info, \ | | ------------------ | | | Branch (300:7): [True: 17, False: 15] | | ------------------ | | 301| 32| sizeof(compiler->last_error_extra_info)); ------------------ 3051| 32| compiler, expression_identifier((yyvsp[-3].expression))); 3052| | 3053| 32| result = ERROR_NOT_INDEXABLE; ------------------ | | 81| 32|#define ERROR_NOT_INDEXABLE 36 ------------------ 3054| 32| } 3055| | 3056| 430| fail_if_error(result); ------------------ | | 135| 430| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 860|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 32, False: 398] | | ------------------ | | 136| 430| { \ | | 137| 32| fail_with_error(e); \ | | ------------------ | | | | 120| 32| { \ | | | | 121| 32| compiler->last_error = e; \ | | | | 122| 32| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 32| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 32, False: 0] | | | | ------------------ | | | | 128| 32| YYERROR; \ | | | | ------------------ | | | | | | 1311| 32|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 32| } \ | | | | 130| 32| } | | ------------------ | | 138| 0| } ------------------ 3057| 398| } 3058| 0|#line 3059 "libyara/grammar.c" 3059| 0| break; 3060| | 3061| 63| case 68: /* identifier: identifier '(' arguments ')' */ ------------------ | Branch (3061:3): [True: 63, False: 369k] ------------------ 3062| 63|#line 1118 "libyara/grammar.y" 3063| 63| { 3064| 63| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 63| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 3065| 63| int result = ERROR_SUCCESS; ------------------ | | 40| 63|#define ERROR_SUCCESS 0 ------------------ 3066| | 3067| 63| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 126|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3067:13): [True: 63, False: 0] ------------------ 3068| 63| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_FUNCTION) ------------------ | | 62| 63|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (3068:13): [True: 63, False: 0] ------------------ 3069| 63| { 3070| 63| YR_OBJECT_FUNCTION* function = object_as_function((yyvsp[-3].expression).value.object); ------------------ | | 895| 63|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 3071| | 3072| 63| result = yr_parser_check_types(compiler, function, (yyvsp[-1].c_string)); 3073| | 3074| 63| if (result == ERROR_SUCCESS) ------------------ | | 40| 63|#define ERROR_SUCCESS 0 ------------------ | Branch (3074:15): [True: 63, False: 0] ------------------ 3075| 63| result = _yr_compiler_store_string( 3076| 63| compiler, (yyvsp[-1].c_string), &ref); 3077| | 3078| 63| if (result == ERROR_SUCCESS) ------------------ | | 40| 63|#define ERROR_SUCCESS 0 ------------------ | Branch (3078:15): [True: 63, False: 0] ------------------ 3079| 63| result = yr_parser_emit_with_arg_reloc( 3080| 63| yyscanner, 3081| 63| OP_CALL, ------------------ | | 63| 63|#define OP_CALL 15 ------------------ 3082| 63| yr_arena_ref_to_ptr(compiler->arena, &ref), 3083| 63| NULL, 3084| 63| NULL); 3085| | 3086| 63| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 63|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3087| 63| (yyval.expression).value.object = function->return_obj; 3088| 63| (yyval.expression).identifier.ref = ref; 3089| 63| (yyval.expression).identifier.ptr = NULL; 3090| 63| } 3091| 0| else 3092| 0| { 3093| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | ------------------ | | | Branch (300:7): [True: 0, False: 0] | | ------------------ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3094| 0| compiler, expression_identifier((yyvsp[-3].expression))); 3095| | 3096| 0| result = ERROR_NOT_A_FUNCTION; ------------------ | | 82| 0|#define ERROR_NOT_A_FUNCTION 37 ------------------ 3097| 0| } 3098| | 3099| 63| yr_free((yyvsp[-1].c_string)); 3100| | 3101| 63| fail_if_error(result); ------------------ | | 135| 63| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 126|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 63] | | ------------------ | | 136| 63| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3102| 63| } 3103| 0|#line 3104 "libyara/grammar.c" 3104| 0| break; 3105| | 3106| 64| case 69: /* arguments: %empty */ ------------------ | Branch (3106:3): [True: 64, False: 369k] ------------------ 3107| 64|#line 1162 "libyara/grammar.y" 3108| 64| { (yyval.c_string) = yr_strdup(""); } 3109| 64|#line 3110 "libyara/grammar.c" 3110| 64| break; 3111| | 3112| 63| case 70: /* arguments: arguments_list */ ------------------ | Branch (3112:3): [True: 63, False: 369k] ------------------ 3113| 63|#line 1163 "libyara/grammar.y" 3114| 63| { (yyval.c_string) = (yyvsp[0].c_string); } 3115| 63|#line 3116 "libyara/grammar.c" 3116| 63| break; 3117| | 3118| 1.24k| case 71: /* arguments_list: expression */ ------------------ | Branch (3118:3): [True: 1.24k, False: 368k] ------------------ 3119| 1.24k|#line 1168 "libyara/grammar.y" 3120| 1.24k| { 3121| 1.24k| (yyval.c_string) = (char*) yr_malloc(YR_MAX_FUNCTION_ARGS + 1); ------------------ | | 131| 1.24k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3122| | 3123| 1.24k| if ((yyval.c_string) == NULL) ------------------ | Branch (3123:13): [True: 0, False: 1.24k] ------------------ 3124| 1.24k| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3125| | 3126| 1.24k| switch((yyvsp[0].expression).type) 3127| 1.24k| { 3128| 177| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 177|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3128:11): [True: 177, False: 1.07k] ------------------ 3129| 177| strlcpy((yyval.c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 177|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3130| 177| break; 3131| 36| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 36|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3131:11): [True: 36, False: 1.21k] ------------------ 3132| 36| strlcpy((yyval.c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 36|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3133| 36| break; 3134| 531| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 531|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3134:11): [True: 531, False: 717] ------------------ 3135| 531| strlcpy((yyval.c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 531|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3136| 531| break; 3137| 370| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 370|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3137:11): [True: 370, False: 878] ------------------ 3138| 370| strlcpy((yyval.c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 370|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3139| 370| break; 3140| 131| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 131|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3140:11): [True: 131, False: 1.11k] ------------------ 3141| 131| strlcpy((yyval.c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 131|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3142| 131| break; 3143| 3| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 3|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3143:11): [True: 3, False: 1.24k] ------------------ 3144| 3| yr_free((yyval.c_string)); 3145| 3| yr_compiler_set_error_extra_info( ------------------ | | 298| 3| strlcpy( \ | | 299| 3| compiler->last_error_extra_info, \ | | 300| 3| info, \ | | 301| 3| sizeof(compiler->last_error_extra_info)); ------------------ 3146| 3| compiler, "unknown type for argument 1 in function call"); 3147| 3| fail_with_error(ERROR_WRONG_TYPE); ------------------ | | 120| 3| { \ | | 121| 3| compiler->last_error = e; \ | | 122| 3| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 3| default: \ | | ------------------ | | | Branch (127:7): [True: 3, False: 0] | | ------------------ | | 128| 3| YYERROR; \ | | ------------------ | | | | 1311| 3|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 3| } \ | | 130| 3| } ------------------ 3148| 0| break; 3149| 0| default: ------------------ | Branch (3149:11): [True: 0, False: 1.24k] ------------------ 3150| | // An unknown expression type is OK iff an error ocurred. 3151| 0| assert(compiler->last_error != ERROR_SUCCESS); 3152| 1.24k| } 3153| 1.24k| } 3154| 1.24k|#line 3155 "libyara/grammar.c" 3155| 1.24k| break; 3156| | 3157| 9.31k| case 72: /* arguments_list: arguments_list ',' expression */ ------------------ | Branch (3157:3): [True: 9.31k, False: 360k] ------------------ 3158| 9.31k|#line 1203 "libyara/grammar.y" 3159| 9.31k| { 3160| 9.31k| int result = ERROR_SUCCESS; ------------------ | | 40| 9.31k|#define ERROR_SUCCESS 0 ------------------ 3161| | 3162| 9.31k| if (strlen((yyvsp[-2].c_string)) == YR_MAX_FUNCTION_ARGS) ------------------ | | 131| 9.31k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ | Branch (3162:13): [True: 0, False: 9.31k] ------------------ 3163| 0| { 3164| 0| result = ERROR_TOO_MANY_ARGUMENTS; ------------------ | | 84| 0|#define ERROR_TOO_MANY_ARGUMENTS 39 ------------------ 3165| 0| } 3166| 9.31k| else 3167| 9.31k| { 3168| 9.31k| switch((yyvsp[0].expression).type) 3169| 9.31k| { 3170| 331| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 331|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3170:13): [True: 331, False: 8.97k] ------------------ 3171| 331| strlcat((yyvsp[-2].c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 331|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3172| 331| break; 3173| 159| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 159|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3173:13): [True: 159, False: 9.15k] ------------------ 3174| 159| strlcat((yyvsp[-2].c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 159|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3175| 159| break; 3176| 5.46k| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 5.46k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3176:13): [True: 5.46k, False: 3.84k] ------------------ 3177| 5.46k| strlcat((yyvsp[-2].c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 5.46k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3178| 5.46k| break; 3179| 3.01k| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 3.01k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3179:13): [True: 3.01k, False: 6.29k] ------------------ 3180| 3.01k| strlcat((yyvsp[-2].c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 3.01k|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3181| 3.01k| break; 3182| 340| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 340|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3182:13): [True: 340, False: 8.97k] ------------------ 3183| 340| strlcat((yyvsp[-2].c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 131| 340|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3184| 340| break; 3185| 0| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 0|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3185:13): [True: 0, False: 9.31k] ------------------ 3186| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 3187| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); ------------------ 3188| 0| compiler, "unknown type for argument %zu in function call", 3189| | // As we add one character per argument, the length of $1 is 3190| | // the number of arguments parsed so far, and the argument 3191| | // represented by is length of $1 plus one. 3192| 0| strlen((yyvsp[-2].c_string)) + 1); 3193| 0| break; 3194| 0| default: ------------------ | Branch (3194:13): [True: 0, False: 9.31k] ------------------ 3195| | // An unknown expression type is OK iff an error ocurred. 3196| 0| assert(compiler->last_error != ERROR_SUCCESS); 3197| 9.31k| } 3198| 9.31k| } 3199| | 3200| 9.31k| if (result != ERROR_SUCCESS) ------------------ | | 40| 9.31k|#define ERROR_SUCCESS 0 ------------------ | Branch (3200:13): [True: 0, False: 9.31k] ------------------ 3201| 0| yr_free((yyvsp[-2].c_string)); 3202| | 3203| 9.31k| fail_if_error(result); ------------------ | | 135| 9.31k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 18.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 9.31k] | | ------------------ | | 136| 9.31k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3204| | 3205| 9.31k| (yyval.c_string) = (yyvsp[-2].c_string); 3206| 9.31k| } 3207| 0|#line 3208 "libyara/grammar.c" 3208| 0| break; 3209| | 3210| 994| case 73: /* regexp: "regular expression" */ ------------------ | Branch (3210:3): [True: 994, False: 368k] ------------------ 3211| 994|#line 1256 "libyara/grammar.y" 3212| 994| { 3213| 994| YR_ARENA_REF re_ref; 3214| 994| RE_ERROR error; 3215| | 3216| 994| int result = ERROR_SUCCESS; ------------------ | | 40| 994|#define ERROR_SUCCESS 0 ------------------ 3217| 994| int re_flags = 0; 3218| | 3219| 994| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_NO_CASE) ------------------ | | 39| 994|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ | Branch (3219:13): [True: 165, False: 829] ------------------ 3220| 165| re_flags |= RE_FLAGS_NO_CASE; ------------------ | | 98| 165|#define RE_FLAGS_NO_CASE 0x20 ------------------ 3221| | 3222| 994| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_DOT_ALL) ------------------ | | 43| 994|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ | Branch (3222:13): [True: 32, False: 962] ------------------ 3223| 32| re_flags |= RE_FLAGS_DOT_ALL; ------------------ | | 100| 32|#define RE_FLAGS_DOT_ALL 0x80 ------------------ 3224| | 3225| 994| result = yr_re_compile( 3226| 994| (yyvsp[0].sized_string)->c_string, 3227| 994| re_flags, 3228| 994| compiler->arena, 3229| 994| &re_ref, 3230| 994| &error); 3231| | 3232| 994| yr_free((yyvsp[0].sized_string)); 3233| | 3234| 994| if (result == ERROR_INVALID_REGULAR_EXPRESSION) ------------------ | | 54| 994|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ | Branch (3234:13): [True: 192, False: 802] ------------------ 3235| 192| yr_compiler_set_error_extra_info(compiler, error.message); ------------------ | | 298| 192| strlcpy( \ | | 299| 192| compiler->last_error_extra_info, \ | | 300| 192| info, \ | | 301| 192| sizeof(compiler->last_error_extra_info)); ------------------ 3236| | 3237| 994| if (result == ERROR_SUCCESS) ------------------ | | 40| 994|#define ERROR_SUCCESS 0 ------------------ | Branch (3237:13): [True: 768, False: 226] ------------------ 3238| 768| result = yr_parser_emit_with_arg_reloc( 3239| 768| yyscanner, 3240| 768| OP_PUSH, ------------------ | | 61| 768|#define OP_PUSH 13 ------------------ 3241| 768| yr_arena_ref_to_ptr(compiler->arena, &re_ref), 3242| 768| NULL, 3243| 768| NULL); 3244| | 3245| 994| fail_if_error(result); ------------------ | | 135| 994| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.98k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 226, False: 768] | | ------------------ | | 136| 994| { \ | | 137| 226| fail_with_error(e); \ | | ------------------ | | | | 120| 226| { \ | | | | 121| 226| compiler->last_error = e; \ | | | | 122| 226| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 226|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 226| switch (e) \ | | | | 124| 226| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 226] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 226| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 226, False: 0] | | | | ------------------ | | | | 128| 226| YYERROR; \ | | | | ------------------ | | | | | | 1311| 226|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 226| } \ | | | | 130| 226| } | | ------------------ | | 138| 0| } ------------------ 3246| | 3247| 768| (yyval.expression).type = EXPRESSION_TYPE_REGEXP; ------------------ | | 49| 768|#define EXPRESSION_TYPE_REGEXP 8 ------------------ 3248| 768| } 3249| 0|#line 3250 "libyara/grammar.c" 3250| 0| break; 3251| | 3252| 8.54k| case 74: /* boolean_expression: expression */ ------------------ | Branch (3252:3): [True: 8.54k, False: 361k] ------------------ 3253| 8.54k|#line 1298 "libyara/grammar.y" 3254| 8.54k| { 3255| 8.54k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 8.54k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3255:13): [True: 150, False: 8.39k] ------------------ 3256| 150| { 3257| 150| if (!YR_ARENA_IS_NULL_REF((yyvsp[0].expression).value.sized_string_ref)) ------------------ | | 46| 150| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 150| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 150| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ ------------------ | Branch (3257:15): [True: 139, False: 11] ------------------ 3258| 139| { 3259| 139| SIZED_STRING* sized_string = yr_arena_ref_to_ptr( 3260| 139| compiler->arena, &(yyvsp[0].expression).value.sized_string_ref); 3261| | 3262| 139| yywarning(yyscanner, ------------------ | | 51| 139|#define yywarning yara_yywarning ------------------ 3263| 139| "using literal string \"%s\" in a boolean operation.", 3264| 139| sized_string->c_string); 3265| 139| } 3266| | 3267| 150| fail_if_error(yr_parser_emit( ------------------ | | 135| 150| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 300|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 150] | | ------------------ | | 136| 150| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3268| 150| yyscanner, OP_STR_TO_BOOL, NULL)); 3269| 150| } 3270| | 3271| 8.54k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 8.54k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3272| 8.54k| } 3273| 0|#line 3274 "libyara/grammar.c" 3274| 0| break; 3275| | 3276| 3| case 75: /* expression: "" */ ------------------ | Branch (3276:3): [True: 3, False: 369k] ------------------ 3277| 3|#line 1321 "libyara/grammar.y" 3278| 3| { 3279| 3| fail_if_error(yr_parser_emit_push_const(yyscanner, 1)); ------------------ | | 135| 3| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 3] | | ------------------ | | 136| 3| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3280| | 3281| 3| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 3|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3282| 3| } 3283| 0|#line 3284 "libyara/grammar.c" 3284| 0| break; 3285| | 3286| 512| case 76: /* expression: "" */ ------------------ | Branch (3286:3): [True: 512, False: 369k] ------------------ 3287| 512|#line 1327 "libyara/grammar.y" 3288| 512| { 3289| 512| fail_if_error(yr_parser_emit_push_const(yyscanner, 0)); ------------------ | | 135| 512| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.02k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 512] | | ------------------ | | 136| 512| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3290| | 3291| 512| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 512|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3292| 512| } 3293| 0|#line 3294 "libyara/grammar.c" 3294| 0| break; 3295| | 3296| 12| case 77: /* expression: primary_expression "" regexp */ ------------------ | Branch (3296:3): [True: 12, False: 369k] ------------------ 3297| 12|#line 1333 "libyara/grammar.y" 3298| 12| { 3299| 12| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "matches"); ------------------ | | 175| 12| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 12| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 8, False: 4] | | | | ------------------ | | | | 146| 12| { \ | | | | 147| 8| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 0] | | | | ------------------ | | | | 148| 8| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 8] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 8| } \ | | | | 166| 8| cleanup; \ | | | | 167| 8| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 8|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 8| } | | ------------------ ------------------ 3300| 4| check_type((yyvsp[0].expression), EXPRESSION_TYPE_REGEXP, "matches"); ------------------ | | 175| 4| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 4| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 4] | | | | ------------------ | | | | 146| 4| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3301| | 3302| 4| fail_if_error(yr_parser_emit( ------------------ | | 135| 4| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 4] | | ------------------ | | 136| 4| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3303| 4| yyscanner, 3304| 4| OP_MATCHES, 3305| 4| NULL)); 3306| | 3307| 4| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 4|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3308| 4| } 3309| 0|#line 3310 "libyara/grammar.c" 3310| 0| break; 3311| | 3312| 18| case 78: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3312:3): [True: 18, False: 369k] ------------------ 3313| 18|#line 1345 "libyara/grammar.y" 3314| 18| { 3315| 18| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 175| 18| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 18| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 18] | | | | ------------------ | | | | 146| 18| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3316| 18| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 175| 18| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 18| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 18, False: 0] | | | | ------------------ | | | | 146| 18| { \ | | | | 147| 18| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 18, False: 0] | | | | ------------------ | | | | 148| 18| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 18] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 18] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 18] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 18] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 18| } \ | | | | 166| 18| cleanup; \ | | | | 167| 18| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 18|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 18| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 18|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 18| YYERROR; \ | | | | ------------------ | | | | | | 1311| 18|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 18| } | | ------------------ ------------------ 3317| | 3318| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3319| 0| yyscanner, OP_CONTAINS, NULL)); 3320| | 3321| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3322| 0| } 3323| 0|#line 3324 "libyara/grammar.c" 3324| 0| break; 3325| | 3326| 24| case 79: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3326:3): [True: 24, False: 369k] ------------------ 3327| 24|#line 1355 "libyara/grammar.y" 3328| 24| { 3329| 24| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 175| 24| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 24| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 16, False: 8] | | | | ------------------ | | | | 146| 24| { \ | | | | 147| 16| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 8] | | | | ------------------ | | | | 148| 16| { \ | | | | 149| 8| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 8|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 8, False: 8] | | | | ------------------ | | | | 150| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 8| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 8| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 16] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 16| } \ | | | | 166| 16| cleanup; \ | | | | 167| 16| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 16|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 16| YYERROR; \ | | | | ------------------ | | | | | | 1311| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 16| } | | ------------------ ------------------ 3330| 8| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 175| 8| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 8| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 8, False: 0] | | | | ------------------ | | | | 146| 8| { \ | | | | 147| 8| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 8] | | | | ------------------ | | | | 148| 8| { \ | | | | 149| 8| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 8|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 8, False: 0] | | | | ------------------ | | | | 150| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 8| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 8| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 8] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 8| } \ | | | | 166| 8| cleanup; \ | | | | 167| 8| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 8|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 8| } | | ------------------ ------------------ 3331| | 3332| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3333| 0| yyscanner, OP_ICONTAINS, NULL)); 3334| | 3335| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3336| 0| } 3337| 0|#line 3338 "libyara/grammar.c" 3338| 0| break; 3339| | 3340| 8| case 80: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3340:3): [True: 8, False: 369k] ------------------ 3341| 8|#line 1365 "libyara/grammar.y" 3342| 8| { 3343| 8| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "startswith"); ------------------ | | 175| 8| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 8| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 8, False: 0] | | | | ------------------ | | | | 146| 8| { \ | | | | 147| 8| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 8] | | | | ------------------ | | | | 148| 8| { \ | | | | 149| 8| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 8|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 8, False: 0] | | | | ------------------ | | | | 150| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 8| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 8| break; \ | | | | 153| 0| case EXPRESSION_TYPE_FLOAT: \ | | | | ------------------ | | | | | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 | | | | ------------------ | | | | | Branch (153:9): [True: 0, False: 8] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 8| } \ | | | | 166| 8| cleanup; \ | | | | 167| 8| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 8|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 8| } | | ------------------ ------------------ 3344| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "startswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3345| | 3346| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3347| 0| yyscanner, OP_STARTSWITH, NULL)); 3348| | 3349| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3350| 0| } 3351| 0|#line 3352 "libyara/grammar.c" 3352| 0| break; 3353| | 3354| 0| case 81: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3354:3): [True: 0, False: 369k] ------------------ 3355| 0|#line 1375 "libyara/grammar.y" 3356| 0| { 3357| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "istartswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3358| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "istartswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3359| | 3360| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3361| 0| yyscanner, OP_ISTARTSWITH, NULL)); 3362| | 3363| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3364| 0| } 3365| 0|#line 3366 "libyara/grammar.c" 3366| 0| break; 3367| | 3368| 32| case 82: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3368:3): [True: 32, False: 369k] ------------------ 3369| 32|#line 1385 "libyara/grammar.y" 3370| 32| { 3371| 32| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 175| 32| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 32| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 32] | | | | ------------------ | | | | 146| 32| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3372| 32| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 175| 32| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 32| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 32] | | | | ------------------ | | | | 146| 32| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3373| | 3374| 32| fail_if_error(yr_parser_emit( ------------------ | | 135| 32| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 64|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 32] | | ------------------ | | 136| 32| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3375| 32| yyscanner, OP_ENDSWITH, NULL)); 3376| | 3377| 32| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 32|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3378| 32| } 3379| 0|#line 3380 "libyara/grammar.c" 3380| 0| break; 3381| | 3382| 57| case 83: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3382:3): [True: 57, False: 369k] ------------------ 3383| 57|#line 1395 "libyara/grammar.y" 3384| 57| { 3385| 57| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 175| 57| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 57| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 57] | | | | ------------------ | | | | 146| 57| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3386| 57| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 175| 57| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 57| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 9, False: 48] | | | | ------------------ | | | | 146| 57| { \ | | | | 147| 9| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 1] | | | | ------------------ | | | | 148| 9| { \ | | | | 149| 1| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 1|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 1, False: 8] | | | | ------------------ | | | | 150| 1| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 1| strlcpy( \ | | | | | | 299| 1| compiler->last_error_extra_info, \ | | | | | | 300| 1| info, \ | | | | | | 301| 1| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 151| 1| compiler, "wrong type \"integer\" for " op " operator"); \ | | | | 152| 1| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 9|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 9| YYERROR; \ | | | | ------------------ | | | | | | 1311| 9|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 9| } | | ------------------ ------------------ 3387| | 3388| 48| fail_if_error(yr_parser_emit( ------------------ | | 135| 48| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 96|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 48] | | ------------------ | | 136| 48| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3389| 48| yyscanner, OP_IENDSWITH, NULL)); 3390| | 3391| 48| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 48|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3392| 48| } 3393| 0|#line 3394 "libyara/grammar.c" 3394| 0| break; 3395| | 3396| 0| case 84: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3396:3): [True: 0, False: 369k] ------------------ 3397| 0|#line 1405 "libyara/grammar.y" 3398| 0| { 3399| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3400| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3401| | 3402| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3403| 0| yyscanner, OP_IEQUALS, NULL)); 3404| | 3405| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3406| 0| } 3407| 0|#line 3408 "libyara/grammar.c" 3408| 0| break; 3409| | 3410| 394| case 85: /* expression: "string identifier" */ ------------------ | Branch (3410:3): [True: 394, False: 369k] ------------------ 3411| 394|#line 1415 "libyara/grammar.y" 3412| 394| { 3413| 394| int result = yr_parser_reduce_string_identifier( 3414| 394| yyscanner, 3415| 394| (yyvsp[0].c_string), 3416| 394| OP_FOUND, ------------------ | | 70| 394|#define OP_FOUND 22 ------------------ 3417| 394| YR_UNDEFINED); ------------------ | | 38| 394|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 3418| | 3419| 394| yr_free((yyvsp[0].c_string)); 3420| | 3421| 394| fail_if_error(result); ------------------ | | 135| 394| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 788|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 2, False: 392] | | ------------------ | | 136| 394| { \ | | 137| 2| fail_with_error(e); \ | | ------------------ | | | | 120| 2| { \ | | | | 121| 2| compiler->last_error = e; \ | | | | 122| 2| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 2| switch (e) \ | | | | 124| 2| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 2] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 2| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 2, False: 0] | | | | ------------------ | | | | 128| 2| YYERROR; \ | | | | ------------------ | | | | | | 1311| 2|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 2| } \ | | | | 130| 2| } | | ------------------ | | 138| 0| } ------------------ 3422| | 3423| 392| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 392|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3424| 392| } 3425| 0|#line 3426 "libyara/grammar.c" 3426| 0| break; 3427| | 3428| 787| case 86: /* expression: "string identifier" "" primary_expression */ ------------------ | Branch (3428:3): [True: 787, False: 368k] ------------------ 3429| 787|#line 1429 "libyara/grammar.y" 3430| 787| { 3431| 787| int result; 3432| | 3433| 787| check_type_with_cleanup((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "at", yr_free((yyvsp[-2].c_string))); ------------------ | | 145| 787| if (((expression.type) & (expected_type)) == 0) \ | | ------------------ | | | Branch (145:9): [True: 0, False: 787] | | ------------------ | | 146| 787| { \ | | 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( \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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( \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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( \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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( \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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); \ | | ------------------ | | | | 49| 0|#define yyerror yara_yyerror | | ------------------ | | 169| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 170| 0| } ------------------ 3434| | 3435| 787| result = yr_parser_reduce_string_identifier( 3436| 787| yyscanner, (yyvsp[-2].c_string), OP_FOUND_AT, (yyvsp[0].expression).value.integer); ------------------ | | 71| 787|#define OP_FOUND_AT 23 ------------------ 3437| | 3438| 787| yr_free((yyvsp[-2].c_string)); 3439| | 3440| 787| fail_if_error(result); ------------------ | | 135| 787| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.57k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 787] | | ------------------ | | 136| 787| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3441| | 3442| 787| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 787|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3443| 787| } 3444| 0|#line 3445 "libyara/grammar.c" 3445| 0| break; 3446| | 3447| 0| case 87: /* expression: "string identifier" "" range */ ------------------ | Branch (3447:3): [True: 0, False: 369k] ------------------ 3448| 0|#line 1444 "libyara/grammar.y" 3449| 0| { 3450| 0| int result = yr_parser_reduce_string_identifier( 3451| 0| yyscanner, (yyvsp[-2].c_string), OP_FOUND_IN, YR_UNDEFINED); ------------------ | | 72| 0|#define OP_FOUND_IN 24 ------------------ yyscanner, (yyvsp[-2].c_string), OP_FOUND_IN, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 3452| | 3453| 0| yr_free((yyvsp[-2].c_string)); 3454| | 3455| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [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); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3456| | 3457| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3458| 0| } 3459| 0|#line 3460 "libyara/grammar.c" 3460| 0| break; 3461| | 3462| 1.36k| case 88: /* expression: "" for_expression error */ ------------------ | Branch (3462:3): [True: 1.36k, False: 368k] ------------------ 3463| 1.36k|#line 1455 "libyara/grammar.y" 3464| 1.36k| { 3465| | // Free all the loop variable identifiers, including the variables for 3466| | // the current loop (represented by loop_index), and set loop_index to 3467| | // -1. This is OK even if we have nested loops. If an error occurs while 3468| | // parsing the inner loop, it will be propagated to the outer loop 3469| | // anyways, so it's safe to do this cleanup while processing the error 3470| | // for the inner loop. 3471| | 3472| 2.69k| for (int i = 0; i <= compiler->loop_index; i++) ------------------ | Branch (3472:25): [True: 1.32k, False: 1.36k] ------------------ 3473| 1.32k| { 3474| 1.32k| loop_vars_cleanup(i); ------------------ | | 179| 1.32k| { \ | | 180| 1.32k| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 2.80k| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 1.47k, False: 1.32k] | | ------------------ | | 182| 1.47k| { \ | | 183| 1.47k| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 1.47k| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 1.47k| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 1.47k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | 186| 1.47k| } \ | | 187| 1.32k| loop_ctx->vars_count = 0; \ | | 188| 1.32k| } \ ------------------ 3475| 1.32k| } 3476| | 3477| 1.36k| compiler->loop_index = -1; 3478| 1.36k| YYERROR; ------------------ | | 1311| 1.36k|#define YYERROR goto yyerrorlab ------------------ 3479| 0| } 3480| 0|#line 3481 "libyara/grammar.c" 3481| 0| break; 3482| | 3483| 1.47k| case 89: /* $@6: %empty */ ------------------ | Branch (3483:3): [True: 1.47k, False: 368k] ------------------ 3484| 1.47k|#line 1529 "libyara/grammar.y" 3485| 1.47k| { 3486| | // var_frame is used for accessing local variables used in this loop. 3487| | // All local variables are accessed using var_frame as a reference, 3488| | // like var_frame + 0, var_frame + 1, etc. Here we initialize var_frame 3489| | // with the correct value, which depends on the number of variables 3490| | // defined by any outer loops. 3491| | 3492| 1.47k| int var_frame; 3493| 1.47k| int result = ERROR_SUCCESS; ------------------ | | 40| 1.47k|#define ERROR_SUCCESS 0 ------------------ 3494| | 3495| 1.47k| if (compiler->loop_index + 1 == YR_MAX_LOOP_NESTING) ------------------ | | 96| 1.47k|#define YR_MAX_LOOP_NESTING 4 ------------------ | Branch (3495:13): [True: 9, False: 1.46k] ------------------ 3496| 9| result = ERROR_LOOP_NESTING_LIMIT_EXCEEDED; ------------------ | | 57| 9|#define ERROR_LOOP_NESTING_LIMIT_EXCEEDED 12 ------------------ 3497| | 3498| 1.47k| fail_if_error(result); ------------------ | | 135| 1.47k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.95k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 9, False: 1.46k] | | ------------------ | | 136| 1.47k| { \ | | 137| 9| fail_with_error(e); \ | | ------------------ | | | | 120| 9| { \ | | | | 121| 9| compiler->last_error = e; \ | | | | 122| 9| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 9| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 9, False: 0] | | | | ------------------ | | | | 128| 9| YYERROR; \ | | | | ------------------ | | | | | | 1311| 9|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 9| } \ | | | | 130| 9| } | | ------------------ | | 138| 0| } ------------------ 3499| | 3500| 1.46k| compiler->loop_index++; 3501| | 3502| | // This loop uses internal variables besides the ones explicitly 3503| | // defined by the user. 3504| 1.46k| compiler->loop[compiler->loop_index].vars_internal_count = \ 3505| 1.46k| YR_INTERNAL_LOOP_VARS; ------------------ | | 76| 1.46k|#define YR_INTERNAL_LOOP_VARS 3 ------------------ 3506| | 3507| | // Initialize the number of variables, this number will be incremented 3508| | // as variable declaration are processed by for_variables. 3509| 1.46k| compiler->loop[compiler->loop_index].vars_count = 0; 3510| | 3511| 1.46k| var_frame = _yr_compiler_get_var_frame(compiler); 3512| | 3513| 1.46k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.46k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.93k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.46k] | | ------------------ | | 136| 1.46k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3514| 1.46k| yyscanner, OP_CLEAR_M, var_frame + 0, NULL, NULL)); 3515| | 3516| 1.46k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.46k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.93k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.46k] | | ------------------ | | 136| 1.46k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3517| 1.46k| yyscanner, OP_CLEAR_M, var_frame + 1, NULL, NULL)); 3518| | 3519| 1.46k| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 1.46k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.93k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.46k] | | ------------------ | | 136| 1.46k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3520| 1.46k| yyscanner, OP_POP_M, var_frame + 2, NULL, NULL)); 3521| 1.46k| } 3522| 0|#line 3523 "libyara/grammar.c" 3523| 0| break; 3524| | 3525| 503| case 90: /* $@7: %empty */ ------------------ | Branch (3525:3): [True: 503, False: 369k] ------------------ 3526| 503|#line 1567 "libyara/grammar.y" 3527| 503| { 3528| 503| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 3529| 503| YR_FIXUP* fixup; 3530| | 3531| 503| YR_ARENA_REF loop_start_ref; 3532| 503| YR_ARENA_REF jmp_offset_ref; 3533| | 3534| 503| int var_frame = _yr_compiler_get_var_frame(compiler); 3535| | 3536| 503| fail_if_error(yr_parser_emit( ------------------ | | 135| 503| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.00k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 503] | | ------------------ | | 136| 503| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3537| 503| yyscanner, OP_ITER_NEXT, &loop_start_ref)); 3538| | 3539| | // For each variable generate an instruction that pops the value from 3540| | // the stack and store it into one memory slot starting at var_frame + 3541| | // YR_INTERNAL_LOOP_VARS because the first YR_INTERNAL_LOOP_VARS slots 3542| | // in the frame are for the internal variables. 3543| | 3544| 1.02k| for (int i = 0; i < loop_ctx->vars_count; i++) ------------------ | Branch (3544:25): [True: 525, False: 503] ------------------ 3545| 525| { 3546| 525| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 525| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.05k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 525] | | ------------------ | | 136| 525| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3547| 525| yyscanner, 3548| 525| OP_POP_M, 3549| 525| var_frame + YR_INTERNAL_LOOP_VARS + i, 3550| 525| NULL, 3551| 525| NULL)); 3552| 525| } 3553| | 3554| 503| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 503| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.00k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 503] | | ------------------ | | 136| 503| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3555| 503| yyscanner, 3556| 503| OP_JTRUE_P, 3557| 503| 0, // still don't know the jump offset, use 0 for now. 3558| 503| NULL, 3559| 503| &jmp_offset_ref)); 3560| | 3561| | // We still don't know the jump's target, so we push a fixup entry 3562| | // in the stack, so that the jump's offset can be set once we know it. 3563| | 3564| 503| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3565| | 3566| 503| if (fixup == NULL) ------------------ | Branch (3566:13): [True: 0, False: 503] ------------------ 3567| 503| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3568| | 3569| 503| fixup->ref = jmp_offset_ref; 3570| 503| fixup->next = compiler->fixup_stack_head; 3571| 503| compiler->fixup_stack_head = fixup; 3572| | 3573| 503| loop_ctx->start_ref = loop_start_ref; 3574| 503| } 3575| 0|#line 3576 "libyara/grammar.c" 3576| 0| break; 3577| | 3578| 139| case 91: /* expression: "" for_expression $@6 for_iteration ':' $@7 '(' boolean_expression ')' */ ------------------ | Branch (3578:3): [True: 139, False: 369k] ------------------ 3579| 139|#line 1616 "libyara/grammar.y" 3580| 139| { 3581| 139| int32_t jmp_offset; 3582| 139| YR_FIXUP* fixup; 3583| 139| YR_ARENA_REF pop_ref; 3584| | 3585| 139| int var_frame = _yr_compiler_get_var_frame(compiler); 3586| | 3587| 139| if ((yyvsp[-5].integer) == FOR_ITERATION_STRING_SET) ------------------ | | 113| 139|#define FOR_ITERATION_STRING_SET 2 ------------------ | Branch (3587:13): [True: 28, False: 111] ------------------ 3588| 28| { 3589| 28| compiler->loop_for_of_var_index = -1; 3590| 28| } 3591| | 3592| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3593| 139| yyscanner, OP_INCR_M, var_frame + 1, NULL, NULL)); 3594| | 3595| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3596| 139| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3597| | 3598| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3599| 139| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3600| | 3601| 139| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_CONDITION, NULL)); ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3602| | 3603| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3604| 139| yyscanner, OP_ADD_M, var_frame + 0, NULL, NULL)); 3605| | 3606| 139| jmp_offset = \ 3607| 139| compiler->loop[compiler->loop_index].start_ref.offset - 3608| 139| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION); ------------------ | | 63| 139|#define YR_CODE_SECTION 6 ------------------ 3609| | 3610| 139| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3611| 139| yyscanner, 3612| 139| OP_JTRUE_P, 3613| 139| jmp_offset, 3614| 139| NULL, 3615| 139| NULL)); 3616| | 3617| 139| fail_if_error(yr_parser_emit( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3618| 139| yyscanner, OP_POP, &pop_ref)); 3619| | 3620| | // Pop from the stack the fixup entry containing the reference to 3621| | // the jump offset that needs to be fixed. 3622| | 3623| 139| fixup = compiler->fixup_stack_head; 3624| 139| compiler->fixup_stack_head = fixup->next; 3625| | 3626| | // The fixup entry has a reference to the jump offset that need 3627| | // to be fixed, convert the address into a pointer. 3628| 139| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3629| 139| compiler->arena, &fixup->ref); 3630| | 3631| | // The reference in the fixup entry points to the jump's offset 3632| | // but the jump instruction is one byte before, that's why we add 3633| | // one to the offset. 3634| 139| jmp_offset = pop_ref.offset - fixup->ref.offset + 1; 3635| | 3636| | // Fix the jump's offset. 3637| 139| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3638| | 3639| 139| yr_free(fixup); 3640| | 3641| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3642| 139| yyscanner, OP_PUSH_M, var_frame + 1, NULL, NULL)); 3643| | 3644| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3645| 139| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3646| | 3647| 139| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3648| 139| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3649| | 3650| 139| fail_if_error(yr_parser_emit( ------------------ | | 135| 139| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 278|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 139] | | ------------------ | | 136| 139| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3651| 139| yyscanner, OP_ITER_END, NULL)); 3652| | 3653| 139| loop_vars_cleanup(compiler->loop_index); ------------------ | | 179| 139| { \ | | 180| 139| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 282| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 143, False: 139] | | ------------------ | | 182| 143| { \ | | 183| 143| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 143| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 143| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 143| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | 186| 143| } \ | | 187| 139| loop_ctx->vars_count = 0; \ | | 188| 139| } \ ------------------ 3654| | 3655| 139| compiler->loop_index--; 3656| | 3657| 139| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 139|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3658| 139| } 3659| 0|#line 3660 "libyara/grammar.c" 3660| 0| break; 3661| | 3662| 279| case 92: /* expression: for_expression "" string_set */ ------------------ | Branch (3662:3): [True: 279, False: 369k] ------------------ 3663| 279|#line 1696 "libyara/grammar.y" 3664| 279| { 3665| 279| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].integer)) ------------------ | | 47| 558|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3665:13): [True: 1, False: 278] | Branch (3665:71): [True: 0, False: 1] ------------------ 3666| 0| { 3667| 0| yywarning(yyscanner, ------------------ | | 51| 0|#define yywarning yara_yywarning ------------------ 3668| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].integer)); 3669| 0| } 3670| 279| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 74| 279|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 42| 279|#define OF_STRING_SET 0 ------------------ 3671| | 3672| 279| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 279|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3673| 279| } 3674| 279|#line 3675 "libyara/grammar.c" 3675| 279| break; 3676| | 3677| 10| case 93: /* expression: for_expression "" rule_set */ ------------------ | Branch (3677:3): [True: 10, False: 369k] ------------------ 3678| 10|#line 1707 "libyara/grammar.y" 3679| 10| { 3680| 10| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].integer)) ------------------ | | 47| 20|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3680:13): [True: 0, False: 10] | Branch (3680:71): [True: 0, False: 0] ------------------ 3681| 0| { 3682| 0| yywarning(yyscanner, ------------------ | | 51| 0|#define yywarning yara_yywarning ------------------ 3683| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].integer)); 3684| 0| } 3685| 10| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 74| 10|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 10|#define OF_RULE_SET 1 ------------------ 3686| | 3687| 10| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 10|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3688| 10| } 3689| 10|#line 3690 "libyara/grammar.c" 3690| 10| break; 3691| | 3692| 4| case 94: /* expression: primary_expression '%' "" string_set */ ------------------ | Branch (3692:3): [True: 4, False: 369k] ------------------ 3693| 4|#line 1718 "libyara/grammar.y" 3694| 4| { 3695| 4| check_type((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 4| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 4| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 4, False: 0] | | | | ------------------ | | | | 146| 4| { \ | | | | 147| 4| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 4, False: 0] | | | | ------------------ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 4] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 4] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 4|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 4| YYERROR; \ | | | | ------------------ | | | | | | 1311| 4|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 4| } | | ------------------ ------------------ 3696| | 3697| | // The value of primary_expression can be undefined because 3698| | // it could be a variable for which don't know the value during 3699| | // compiling time. However, if the value is defined it should be 3700| | // in the range [1,100]. 3701| 0| if (!IS_UNDEFINED((yyvsp[-3].expression).value.integer) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3701:13): [True: 0, False: 0] ------------------ 3702| 0| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3702:14): [True: 0, False: 0] | Branch (3702:58): [True: 0, False: 0] ------------------ 3703| 0| { 3704| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3705| 0| compiler, "percentage must be between 1 and 100 (inclusive)"); 3706| | 3707| 0| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3708| 0| } 3709| | 3710| 0| yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_STRING_SET, NULL, NULL); ------------------ | | 122| 0|#define OP_OF_PERCENT 74 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_STRING_SET, NULL, NULL); ------------------ | | 42| 0|#define OF_STRING_SET 0 ------------------ 3711| 0| } 3712| 0|#line 3713 "libyara/grammar.c" 3713| 0| break; 3714| | 3715| 88| case 95: /* expression: primary_expression '%' "" rule_set */ ------------------ | Branch (3715:3): [True: 88, False: 369k] ------------------ 3716| 88|#line 1737 "libyara/grammar.y" 3717| 88| { 3718| 88| check_type((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 88| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 88| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 62, False: 26] | | | | ------------------ | | | | 146| 88| { \ | | | | 147| 62| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 26, False: 36] | | | | ------------------ | | | | 148| 62| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 62] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 62] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 28| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 28|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 28, False: 34] | | | | ------------------ | | | | 158| 28| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 28| strlcpy( \ | | | | | | 299| 28| compiler->last_error_extra_info, \ | | | | | | 300| 28| info, \ | | | | | | 301| 28| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 28| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 28| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 54] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 62| } \ | | | | 166| 62| cleanup; \ | | | | 167| 62| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 62|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 62| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 62|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 62| YYERROR; \ | | | | ------------------ | | | | | | 1311| 62|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 62| } | | ------------------ ------------------ 3719| | 3720| | // The value of primary_expression can be undefined because 3721| | // it could be a variable for which don't know the value during 3722| | // compiling time. However, if the value is defined it should be 3723| | // in the range [1,100]. 3724| 26| if (!IS_UNDEFINED((yyvsp[-3].expression).value.integer) && ------------------ | | 39| 52|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 26|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3724:13): [True: 2, False: 24] ------------------ 3725| 26| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3725:14): [True: 2, False: 0] | Branch (3725:58): [True: 0, False: 0] ------------------ 3726| 2| { 3727| 2| yr_compiler_set_error_extra_info( ------------------ | | 298| 2| strlcpy( \ | | 299| 2| compiler->last_error_extra_info, \ | | 300| 2| info, \ | | 301| 2| sizeof(compiler->last_error_extra_info)); ------------------ 3728| 2| compiler, "percentage must be between 1 and 100 (inclusive)"); 3729| | 3730| 2| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 2| { \ | | 121| 2| compiler->last_error = e; \ | | 122| 2| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 2|#define yyerror yara_yyerror | | ------------------ | | 123| 2| switch (e) \ | | 124| 2| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 2] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 2| default: \ | | ------------------ | | | Branch (127:7): [True: 2, False: 0] | | ------------------ | | 128| 2| YYERROR; \ | | ------------------ | | | | 1311| 2|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 2| } \ | | 130| 2| } ------------------ 3731| 0| } 3732| | 3733| 24| yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 122| 24|#define OP_OF_PERCENT 74 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 24|#define OF_RULE_SET 1 ------------------ 3734| 24| } 3735| 0|#line 3736 "libyara/grammar.c" 3736| 0| break; 3737| | 3738| 0| case 96: /* expression: for_expression "" string_set "" range */ ------------------ | Branch (3738:3): [True: 0, False: 369k] ------------------ 3739| 0|#line 1756 "libyara/grammar.y" 3740| 0| { 3741| 0| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].integer)) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3741:13): [True: 0, False: 0] | Branch (3741:71): [True: 0, False: 0] ------------------ 3742| 0| { 3743| 0| yywarning(yyscanner, ------------------ | | 51| 0|#define yywarning yara_yywarning ------------------ 3744| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].integer)); 3745| 0| } 3746| | 3747| 0| yr_parser_emit(yyscanner, OP_OF_FOUND_IN, NULL); ------------------ | | 123| 0|#define OP_OF_FOUND_IN 75 ------------------ 3748| | 3749| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3750| 0| } 3751| 0|#line 3752 "libyara/grammar.c" 3752| 0| break; 3753| | 3754| 2.45k| case 97: /* expression: for_expression "" string_set "" primary_expression */ ------------------ | Branch (3754:3): [True: 2.45k, False: 367k] ------------------ 3755| 2.45k|#line 1768 "libyara/grammar.y" 3756| 2.45k| { 3757| 2.45k| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 2.45k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3757:13): [True: 0, False: 2.45k] ------------------ 3758| 0| { 3759| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3760| 0| "at expression must be an integer"); 3761| | 3762| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3763| 0| } 3764| | 3765| 2.45k| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].integer)) ------------------ | | 47| 4.91k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3765:13): [True: 57, False: 2.40k] | Branch (3765:71): [True: 0, False: 57] ------------------ 3766| 0| { 3767| 0| yywarning(yyscanner, ------------------ | | 51| 0|#define yywarning yara_yywarning ------------------ 3768| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].integer)); 3769| 0| } 3770| | 3771| | // Both of these are warnings: 3772| | // 3773| | // "N of them at 0" where N > 1 3774| | // 3775| | //"all of them at 0" where there is more than 1 in "them". 3776| | // 3777| | // This means you can do "all of them at 0" if you only have one string 3778| | // defined in the set. 3779| 2.45k| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 4.91k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3779:14): [True: 57, False: 2.40k] ------------------ 3780| 2.45k| !IS_UNDEFINED((yyvsp[-4].expression).value.integer) && (yyvsp[-4].expression).value.integer > 1) || ------------------ | | 39| 2.51k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 57|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3780:15): [True: 8, False: 49] | Branch (3780:70): [True: 0, False: 8] ------------------ 3781| 2.45k| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 4.91k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3781:16): [True: 2.40k, False: 57] ------------------ 3782| 2.45k| (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL && (yyvsp[-2].integer) > 1)) ------------------ | | 108| 4.85k|#define FOR_EXPRESSION_ALL 1 ------------------ | Branch (3782:15): [True: 658, False: 1.74k] | Branch (3782:77): [True: 408, False: 250] ------------------ 3783| 408| { 3784| 408| yywarning(yyscanner, ------------------ | | 51| 408|#define yywarning yara_yywarning ------------------ 3785| 408| "multiple strings at an offset is usually false."); 3786| 408| } 3787| | 3788| 2.45k| yr_parser_emit(yyscanner, OP_OF_FOUND_AT, NULL); ------------------ | | 127| 2.45k|#define OP_OF_FOUND_AT 79 ------------------ 3789| | 3790| 2.45k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 2.45k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3791| 2.45k| } 3792| 0|#line 3793 "libyara/grammar.c" 3793| 0| break; 3794| | 3795| 330| case 98: /* expression: "" boolean_expression */ ------------------ | Branch (3795:3): [True: 330, False: 369k] ------------------ 3796| 330|#line 1805 "libyara/grammar.y" 3797| 330| { 3798| 330| yr_parser_emit(yyscanner, OP_NOT, NULL); ------------------ | | 51| 330|#define OP_NOT 3 ------------------ 3799| | 3800| 330| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 330|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3801| 330| } 3802| 330|#line 3803 "libyara/grammar.c" 3803| 330| break; 3804| | 3805| 0| case 99: /* expression: "" boolean_expression */ ------------------ | Branch (3805:3): [True: 0, False: 369k] ------------------ 3806| 0|#line 1811 "libyara/grammar.y" 3807| 0| { 3808| 0| yr_parser_emit(yyscanner, OP_DEFINED, NULL); ------------------ | | 125| 0|#define OP_DEFINED 77 ------------------ 3809| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3810| 0| } 3811| 0|#line 3812 "libyara/grammar.c" 3812| 0| break; 3813| | 3814| 196| case 100: /* $@8: %empty */ ------------------ | Branch (3814:3): [True: 196, False: 369k] ------------------ 3815| 196|#line 1816 "libyara/grammar.y" 3816| 196| { 3817| 196| YR_FIXUP* fixup; 3818| 196| YR_ARENA_REF jmp_offset_ref; 3819| | 3820| 196| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 196| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 392|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 196] | | ------------------ | | 136| 196| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3821| 196| yyscanner, 3822| 196| OP_JFALSE, 3823| 196| 0, // still don't know the jump offset, use 0 for now. 3824| 196| NULL, 3825| 196| &jmp_offset_ref)); 3826| | 3827| | // Create a fixup entry for the jump and push it in the stack. 3828| 196| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3829| | 3830| 196| if (fixup == NULL) ------------------ | Branch (3830:13): [True: 0, False: 196] ------------------ 3831| 196| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3832| | 3833| 196| fixup->ref = jmp_offset_ref; 3834| 196| fixup->next = compiler->fixup_stack_head; 3835| 196| compiler->fixup_stack_head = fixup; 3836| 196| } 3837| 0|#line 3838 "libyara/grammar.c" 3838| 0| break; 3839| | 3840| 194| case 101: /* expression: boolean_expression "" $@8 boolean_expression */ ------------------ | Branch (3840:3): [True: 194, False: 369k] ------------------ 3841| 194|#line 1838 "libyara/grammar.y" 3842| 194| { 3843| 194| YR_FIXUP* fixup; 3844| | 3845| 194| fail_if_error(yr_parser_emit(yyscanner, OP_AND, NULL)); ------------------ | | 135| 194| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 388|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 194] | | ------------------ | | 136| 194| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3846| | 3847| 194| fixup = compiler->fixup_stack_head; 3848| | 3849| 194| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3850| 194| compiler->arena, &fixup->ref); 3851| | 3852| 194| int32_t jmp_offset = \ 3853| 194| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 194|#define YR_CODE_SECTION 6 ------------------ 3854| 194| fixup->ref.offset + 1; 3855| | 3856| 194| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3857| | 3858| | // Remove fixup from the stack. 3859| 194| compiler->fixup_stack_head = fixup->next; 3860| 194| yr_free(fixup); 3861| | 3862| 194| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 194|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3863| 194| } 3864| 0|#line 3865 "libyara/grammar.c" 3865| 0| break; 3866| | 3867| 4.16k| case 102: /* $@9: %empty */ ------------------ | Branch (3867:3): [True: 4.16k, False: 365k] ------------------ 3868| 4.16k|#line 1861 "libyara/grammar.y" 3869| 4.16k| { 3870| 4.16k| YR_FIXUP* fixup; 3871| 4.16k| YR_ARENA_REF jmp_offset_ref; 3872| | 3873| 4.16k| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 4.16k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.33k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 4.16k] | | ------------------ | | 136| 4.16k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3874| 4.16k| yyscanner, 3875| 4.16k| OP_JTRUE, 3876| 4.16k| 0, // still don't know the jump destination, use 0 for now. 3877| 4.16k| NULL, 3878| 4.16k| &jmp_offset_ref)); 3879| | 3880| 4.16k| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3881| | 3882| 4.16k| if (fixup == NULL) ------------------ | Branch (3882:13): [True: 0, False: 4.16k] ------------------ 3883| 4.16k| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3884| | 3885| 4.16k| fixup->ref = jmp_offset_ref; 3886| 4.16k| fixup->next = compiler->fixup_stack_head; 3887| 4.16k| compiler->fixup_stack_head = fixup; 3888| 4.16k| } 3889| 0|#line 3890 "libyara/grammar.c" 3890| 0| break; 3891| | 3892| 3.14k| case 103: /* expression: boolean_expression "" $@9 boolean_expression */ ------------------ | Branch (3892:3): [True: 3.14k, False: 366k] ------------------ 3893| 3.14k|#line 1882 "libyara/grammar.y" 3894| 3.14k| { 3895| 3.14k| YR_FIXUP* fixup; 3896| | 3897| 3.14k| fail_if_error(yr_parser_emit(yyscanner, OP_OR, NULL)); ------------------ | | 135| 3.14k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.28k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 3.14k] | | ------------------ | | 136| 3.14k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3898| | 3899| 3.14k| fixup = compiler->fixup_stack_head; 3900| | 3901| 3.14k| int32_t jmp_offset = \ 3902| 3.14k| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 3.14k|#define YR_CODE_SECTION 6 ------------------ 3903| 3.14k| fixup->ref.offset + 1; 3904| | 3905| 3.14k| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3906| 3.14k| compiler->arena, &fixup->ref); 3907| | 3908| 3.14k| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3909| | 3910| | // Remove fixup from the stack. 3911| 3.14k| compiler->fixup_stack_head = fixup->next; 3912| 3.14k| yr_free(fixup); 3913| | 3914| 3.14k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 3.14k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3915| 3.14k| } 3916| 0|#line 3917 "libyara/grammar.c" 3917| 0| break; 3918| | 3919| 871| case 104: /* expression: primary_expression "<" primary_expression */ ------------------ | Branch (3919:3): [True: 871, False: 368k] ------------------ 3920| 871|#line 1905 "libyara/grammar.y" 3921| 871| { 3922| 871| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 871| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.74k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 35, False: 836] | | ------------------ | | 136| 871| { \ | | 137| 35| fail_with_error(e); \ | | ------------------ | | | | 120| 35| { \ | | | | 121| 35| compiler->last_error = e; \ | | | | 122| 35| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 35|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 35| switch (e) \ | | | | 124| 35| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 35] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 35| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 35, False: 0] | | | | ------------------ | | | | 128| 35| YYERROR; \ | | | | ------------------ | | | | | | 1311| 35|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 35| } \ | | | | 130| 35| } | | ------------------ | | 138| 0| } ------------------ 3923| 871| yyscanner, "<", (yyvsp[-2].expression), (yyvsp[0].expression))); 3924| | 3925| 836| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 836|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3926| 836| } 3927| 0|#line 3928 "libyara/grammar.c" 3928| 0| break; 3929| | 3930| 1.17k| case 105: /* expression: primary_expression ">" primary_expression */ ------------------ | Branch (3930:3): [True: 1.17k, False: 368k] ------------------ 3931| 1.17k|#line 1912 "libyara/grammar.y" 3932| 1.17k| { 3933| 1.17k| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 1.17k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.34k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 1.16k] | | ------------------ | | 136| 1.17k| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 3934| 1.17k| yyscanner, ">", (yyvsp[-2].expression), (yyvsp[0].expression))); 3935| | 3936| 1.16k| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 1.16k|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3937| 1.16k| } 3938| 0|#line 3939 "libyara/grammar.c" 3939| 0| break; 3940| | 3941| 347| case 106: /* expression: primary_expression "<=" primary_expression */ ------------------ | Branch (3941:3): [True: 347, False: 369k] ------------------ 3942| 347|#line 1919 "libyara/grammar.y" 3943| 347| { 3944| 347| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 347| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 694|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 24, False: 323] | | ------------------ | | 136| 347| { \ | | 137| 24| fail_with_error(e); \ | | ------------------ | | | | 120| 24| { \ | | | | 121| 24| compiler->last_error = e; \ | | | | 122| 24| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 24|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 24| switch (e) \ | | | | 124| 24| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 24] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 24| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 24, False: 0] | | | | ------------------ | | | | 128| 24| YYERROR; \ | | | | ------------------ | | | | | | 1311| 24|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 24| } \ | | | | 130| 24| } | | ------------------ | | 138| 0| } ------------------ 3945| 347| yyscanner, "<=", (yyvsp[-2].expression), (yyvsp[0].expression))); 3946| | 3947| 323| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 323|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3948| 323| } 3949| 0|#line 3950 "libyara/grammar.c" 3950| 0| break; 3951| | 3952| 419| case 107: /* expression: primary_expression ">=" primary_expression */ ------------------ | Branch (3952:3): [True: 419, False: 369k] ------------------ 3953| 419|#line 1926 "libyara/grammar.y" 3954| 419| { 3955| 419| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 419| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 838|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 19, False: 400] | | ------------------ | | 136| 419| { \ | | 137| 19| fail_with_error(e); \ | | ------------------ | | | | 120| 19| { \ | | | | 121| 19| compiler->last_error = e; \ | | | | 122| 19| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 19|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 19| switch (e) \ | | | | 124| 19| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 19] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 19| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 19, False: 0] | | | | ------------------ | | | | 128| 19| YYERROR; \ | | | | ------------------ | | | | | | 1311| 19|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 19| } \ | | | | 130| 19| } | | ------------------ | | 138| 0| } ------------------ 3956| 419| yyscanner, ">=", (yyvsp[-2].expression), (yyvsp[0].expression))); 3957| | 3958| 400| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 400|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3959| 400| } 3960| 0|#line 3961 "libyara/grammar.c" 3961| 0| break; 3962| | 3963| 310| case 108: /* expression: primary_expression "==" primary_expression */ ------------------ | Branch (3963:3): [True: 310, False: 369k] ------------------ 3964| 310|#line 1933 "libyara/grammar.y" 3965| 310| { 3966| 310| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 310| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 620|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 302] | | ------------------ | | 136| 310| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 3967| 310| yyscanner, "==", (yyvsp[-2].expression), (yyvsp[0].expression))); 3968| | 3969| 302| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 302|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3970| 302| } 3971| 0|#line 3972 "libyara/grammar.c" 3972| 0| break; 3973| | 3974| 192| case 109: /* expression: primary_expression "!=" primary_expression */ ------------------ | Branch (3974:3): [True: 192, False: 369k] ------------------ 3975| 192|#line 1940 "libyara/grammar.y" 3976| 192| { 3977| 192| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 192| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 384|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 192] | | ------------------ | | 136| 192| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3978| 192| yyscanner, "!=", (yyvsp[-2].expression), (yyvsp[0].expression))); 3979| | 3980| 192| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 192|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3981| 192| } 3982| 0|#line 3983 "libyara/grammar.c" 3983| 0| break; 3984| | 3985| 7.53k| case 110: /* expression: primary_expression */ ------------------ | Branch (3985:3): [True: 7.53k, False: 362k] ------------------ 3986| 7.53k|#line 1947 "libyara/grammar.y" 3987| 7.53k| { 3988| 7.53k| (yyval.expression) = (yyvsp[0].expression); 3989| 7.53k| } 3990| 7.53k|#line 3991 "libyara/grammar.c" 3991| 7.53k| break; 3992| | 3993| 207| case 111: /* expression: '(' expression ')' */ ------------------ | Branch (3993:3): [True: 207, False: 369k] ------------------ 3994| 207|#line 1951 "libyara/grammar.y" 3995| 207| { 3996| 207| (yyval.expression) = (yyvsp[-1].expression); 3997| 207| } 3998| 207|#line 3999 "libyara/grammar.c" 3999| 207| break; 4000| | 4001| 479| case 112: /* for_iteration: for_variables "" iterator */ ------------------ | Branch (4001:3): [True: 479, False: 369k] ------------------ 4002| 479|#line 1958 "libyara/grammar.y" 4003| 479| { (yyval.integer) = FOR_ITERATION_ITERATOR; } ------------------ | | 112| 479|#define FOR_ITERATION_ITERATOR 1 ------------------ 4004| 479|#line 4005 "libyara/grammar.c" 4005| 479| break; 4006| | 4007| 130| case 113: /* for_iteration: "" string_iterator */ ------------------ | Branch (4007:3): [True: 130, False: 369k] ------------------ 4008| 130|#line 1960 "libyara/grammar.y" 4009| 130| { 4010| 130| int var_frame; 4011| 130| int result = ERROR_SUCCESS; ------------------ | | 40| 130|#define ERROR_SUCCESS 0 ------------------ 4012| | 4013| 130| if (compiler->loop_for_of_var_index != -1) ------------------ | Branch (4013:13): [True: 46, False: 84] ------------------ 4014| 46| result = ERROR_NESTED_FOR_OF_LOOP; ------------------ | | 77| 46|#define ERROR_NESTED_FOR_OF_LOOP 32 ------------------ 4015| | 4016| 130| fail_if_error(result); ------------------ | | 135| 130| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 260|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 46, False: 84] | | ------------------ | | 136| 130| { \ | | 137| 46| fail_with_error(e); \ | | ------------------ | | | | 120| 46| { \ | | | | 121| 46| compiler->last_error = e; \ | | | | 122| 46| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 46|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 46| switch (e) \ | | | | 124| 46| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 46] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 46| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 46, False: 0] | | | | ------------------ | | | | 128| 46| YYERROR; \ | | | | ------------------ | | | | | | 1311| 46|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 46| } \ | | | | 130| 46| } | | ------------------ | | 138| 0| } ------------------ 4017| | 4018| | // Simulate that we have 1 variable with string loops 4019| 84| compiler->loop[compiler->loop_index].vars_count = 1; 4020| | 4021| | // Set where we can find our string in case $ is in 4022| | // the body of the loop 4023| 84| var_frame = _yr_compiler_get_var_frame(compiler); 4024| 84| compiler->loop_for_of_var_index = var_frame + 4025| 84| compiler->loop[compiler->loop_index].vars_internal_count; 4026| | 4027| 84| (yyval.integer) = FOR_ITERATION_STRING_SET; ------------------ | | 113| 84|#define FOR_ITERATION_STRING_SET 2 ------------------ 4028| 84| } 4029| 0|#line 4030 "libyara/grammar.c" 4030| 0| break; 4031| | 4032| 1.32k| case 114: /* for_variables: "identifier" */ ------------------ | Branch (4032:3): [True: 1.32k, False: 368k] ------------------ 4033| 1.32k|#line 1985 "libyara/grammar.y" 4034| 1.32k| { 4035| 1.32k| int result = ERROR_SUCCESS; ------------------ | | 40| 1.32k|#define ERROR_SUCCESS 0 ------------------ 4036| | 4037| 1.32k| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4038| | 4039| 1.32k| if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4039:13): [True: 58, False: 1.27k] ------------------ 4040| 58| { 4041| 58| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 298| 58| strlcpy( \ | | 299| 58| compiler->last_error_extra_info, \ | | 300| 58| info, \ | | 301| 58| sizeof(compiler->last_error_extra_info)); ------------------ 4042| 58| yr_free((yyvsp[0].c_string)); 4043| | 4044| 58| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 58|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4045| 58| } 4046| | 4047| 1.32k| fail_if_error(result); ------------------ | | 135| 1.32k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.65k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 58, False: 1.27k] | | ------------------ | | 136| 1.32k| { \ | | 137| 58| fail_with_error(e); \ | | ------------------ | | | | 120| 58| { \ | | | | 121| 58| compiler->last_error = e; \ | | | | 122| 58| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 58|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 58| switch (e) \ | | | | 124| 58| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 58] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 58| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 58, False: 0] | | | | ------------------ | | | | 128| 58| YYERROR; \ | | | | ------------------ | | | | | | 1311| 58|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 58| } \ | | | | 130| 58| } | | ------------------ | | 138| 0| } ------------------ 4048| | 4049| 1.27k| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4050| | 4051| 1.27k| assert(loop_ctx->vars_count <= YR_MAX_LOOP_VARS); 4052| 1.27k| } 4053| 1.27k|#line 4054 "libyara/grammar.c" 4054| 1.27k| break; 4055| | 4056| 1.27k| case 115: /* for_variables: for_variables ',' "identifier" */ ------------------ | Branch (4056:3): [True: 281, False: 369k] ------------------ 4057| 281|#line 2005 "libyara/grammar.y" 4058| 281| { 4059| 281| int result = ERROR_SUCCESS; ------------------ | | 40| 281|#define ERROR_SUCCESS 0 ------------------ 4060| | 4061| 281| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4062| | 4063| 281| if (loop_ctx->vars_count == YR_MAX_LOOP_VARS) ------------------ | | 103| 281|#define YR_MAX_LOOP_VARS 2 ------------------ | Branch (4063:13): [True: 13, False: 268] ------------------ 4064| 13| { 4065| 13| yr_compiler_set_error_extra_info(compiler, "too many loop variables"); ------------------ | | 298| 13| strlcpy( \ | | 299| 13| compiler->last_error_extra_info, \ | | 300| 13| info, \ | | 301| 13| sizeof(compiler->last_error_extra_info)); ------------------ 4066| 13| yr_free((yyvsp[0].c_string)); 4067| | 4068| 13| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 13|#define ERROR_SYNTAX_ERROR 11 ------------------ 4069| 13| } 4070| 268| else if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4070:18): [True: 1, False: 267] ------------------ 4071| 1| { 4072| 1| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 298| 1| strlcpy( \ | | 299| 1| compiler->last_error_extra_info, \ | | 300| 1| info, \ | | 301| 1| sizeof(compiler->last_error_extra_info)); ------------------ 4073| 1| yr_free((yyvsp[0].c_string)); 4074| | 4075| 1| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 1|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4076| 1| } 4077| | 4078| 281| fail_if_error(result); ------------------ | | 135| 281| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 562|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 14, False: 267] | | ------------------ | | 136| 281| { \ | | 137| 14| fail_with_error(e); \ | | ------------------ | | | | 120| 14| { \ | | | | 121| 14| compiler->last_error = e; \ | | | | 122| 14| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 14| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 14, False: 0] | | | | ------------------ | | | | 128| 14| YYERROR; \ | | | | ------------------ | | | | | | 1311| 14|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 14| } \ | | | | 130| 14| } | | ------------------ | | 138| 0| } ------------------ 4079| | 4080| 267| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4081| 267| } 4082| 0|#line 4083 "libyara/grammar.c" 4083| 0| break; 4084| | 4085| 91| case 116: /* iterator: identifier */ ------------------ | Branch (4085:3): [True: 91, False: 369k] ------------------ 4086| 91|#line 2033 "libyara/grammar.y" 4087| 91| { 4088| 91| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4089| | 4090| | // Initially we assume that the identifier is from a non-iterable type, 4091| | // this will change later if it's iterable. 4092| 91| int result = ERROR_WRONG_TYPE; ------------------ | | 69| 91|#define ERROR_WRONG_TYPE 24 ------------------ 4093| | 4094| 91| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 91|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4094:13): [True: 83, False: 8] ------------------ 4095| 83| { 4096| 83| switch((yyvsp[0].expression).value.object->type) ------------------ | Branch (4096:18): [True: 29, False: 54] ------------------ 4097| 83| { 4098| 2| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 2|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (4098:13): [True: 2, False: 81] ------------------ 4099| | // If iterating an array the loop must define a single variable 4100| | // that will hold the current item. If a different number of 4101| | // variables were defined that's an error. 4102| 2| if (loop_ctx->vars_count == 1) ------------------ | Branch (4102:19): [True: 2, False: 0] ------------------ 4103| 2| { 4104| 2| loop_ctx->vars[0].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 2|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4105| 2| loop_ctx->vars[0].value.object = \ 4106| 2| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 893| 2|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4107| | 4108| 2| result = yr_parser_emit(yyscanner, OP_ITER_START_ARRAY, NULL); ------------------ | | 102| 2|#define OP_ITER_START_ARRAY 54 ------------------ 4109| 2| } 4110| 0| else 4111| 0| { 4112| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); | | ------------------ | | | Branch (308:7): [True: 0, False: 0] | | ------------------ ------------------ 4113| 0| compiler, 4114| 0| "iterator for \"%s\" yields a single item on each iteration" 4115| 0| ", but the loop expects %d", 4116| 0| expression_identifier((yyvsp[0].expression)), 4117| 0| loop_ctx->vars_count); 4118| | 4119| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4120| 0| } 4121| 2| break; 4122| | 4123| 52| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 52|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (4123:13): [True: 52, False: 31] ------------------ 4124| | // If iterating a dictionary the loop must define exactly two 4125| | // variables, one for the key and another for the value . If a 4126| | // different number of variables were defined that's an error. 4127| 52| if (loop_ctx->vars_count == 2) ------------------ | Branch (4127:19): [True: 52, False: 0] ------------------ 4128| 52| { 4129| 52| loop_ctx->vars[0].type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 52|#define EXPRESSION_TYPE_STRING 4 ------------------ 4130| 52| loop_ctx->vars[0].value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 52| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 4131| 52| loop_ctx->vars[1].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 52|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4132| 52| loop_ctx->vars[1].value.object = \ 4133| 52| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 893| 52|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4134| | 4135| 52| result = yr_parser_emit(yyscanner, OP_ITER_START_DICT, NULL); ------------------ | | 103| 52|#define OP_ITER_START_DICT 55 ------------------ 4136| 52| } 4137| 0| else 4138| 0| { 4139| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); | | ------------------ | | | Branch (308:7): [True: 0, False: 0] | | ------------------ ------------------ 4140| 0| compiler, 4141| 0| "iterator for \"%s\" yields a key,value pair item on each iteration", 4142| 0| expression_identifier((yyvsp[0].expression))); 4143| | 4144| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4145| 0| } 4146| 52| break; 4147| 83| } 4148| 83| } 4149| | 4150| 91| if (result == ERROR_WRONG_TYPE) ------------------ | | 69| 91|#define ERROR_WRONG_TYPE 24 ------------------ | Branch (4150:13): [True: 37, False: 54] ------------------ 4151| 37| { 4152| 37| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 37| snprintf( \ | | 305| 37| compiler->last_error_extra_info, \ | | 306| 37| sizeof(compiler->last_error_extra_info), \ | | 307| 37| fmt, \ | | 308| 74| __VA_ARGS__); | | ------------------ | | | Branch (308:7): [True: 0, False: 37] | | ------------------ ------------------ 4153| 37| compiler, 4154| 37| "identifier \"%s\" is not iterable", 4155| 37| expression_identifier((yyvsp[0].expression))); 4156| 37| } 4157| | 4158| 91| fail_if_error(result); ------------------ | | 135| 91| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 182|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 37, False: 54] | | ------------------ | | 136| 91| { \ | | 137| 37| fail_with_error(e); \ | | ------------------ | | | | 120| 37| { \ | | | | 121| 37| compiler->last_error = e; \ | | | | 122| 37| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 37|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 37| switch (e) \ | | | | 124| 37| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 37] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 37| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 37, False: 0] | | | | ------------------ | | | | 128| 37| YYERROR; \ | | | | ------------------ | | | | | | 1311| 37|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 37| } \ | | | | 130| 37| } | | ------------------ | | 138| 0| } ------------------ 4159| 54| } 4160| 0|#line 4161 "libyara/grammar.c" 4161| 0| break; 4162| | 4163| 445| case 117: /* iterator: set */ ------------------ | Branch (4163:3): [True: 445, False: 369k] ------------------ 4164| 445|#line 2107 "libyara/grammar.y" 4165| 445| { 4166| 445| int result = ERROR_SUCCESS; ------------------ | | 40| 445|#define ERROR_SUCCESS 0 ------------------ 4167| | 4168| 445| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4169| | 4170| 445| if (loop_ctx->vars_count == 1) ------------------ | Branch (4170:13): [True: 425, False: 20] ------------------ 4171| 425| { 4172| 425| loop_ctx->vars[0].type = (yyvsp[0].enumeration).type; 4173| 425| loop_ctx->vars[0].value.integer = YR_UNDEFINED; ------------------ | | 38| 425|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4174| 425| } 4175| 20| else 4176| 20| { 4177| 20| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 20| snprintf( \ | | 305| 20| compiler->last_error_extra_info, \ | | 306| 20| sizeof(compiler->last_error_extra_info), \ | | 307| 20| fmt, \ | | 308| 20| __VA_ARGS__); ------------------ 4178| 20| compiler, 4179| 20| "iterator yields one value on each iteration " 4180| 20| ", but the loop expects %d", 4181| 20| loop_ctx->vars_count); 4182| | 4183| 20| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 20|#define ERROR_SYNTAX_ERROR 11 ------------------ 4184| 20| } 4185| | 4186| 445| fail_if_error(result); ------------------ | | 135| 445| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 890|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 20, False: 425] | | ------------------ | | 136| 445| { \ | | 137| 20| fail_with_error(e); \ | | ------------------ | | | | 120| 20| { \ | | | | 121| 20| compiler->last_error = e; \ | | | | 122| 20| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 20| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 20, False: 0] | | | | ------------------ | | | | 128| 20| YYERROR; \ | | | | ------------------ | | | | | | 1311| 20|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 20| } \ | | | | 130| 20| } | | ------------------ | | 138| 0| } ------------------ 4187| 425| } 4188| 0|#line 4189 "libyara/grammar.c" 4189| 0| break; 4190| | 4191| 436| case 118: /* set: '(' enumeration ')' */ ------------------ | Branch (4191:3): [True: 436, False: 369k] ------------------ 4192| 436|#line 2135 "libyara/grammar.y" 4193| 436| { 4194| | // $2.count contains the number of items in the enumeration 4195| 436| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[-1].enumeration).count)); ------------------ | | 135| 436| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 872|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 436] | | ------------------ | | 136| 436| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4196| | 4197| 436| if ((yyvsp[-1].enumeration).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 436|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4197:13): [True: 416, False: 20] ------------------ 4198| 416| { 4199| 416| fail_if_error(yr_parser_emit( ------------------ | | 135| 416| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 832|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 416] | | ------------------ | | 136| 416| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4200| 416| yyscanner, OP_ITER_START_INT_ENUM, NULL)); 4201| 416| } 4202| 20| else 4203| 20| { 4204| 20| fail_if_error(yr_parser_emit( ------------------ | | 135| 20| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 40|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 20] | | ------------------ | | 136| 20| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4205| 20| yyscanner, OP_ITER_START_TEXT_STRING_SET, NULL)); 4206| 20| } 4207| | 4208| 436| (yyval.enumeration).type = (yyvsp[-1].enumeration).type; 4209| | 4210| 436| } 4211| 0|#line 4212 "libyara/grammar.c" 4212| 0| break; 4213| | 4214| 9| case 119: /* set: range */ ------------------ | Branch (4214:3): [True: 9, False: 369k] ------------------ 4215| 9|#line 2154 "libyara/grammar.y" 4216| 9| { 4217| 9| fail_if_error(yr_parser_emit( ------------------ | | 135| 9| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 18|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 9] | | ------------------ | | 136| 9| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4218| 9| yyscanner, OP_ITER_START_INT_RANGE, NULL)); 4219| | 4220| 9| (yyval.enumeration).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 9|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4221| 9| } 4222| 0|#line 4223 "libyara/grammar.c" 4223| 0| break; 4224| | 4225| 41| case 120: /* range: '(' primary_expression ".." primary_expression ')' */ ------------------ | Branch (4225:3): [True: 41, False: 369k] ------------------ 4226| 41|#line 2165 "libyara/grammar.y" 4227| 41| { 4228| 41| int result = ERROR_SUCCESS; ------------------ | | 40| 41|#define ERROR_SUCCESS 0 ------------------ 4229| | 4230| 41| if ((yyvsp[-3].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 41|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4230:13): [True: 0, False: 41] ------------------ 4231| 0| { 4232| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4233| 0| compiler, "wrong type for range's lower bound"); 4234| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4235| 0| } 4236| | 4237| 41| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 41|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4237:13): [True: 0, False: 41] ------------------ 4238| 0| { 4239| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4240| 0| compiler, "wrong type for range's upper bound"); 4241| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4242| 0| } 4243| | 4244| | // If we can statically determine lower and upper bounds, ensure 4245| | // lower < upper. Check for upper bound here because some things (like 4246| | // string count) are EXPRESSION_TYPE_INTEGER. 4247| 41| if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 82|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 41|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (4247:13): [True: 41, False: 0] | Branch (4247:69): [True: 41, False: 0] ------------------ 4248| 41| { 4249| 41| if ((yyvsp[-3].expression).value.integer > (yyvsp[-1].expression).value.integer) ------------------ | Branch (4249:15): [True: 0, False: 41] ------------------ 4250| 0| { 4251| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4252| 0| compiler, "range lower bound must be less than upper bound"); 4253| 0| result = ERROR_INVALID_VALUE; ------------------ | | 109| 0|#define ERROR_INVALID_VALUE 64 ------------------ 4254| 0| } 4255| 41| else if ((yyvsp[-3].expression).value.integer < 0) ------------------ | Branch (4255:20): [True: 0, False: 41] ------------------ 4256| 0| { 4257| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4258| 0| compiler, "range lower bound can not be negative"); 4259| 0| result = ERROR_INVALID_VALUE; ------------------ | | 109| 0|#define ERROR_INVALID_VALUE 64 ------------------ 4260| 0| } 4261| 41| } 4262| | 4263| 41| fail_if_error(result); ------------------ | | 135| 41| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 82|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 41] | | ------------------ | | 136| 41| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4264| 41| } 4265| 0|#line 4266 "libyara/grammar.c" 4266| 0| break; 4267| | 4268| 529| case 121: /* enumeration: primary_expression */ ------------------ | Branch (4268:3): [True: 529, False: 369k] ------------------ 4269| 529|#line 2208 "libyara/grammar.y" 4270| 529| { 4271| 529| int result = ERROR_SUCCESS; ------------------ | | 40| 529|#define ERROR_SUCCESS 0 ------------------ 4272| | 4273| 529| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 47| 1.05k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 26|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4273:13): [True: 26, False: 503] | Branch (4273:70): [True: 3, False: 23] ------------------ 4274| 3| { 4275| 3| yr_compiler_set_error_extra_info( ------------------ | | 298| 3| strlcpy( \ | | 299| 3| compiler->last_error_extra_info, \ | | 300| 3| info, \ | | 301| 3| sizeof(compiler->last_error_extra_info)); ------------------ 4276| 3| compiler, "wrong type for enumeration item"); 4277| 3| result = ERROR_WRONG_TYPE; ------------------ | | 69| 3|#define ERROR_WRONG_TYPE 24 ------------------ 4278| 3| } 4279| | 4280| 529| fail_if_error(result); ------------------ | | 135| 529| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.05k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 3, False: 526] | | ------------------ | | 136| 529| { \ | | 137| 3| fail_with_error(e); \ | | ------------------ | | | | 120| 3| { \ | | | | 121| 3| compiler->last_error = e; \ | | | | 122| 3| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 3| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 3, False: 0] | | | | ------------------ | | | | 128| 3| YYERROR; \ | | | | ------------------ | | | | | | 1311| 3|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 3| } \ | | | | 130| 3| } | | ------------------ | | 138| 0| } ------------------ 4281| | 4282| 526| (yyval.enumeration).type = (yyvsp[0].expression).type; 4283| 526| (yyval.enumeration).count = 1; 4284| 526| } 4285| 0|#line 4286 "libyara/grammar.c" 4286| 0| break; 4287| | 4288| 131| case 122: /* enumeration: enumeration ',' primary_expression */ ------------------ | Branch (4288:3): [True: 131, False: 369k] ------------------ 4289| 131|#line 2224 "libyara/grammar.y" 4290| 131| { 4291| 131| int result = ERROR_SUCCESS; ------------------ | | 40| 131|#define ERROR_SUCCESS 0 ------------------ 4292| | 4293| 131| if ((yyvsp[0].expression).type != (yyvsp[-2].enumeration).type) ------------------ | Branch (4293:13): [True: 0, False: 131] ------------------ 4294| 0| { 4295| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4296| 0| compiler, "enumerations must be all the same type"); 4297| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4298| 0| } 4299| | 4300| 131| fail_if_error(result); ------------------ | | 135| 131| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 262|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 131] | | ------------------ | | 136| 131| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4301| | 4302| 131| (yyval.enumeration).type = (yyvsp[-2].enumeration).type; 4303| 131| (yyval.enumeration).count = (yyvsp[-2].enumeration).count + 1; 4304| 131| } 4305| 0|#line 4306 "libyara/grammar.c" 4306| 0| break; 4307| | 4308| 130| case 123: /* string_iterator: string_set */ ------------------ | Branch (4308:3): [True: 130, False: 369k] ------------------ 4309| 130|#line 2244 "libyara/grammar.y" 4310| 130| { 4311| 130| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].integer))); ------------------ | | 135| 130| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 260|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 130] | | ------------------ | | 136| 130| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4312| 130| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_START_STRING_SET, ------------------ | | 135| 130| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 260|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 130] | | ------------------ | | 136| 130| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4313| 130| NULL)); 4314| 130| } 4315| 0|#line 4316 "libyara/grammar.c" 4316| 0| break; 4317| | 4318| 2.84k| case 124: /* $@10: %empty */ ------------------ | Branch (4318:3): [True: 2.84k, False: 366k] ------------------ 4319| 2.84k|#line 2253 "libyara/grammar.y" 4320| 2.84k| { 4321| | // Push end-of-list marker 4322| 2.84k| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 2.84k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4323| 2.84k| } 4324| 2.84k|#line 4325 "libyara/grammar.c" 4325| 2.84k| break; 4326| | 4327| 2.81k| case 125: /* string_set: '(' $@10 string_enumeration ')' */ ------------------ | Branch (4327:3): [True: 2.81k, False: 366k] ------------------ 4328| 2.81k|#line 2258 "libyara/grammar.y" 4329| 2.81k| { 4330| 2.81k| (yyval.integer) = (yyvsp[-1].integer); 4331| 2.81k| } 4332| 2.81k|#line 4333 "libyara/grammar.c" 4333| 2.81k| break; 4334| | 4335| 71| case 126: /* string_set: "" */ ------------------ | Branch (4335:3): [True: 71, False: 369k] ------------------ 4336| 71|#line 2262 "libyara/grammar.y" 4337| 71| { 4338| 71| fail_if_error(yr_parser_emit_push_const(yyscanner, YR_UNDEFINED)); ------------------ | | 135| 71| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 142|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 71] | | ------------------ | | 136| 71| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4339| | 4340| 71| int count = 0; 4341| 71| fail_if_error(yr_parser_emit_pushes_for_strings( ------------------ | | 135| 71| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 142|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 19, False: 52] | | ------------------ | | 136| 71| { \ | | 137| 19| fail_with_error(e); \ | | ------------------ | | | | 120| 19| { \ | | | | 121| 19| compiler->last_error = e; \ | | | | 122| 19| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 19|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 19| switch (e) \ | | | | 124| 19| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 19] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 19| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 19, False: 0] | | | | ------------------ | | | | 128| 19| YYERROR; \ | | | | ------------------ | | | | | | 1311| 19|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 19| } \ | | | | 130| 19| } | | ------------------ | | 138| 0| } ------------------ 4342| 71| yyscanner, "$*", &count)); 4343| | 4344| 52| (yyval.integer) = count; 4345| 52| } 4346| 0|#line 4347 "libyara/grammar.c" 4347| 0| break; 4348| | 4349| 2.83k| case 127: /* string_enumeration: string_enumeration_item */ ------------------ | Branch (4349:3): [True: 2.83k, False: 366k] ------------------ 4350| 2.83k|#line 2275 "libyara/grammar.y" 4351| 2.83k| { (yyval.integer) = (yyvsp[0].integer); } 4352| 2.83k|#line 4353 "libyara/grammar.c" 4353| 2.83k| break; 4354| | 4355| 802| case 128: /* string_enumeration: string_enumeration ',' string_enumeration_item */ ------------------ | Branch (4355:3): [True: 802, False: 368k] ------------------ 4356| 802|#line 2276 "libyara/grammar.y" 4357| 802| { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); } 4358| 802|#line 4359 "libyara/grammar.c" 4359| 802| break; 4360| | 4361| 3.27k| case 129: /* string_enumeration_item: "string identifier" */ ------------------ | Branch (4361:3): [True: 3.27k, False: 366k] ------------------ 4362| 3.27k|#line 2282 "libyara/grammar.y" 4363| 3.27k| { 4364| 3.27k| int count = 0; 4365| 3.27k| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &count); 4366| 3.27k| yr_free((yyvsp[0].c_string)); 4367| | 4368| 3.27k| fail_if_error(result); ------------------ | | 135| 3.27k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.54k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 13, False: 3.25k] | | ------------------ | | 136| 3.27k| { \ | | 137| 13| fail_with_error(e); \ | | ------------------ | | | | 120| 13| { \ | | | | 121| 13| compiler->last_error = e; \ | | | | 122| 13| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 13| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 13, False: 0] | | | | ------------------ | | | | 128| 13| YYERROR; \ | | | | ------------------ | | | | | | 1311| 13|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 13| } \ | | | | 130| 13| } | | ------------------ | | 138| 0| } ------------------ 4369| | 4370| 3.25k| (yyval.integer) = count; 4371| 3.25k| } 4372| 0|#line 4373 "libyara/grammar.c" 4373| 0| break; 4374| | 4375| 374| case 130: /* string_enumeration_item: "string identifier with wildcard" */ ------------------ | Branch (4375:3): [True: 374, False: 369k] ------------------ 4376| 374|#line 2292 "libyara/grammar.y" 4377| 374| { 4378| 374| int count = 0; 4379| 374| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &count); 4380| 374| yr_free((yyvsp[0].c_string)); 4381| | 4382| 374| fail_if_error(result); ------------------ | | 135| 374| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 748|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 374] | | ------------------ | | 136| 374| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4383| | 4384| 374| (yyval.integer) = count; 4385| 374| } 4386| 0|#line 4387 "libyara/grammar.c" 4387| 0| break; 4388| | 4389| 180| case 131: /* $@11: %empty */ ------------------ | Branch (4389:3): [True: 180, False: 369k] ------------------ 4390| 180|#line 2306 "libyara/grammar.y" 4391| 180| { 4392| | // Push end-of-list marker 4393| 180| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 180|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4394| 180| } 4395| 180|#line 4396 "libyara/grammar.c" 4396| 180| break; 4397| | 4398| 98| case 132: /* rule_set: '(' $@11 rule_enumeration ')' */ ------------------ | Branch (4398:3): [True: 98, False: 369k] ------------------ 4399| 98|#line 2311 "libyara/grammar.y" 4400| 98| { 4401| 98| (yyval.integer) = (yyvsp[-1].integer); 4402| 98| } 4403| 98|#line 4404 "libyara/grammar.c" 4404| 98| break; 4405| | 4406| 121| case 133: /* rule_enumeration: rule_enumeration_item */ ------------------ | Branch (4406:3): [True: 121, False: 369k] ------------------ 4407| 121|#line 2318 "libyara/grammar.y" 4408| 121| { (yyval.integer) = (yyvsp[0].integer); } 4409| 121|#line 4410 "libyara/grammar.c" 4410| 121| break; 4411| | 4412| 1.13k| case 134: /* rule_enumeration: rule_enumeration ',' rule_enumeration_item */ ------------------ | Branch (4412:3): [True: 1.13k, False: 368k] ------------------ 4413| 1.13k|#line 2319 "libyara/grammar.y" 4414| 1.13k| { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); } 4415| 1.13k|#line 4416 "libyara/grammar.c" 4416| 1.13k| break; 4417| | 4418| 303| case 135: /* rule_enumeration_item: "identifier" */ ------------------ | Branch (4418:3): [True: 303, False: 369k] ------------------ 4419| 303|#line 2325 "libyara/grammar.y" 4420| 303| { 4421| 303| int result = ERROR_SUCCESS; ------------------ | | 40| 303|#define ERROR_SUCCESS 0 ------------------ 4422| | 4423| 303| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4424| 303| compiler->arena, 4425| 303| YR_NAMESPACES_TABLE, ------------------ | | 57| 303|#define YR_NAMESPACES_TABLE 0 ------------------ 4426| 303| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4427| | 4428| 303| uint32_t rule_idx = yr_hash_table_lookup_uint32( 4429| 303| compiler->rules_table, (yyvsp[0].c_string), ns->name); 4430| | 4431| 303| if (rule_idx != UINT32_MAX) ------------------ | Branch (4431:13): [True: 268, False: 35] ------------------ 4432| 268| { 4433| 268| result = yr_parser_emit_with_arg( 4434| 268| yyscanner, 4435| 268| OP_PUSH_RULE, ------------------ | | 75| 268|#define OP_PUSH_RULE 27 ------------------ 4436| 268| rule_idx, 4437| 268| NULL, 4438| 268| NULL); 4439| 268| } 4440| 35| else 4441| 35| { 4442| 35| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 298| 35| strlcpy( \ | | 299| 35| compiler->last_error_extra_info, \ | | 300| 35| info, \ | | 301| 35| sizeof(compiler->last_error_extra_info)); ------------------ 4443| 35| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 35|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 4444| 35| } 4445| | 4446| 303| yr_free((yyvsp[0].c_string)); 4447| | 4448| 303| fail_if_error(result); ------------------ | | 135| 303| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 606|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 35, False: 268] | | ------------------ | | 136| 303| { \ | | 137| 35| fail_with_error(e); \ | | ------------------ | | | | 120| 35| { \ | | | | 121| 35| compiler->last_error = e; \ | | | | 122| 35| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 35|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 35| switch (e) \ | | | | 124| 35| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 35] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 35| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 35, False: 0] | | | | ------------------ | | | | 128| 35| YYERROR; \ | | | | ------------------ | | | | | | 1311| 35|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 35| } \ | | | | 130| 35| } | | ------------------ | | 138| 0| } ------------------ 4449| | 4450| 268| (yyval.integer) = 1; 4451| 268| } 4452| 0|#line 4453 "libyara/grammar.c" 4453| 0| break; 4454| | 4455| 1.01k| case 136: /* rule_enumeration_item: "identifier" '*' */ ------------------ | Branch (4455:3): [True: 1.01k, False: 368k] ------------------ 4456| 1.01k|#line 2358 "libyara/grammar.y" 4457| 1.01k| { 4458| 1.01k| int count = 0; 4459| 1.01k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4460| 1.01k| compiler->arena, 4461| 1.01k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.01k|#define YR_NAMESPACES_TABLE 0 ------------------ 4462| 1.01k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4463| | 4464| 1.01k| yr_hash_table_add_uint32( 4465| 1.01k| compiler->wildcard_identifiers_table, 4466| 1.01k| (yyvsp[-1].c_string), 4467| 1.01k| ns->name, 4468| 1.01k| 1); 4469| | 4470| 1.01k| int result = yr_parser_emit_pushes_for_rules(yyscanner, (yyvsp[-1].c_string), &count); 4471| 1.01k| yr_free((yyvsp[-1].c_string)); 4472| | 4473| 1.01k| fail_if_error(result); ------------------ | | 135| 1.01k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.02k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 30, False: 984] | | ------------------ | | 136| 1.01k| { \ | | 137| 30| fail_with_error(e); \ | | ------------------ | | | | 120| 30| { \ | | | | 121| 30| compiler->last_error = e; \ | | | | 122| 30| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 30|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 30| switch (e) \ | | | | 124| 30| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 30] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 30| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 30, False: 0] | | | | ------------------ | | | | 128| 30| YYERROR; \ | | | | ------------------ | | | | | | 1311| 30|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 30| } \ | | | | 130| 30| } | | ------------------ | | 138| 0| } ------------------ 4474| | 4475| 984| (yyval.integer) = count; 4476| 984| } 4477| 0|#line 4478 "libyara/grammar.c" 4478| 0| break; 4479| | 4480| 1.25k| case 137: /* for_expression: primary_expression */ ------------------ | Branch (4480:3): [True: 1.25k, False: 368k] ------------------ 4481| 1.25k|#line 2383 "libyara/grammar.y" 4482| 1.25k| { 4483| 1.25k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 47| 2.50k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 39| 1.22k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.22k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4483:13): [True: 1.22k, False: 28] | Branch (4483:70): [True: 1.17k, False: 52] ------------------ 4484| 1.17k| { 4485| 1.17k| if ((yyvsp[0].expression).value.integer == 0) ------------------ | Branch (4485:15): [True: 361, False: 809] ------------------ 4486| 361| { 4487| 361| yywarning(yyscanner, ------------------ | | 51| 361|#define yywarning yara_yywarning ------------------ 4488| 361| "consider using \"none\" keyword, it is less ambiguous."); 4489| 361| } 4490| | 4491| 1.17k| if ((yyvsp[0].expression).value.integer < 0) ------------------ | Branch (4491:15): [True: 0, False: 1.17k] ------------------ 4492| 0| { 4493| 0| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); ------------------ 4494| 0| "%" PRId64, (yyvsp[0].expression).value.integer); 4495| | 4496| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4497| 0| } 4498| 1.17k| } 4499| | 4500| 1.25k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 1.25k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (4500:13): [True: 0, False: 1.25k] ------------------ 4501| 0| { 4502| 0| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); ------------------ 4503| 0| "%a", (yyvsp[0].expression).value.double_); 4504| | 4505| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4506| 0| } 4507| | 4508| 1.25k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 1.25k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4508:13): [True: 8, False: 1.24k] ------------------ 4509| 8| { 4510| 8| SIZED_STRING* ss = yr_arena_ref_to_ptr(compiler->arena, 4511| 8| &(yyvsp[0].expression).value.sized_string_ref); 4512| | // If the expression is an external string variable we need to get 4513| | // it some other way. 4514| 8| if (ss != NULL) ------------------ | Branch (4514:15): [True: 8, False: 0] ------------------ 4515| 8| { 4516| 8| yr_compiler_set_error_extra_info_fmt(compiler, "%s", ss->c_string); ------------------ | | 304| 8| snprintf( \ | | 305| 8| compiler->last_error_extra_info, \ | | 306| 8| sizeof(compiler->last_error_extra_info), \ | | 307| 8| fmt, \ | | 308| 8| __VA_ARGS__); ------------------ 4517| 8| } 4518| 0| else 4519| 0| { 4520| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4521| 0| "string in for_expression is invalid"); 4522| 0| } 4523| | 4524| 8| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 8| { \ | | 121| 8| compiler->last_error = e; \ | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 8| default: \ | | ------------------ | | | Branch (127:7): [True: 8, False: 0] | | ------------------ | | 128| 8| YYERROR; \ | | ------------------ | | | | 1311| 8|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 8| } \ | | 130| 8| } ------------------ 4525| 0| } 4526| | 4527| 1.24k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_REGEXP) ------------------ | | 49| 1.24k|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (4527:13): [True: 0, False: 1.24k] ------------------ 4528| 0| { 4529| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4530| 0| "regexp in for_expression is invalid"); 4531| | 4532| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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; \ | | ------------------ | | | | 1310| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1311| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4533| 0| } 4534| | 4535| 1.24k| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4536| 1.24k| } 4537| 0|#line 4538 "libyara/grammar.c" 4538| 0| break; 4539| | 4540| 3.12k| case 138: /* for_expression: for_quantifier */ ------------------ | Branch (4540:3): [True: 3.12k, False: 366k] ------------------ 4541| 3.12k|#line 2439 "libyara/grammar.y" 4542| 3.12k| { 4543| 3.12k| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4544| 3.12k| } 4545| 3.12k|#line 4546 "libyara/grammar.c" 4546| 3.12k| break; 4547| | 4548| 1.36k| case 139: /* for_quantifier: "" */ ------------------ | Branch (4548:3): [True: 1.36k, False: 368k] ------------------ 4549| 1.36k|#line 2446 "libyara/grammar.y" 4550| 1.36k| { 4551| 1.36k| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 1.36k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4552| 1.36k| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 1.36k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4553| 1.36k| (yyval.expression).value.integer = FOR_EXPRESSION_ALL; ------------------ | | 108| 1.36k|#define FOR_EXPRESSION_ALL 1 ------------------ 4554| 1.36k| } 4555| 1.36k|#line 4556 "libyara/grammar.c" 4556| 1.36k| break; 4557| | 4558| 1.75k| case 140: /* for_quantifier: "" */ ------------------ | Branch (4558:3): [True: 1.75k, False: 367k] ------------------ 4559| 1.75k|#line 2452 "libyara/grammar.y" 4560| 1.75k| { 4561| 1.75k| yr_parser_emit_push_const(yyscanner, 1); 4562| 1.75k| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 1.75k|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4563| 1.75k| (yyval.expression).value.integer = FOR_EXPRESSION_ANY; ------------------ | | 109| 1.75k|#define FOR_EXPRESSION_ANY 2 ------------------ 4564| 1.75k| } 4565| 1.75k|#line 4566 "libyara/grammar.c" 4566| 1.75k| break; 4567| | 4568| 0| case 141: /* for_quantifier: "" */ ------------------ | Branch (4568:3): [True: 0, False: 369k] ------------------ 4569| 0|#line 2458 "libyara/grammar.y" 4570| 0| { 4571| 0| yr_parser_emit_push_const(yyscanner, 0); 4572| 0| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4573| 0| (yyval.expression).value.integer = FOR_EXPRESSION_NONE; ------------------ | | 110| 0|#define FOR_EXPRESSION_NONE 3 ------------------ 4574| 0| } 4575| 0|#line 4576 "libyara/grammar.c" 4576| 0| break; 4577| | 4578| 556| case 142: /* primary_expression: '(' primary_expression ')' */ ------------------ | Branch (4578:3): [True: 556, False: 369k] ------------------ 4579| 556|#line 2468 "libyara/grammar.y" 4580| 556| { 4581| 556| (yyval.expression) = (yyvsp[-1].expression); 4582| 556| } 4583| 556|#line 4584 "libyara/grammar.c" 4584| 556| break; 4585| | 4586| 247| case 143: /* primary_expression: "" */ ------------------ | Branch (4586:3): [True: 247, False: 369k] ------------------ 4587| 247|#line 2472 "libyara/grammar.y" 4588| 247| { 4589| 247| fail_if_error(yr_parser_emit( ------------------ | | 135| 247| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 494|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 247] | | ------------------ | | 136| 247| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4590| 247| yyscanner, OP_FILESIZE, NULL)); 4591| | 4592| 247| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 247|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4593| 247| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 247|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4594| 247| } 4595| 0|#line 4596 "libyara/grammar.c" 4596| 0| break; 4597| | 4598| 181| case 144: /* primary_expression: "" */ ------------------ | Branch (4598:3): [True: 181, False: 369k] ------------------ 4599| 181|#line 2480 "libyara/grammar.y" 4600| 181| { 4601| 181| yywarning(yyscanner, ------------------ | | 51| 181|#define yywarning yara_yywarning ------------------ 4602| 181| "using deprecated \"entrypoint\" keyword. Use the \"entry_point\" " 4603| 181| "function from PE module instead."); 4604| | 4605| 181| fail_if_error(yr_parser_emit( ------------------ | | 135| 181| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 362|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 181] | | ------------------ | | 136| 181| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4606| 181| yyscanner, OP_ENTRYPOINT, NULL)); 4607| | 4608| 181| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 181|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4609| 181| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 181|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4610| 181| } 4611| 0|#line 4612 "libyara/grammar.c" 4612| 0| break; 4613| | 4614| 210| case 145: /* primary_expression: "integer function" '(' primary_expression ')' */ ------------------ | Branch (4614:3): [True: 210, False: 369k] ------------------ 4615| 210|#line 2492 "libyara/grammar.y" 4616| 210| { 4617| 210| check_type((yyvsp[-1].expression), EXPRESSION_TYPE_INTEGER, "intXXXX or uintXXXX"); ------------------ | | 175| 210| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 210| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 48, False: 162] | | | | ------------------ | | | | 146| 210| { \ | | | | 147| 48| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 24, False: 24] | | | | ------------------ | | | | 148| 48| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 48] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 48] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 24| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 24|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 24, False: 24] | | | | ------------------ | | | | 158| 24| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 24| strlcpy( \ | | | | | | 299| 24| compiler->last_error_extra_info, \ | | | | | | 300| 24| info, \ | | | | | | 301| 24| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 24| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 24| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 48] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 48| } \ | | | | 166| 48| cleanup; \ | | | | 167| 48| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 48|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 48| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 48|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 48| YYERROR; \ | | | | ------------------ | | | | | | 1311| 48|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 48| } | | ------------------ ------------------ 4618| | 4619| | // _INTEGER_FUNCTION_ could be any of int8, int16, int32, uint8, 4620| | // uint32, etc. $1 contains an index that added to OP_READ_INT results 4621| | // in the proper OP_INTXX opcode. 4622| | 4623| 162| fail_if_error(yr_parser_emit( ------------------ | | 135| 162| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 324|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 162] | | ------------------ | | 136| 162| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4624| 162| yyscanner, (uint8_t) (OP_READ_INT + (yyvsp[-3].integer)), NULL)); 4625| | 4626| 162| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 162|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4627| 162| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 162|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4628| 162| } 4629| 0|#line 4630 "libyara/grammar.c" 4630| 0| break; 4631| | 4632| 19.7k| case 146: /* primary_expression: "integer number" */ ------------------ | Branch (4632:3): [True: 19.7k, False: 349k] ------------------ 4633| 19.7k|#line 2506 "libyara/grammar.y" 4634| 19.7k| { 4635| 19.7k| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].integer))); ------------------ | | 135| 19.7k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 39.5k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 19.7k] | | ------------------ | | 136| 19.7k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4636| | 4637| 19.7k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 19.7k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4638| 19.7k| (yyval.expression).value.integer = (yyvsp[0].integer); 4639| 19.7k| } 4640| 0|#line 4641 "libyara/grammar.c" 4641| 0| break; 4642| | 4643| 917| case 147: /* primary_expression: "floating point number" */ ------------------ | Branch (4643:3): [True: 917, False: 368k] ------------------ 4644| 917|#line 2513 "libyara/grammar.y" 4645| 917| { 4646| 917| fail_if_error(yr_parser_emit_with_arg_double( ------------------ | | 135| 917| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.83k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 917] | | ------------------ | | 136| 917| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4647| 917| yyscanner, OP_PUSH, (yyvsp[0].double_), NULL, NULL)); 4648| | 4649| 917| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 917|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4650| 917| } 4651| 0|#line 4652 "libyara/grammar.c" 4652| 0| break; 4653| | 4654| 2.77k| case 148: /* primary_expression: "text string" */ ------------------ | Branch (4654:3): [True: 2.77k, False: 366k] ------------------ 4655| 2.77k|#line 2520 "libyara/grammar.y" 4656| 2.77k| { 4657| 2.77k| YR_ARENA_REF ref; 4658| | 4659| 2.77k| int result = _yr_compiler_store_data( 4660| 2.77k| compiler, 4661| 2.77k| (yyvsp[0].sized_string), 4662| 2.77k| (yyvsp[0].sized_string)->length + sizeof(SIZED_STRING), 4663| 2.77k| &ref); 4664| | 4665| 2.77k| yr_free((yyvsp[0].sized_string)); 4666| | 4667| 2.77k| if (result == ERROR_SUCCESS) ------------------ | | 40| 2.77k|#define ERROR_SUCCESS 0 ------------------ | Branch (4667:13): [True: 2.77k, False: 0] ------------------ 4668| 2.77k| result = yr_parser_emit_with_arg_reloc( 4669| 2.77k| yyscanner, 4670| 2.77k| OP_PUSH, ------------------ | | 61| 2.77k|#define OP_PUSH 13 ------------------ 4671| 2.77k| yr_arena_ref_to_ptr(compiler->arena, &ref), 4672| 2.77k| NULL, 4673| 2.77k| NULL); 4674| | 4675| 2.77k| fail_if_error(result); ------------------ | | 135| 2.77k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 5.54k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.77k] | | ------------------ | | 136| 2.77k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4676| | 4677| 2.77k| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 2.77k|#define EXPRESSION_TYPE_STRING 4 ------------------ 4678| 2.77k| (yyval.expression).value.sized_string_ref = ref; 4679| 2.77k| } 4680| 0|#line 4681 "libyara/grammar.c" 4681| 0| break; 4682| | 4683| 32| case 149: /* primary_expression: "string count" "" range */ ------------------ | Branch (4683:3): [True: 32, False: 369k] ------------------ 4684| 32|#line 2545 "libyara/grammar.y" 4685| 32| { 4686| 32| int result = yr_parser_reduce_string_identifier( 4687| 32| yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 124| 32|#define OP_COUNT_IN 76 ------------------ yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 38| 32|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4688| | 4689| 32| yr_free((yyvsp[-2].c_string)); 4690| | 4691| 32| fail_if_error(result); ------------------ | | 135| 32| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 64|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 32] | | ------------------ | | 136| 32| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4692| | 4693| 32| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 32|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4694| 32| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 32|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4695| 32| } 4696| 0|#line 4697 "libyara/grammar.c" 4697| 0| break; 4698| | 4699| 1.39k| case 150: /* primary_expression: "string count" */ ------------------ | Branch (4699:3): [True: 1.39k, False: 368k] ------------------ 4700| 1.39k|#line 2557 "libyara/grammar.y" 4701| 1.39k| { 4702| 1.39k| int result = yr_parser_reduce_string_identifier( 4703| 1.39k| yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 68| 1.39k|#define OP_COUNT 20 ------------------ yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 38| 1.39k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4704| | 4705| 1.39k| yr_free((yyvsp[0].c_string)); 4706| | 4707| 1.39k| fail_if_error(result); ------------------ | | 135| 1.39k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.78k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 1.38k] | | ------------------ | | 136| 1.39k| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 4708| | 4709| 1.38k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.38k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4710| 1.38k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 1.38k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4711| 1.38k| } 4712| 0|#line 4713 "libyara/grammar.c" 4713| 0| break; 4714| | 4715| 237| case 151: /* primary_expression: "string offset" '[' primary_expression ']' */ ------------------ | Branch (4715:3): [True: 237, False: 369k] ------------------ 4716| 237|#line 2569 "libyara/grammar.y" 4717| 237| { 4718| 237| int result = yr_parser_reduce_string_identifier( 4719| 237| yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 237|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 237|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4720| | 4721| 237| yr_free((yyvsp[-3].c_string)); 4722| | 4723| 237| fail_if_error(result); ------------------ | | 135| 237| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 474|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 237] | | ------------------ | | 136| 237| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4724| | 4725| 237| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 237|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4726| 237| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 237|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4727| 237| } 4728| 0|#line 4729 "libyara/grammar.c" 4729| 0| break; 4730| | 4731| 1.68k| case 152: /* primary_expression: "string offset" */ ------------------ | Branch (4731:3): [True: 1.68k, False: 367k] ------------------ 4732| 1.68k|#line 2581 "libyara/grammar.y" 4733| 1.68k| { 4734| 1.68k| int result = yr_parser_emit_push_const(yyscanner, 1); 4735| | 4736| 1.68k| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.68k|#define ERROR_SUCCESS 0 ------------------ | Branch (4736:13): [True: 1.68k, False: 0] ------------------ 4737| 1.68k| result = yr_parser_reduce_string_identifier( 4738| 1.68k| yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 1.68k|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 1.68k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4739| | 4740| 1.68k| yr_free((yyvsp[0].c_string)); 4741| | 4742| 1.68k| fail_if_error(result); ------------------ | | 135| 1.68k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.37k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 41, False: 1.64k] | | ------------------ | | 136| 1.68k| { \ | | 137| 41| fail_with_error(e); \ | | ------------------ | | | | 120| 41| { \ | | | | 121| 41| compiler->last_error = e; \ | | | | 122| 41| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 41| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 41, False: 0] | | | | ------------------ | | | | 128| 41| YYERROR; \ | | | | ------------------ | | | | | | 1311| 41|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 41| } \ | | | | 130| 41| } | | ------------------ | | 138| 0| } ------------------ 4743| | 4744| 1.64k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.64k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4745| 1.64k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 1.64k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4746| 1.64k| } 4747| 0|#line 4748 "libyara/grammar.c" 4748| 0| break; 4749| | 4750| 178| case 153: /* primary_expression: "string length" '[' primary_expression ']' */ ------------------ | Branch (4750:3): [True: 178, False: 369k] ------------------ 4751| 178|#line 2596 "libyara/grammar.y" 4752| 178| { 4753| 178| int result = yr_parser_reduce_string_identifier( 4754| 178| yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 178|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 178|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4755| | 4756| 178| yr_free((yyvsp[-3].c_string)); 4757| | 4758| 178| fail_if_error(result); ------------------ | | 135| 178| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 356|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 178] | | ------------------ | | 136| 178| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4759| | 4760| 178| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 178|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4761| 178| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 178|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4762| 178| } 4763| 0|#line 4764 "libyara/grammar.c" 4764| 0| break; 4765| | 4766| 4.06k| case 154: /* primary_expression: "string length" */ ------------------ | Branch (4766:3): [True: 4.06k, False: 365k] ------------------ 4767| 4.06k|#line 2608 "libyara/grammar.y" 4768| 4.06k| { 4769| 4.06k| int result = yr_parser_emit_push_const(yyscanner, 1); 4770| | 4771| 4.06k| if (result == ERROR_SUCCESS) ------------------ | | 40| 4.06k|#define ERROR_SUCCESS 0 ------------------ | Branch (4771:13): [True: 4.06k, False: 0] ------------------ 4772| 4.06k| result = yr_parser_reduce_string_identifier( 4773| 4.06k| yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 4.06k|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 4.06k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4774| | 4775| 4.06k| yr_free((yyvsp[0].c_string)); 4776| | 4777| 4.06k| fail_if_error(result); ------------------ | | 135| 4.06k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.13k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 11, False: 4.05k] | | ------------------ | | 136| 4.06k| { \ | | 137| 11| fail_with_error(e); \ | | ------------------ | | | | 120| 11| { \ | | | | 121| 11| compiler->last_error = e; \ | | | | 122| 11| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 11| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 11, False: 0] | | | | ------------------ | | | | 128| 11| YYERROR; \ | | | | ------------------ | | | | | | 1311| 11|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 11| } \ | | | | 130| 11| } | | ------------------ | | 138| 0| } ------------------ 4778| | 4779| 4.05k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 4.05k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4780| 4.05k| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 4.05k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4781| 4.05k| } 4782| 0|#line 4783 "libyara/grammar.c" 4783| 0| break; 4784| | 4785| 8.70k| case 155: /* primary_expression: identifier */ ------------------ | Branch (4785:3): [True: 8.70k, False: 360k] ------------------ 4786| 8.70k|#line 2623 "libyara/grammar.y" 4787| 8.70k| { 4788| 8.70k| int result = ERROR_SUCCESS; ------------------ | | 40| 8.70k|#define ERROR_SUCCESS 0 ------------------ 4789| | 4790| 8.70k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 8.70k|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4790:13): [True: 4.82k, False: 3.87k] ------------------ 4791| 4.82k| { 4792| 4.82k| result = yr_parser_emit( 4793| 4.82k| yyscanner, OP_OBJ_VALUE, NULL); ------------------ | | 65| 4.82k|#define OP_OBJ_VALUE 17 ------------------ 4794| | 4795| 4.82k| switch((yyvsp[0].expression).value.object->type) 4796| 4.82k| { 4797| 62| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 62|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (4797:13): [True: 62, False: 4.76k] ------------------ 4798| 62| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 62|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4799| 62| (yyval.expression).value.integer = (yyvsp[0].expression).value.object->value.i; 4800| 62| break; 4801| 0| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (4801:13): [True: 0, False: 4.82k] ------------------ 4802| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4803| 0| break; 4804| 4.72k| case OBJECT_TYPE_STRING: ------------------ | | 59| 4.72k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (4804:13): [True: 4.72k, False: 102] ------------------ 4805| 4.72k| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 4.72k|#define EXPRESSION_TYPE_STRING 4 ------------------ 4806| 4.72k| (yyval.expression).value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 4.72k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 4807| 4.72k| break; 4808| 40| default: ------------------ | Branch (4808:13): [True: 40, False: 4.78k] ------------------ 4809| | // In a primary expression any identifier that corresponds to an 4810| | // object must be of type integer, float or string. If "foobar" is 4811| | // either a function, structure, dictionary or array you can not 4812| | // use it as: 4813| | // condition: foobar 4814| 40| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 40| snprintf( \ | | 305| 40| compiler->last_error_extra_info, \ | | 306| 40| sizeof(compiler->last_error_extra_info), \ | | 307| 40| fmt, \ | | 308| 80| __VA_ARGS__); | | ------------------ | | | Branch (308:7): [True: 24, False: 16] | | ------------------ ------------------ 4815| 40| compiler, 4816| 40| "wrong usage of identifier \"%s\"", 4817| 40| expression_identifier((yyvsp[0].expression))); 4818| | 4819| 40| result = ERROR_WRONG_TYPE; ------------------ | | 69| 40|#define ERROR_WRONG_TYPE 24 ------------------ 4820| 4.82k| } 4821| 4.82k| } 4822| 3.87k| else 4823| 3.87k| { 4824| 3.87k| (yyval.expression) = (yyvsp[0].expression); 4825| 3.87k| } 4826| | 4827| 8.70k| fail_if_error(result); ------------------ | | 135| 8.70k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 17.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 40, False: 8.66k] | | ------------------ | | 136| 8.70k| { \ | | 137| 40| fail_with_error(e); \ | | ------------------ | | | | 120| 40| { \ | | | | 121| 40| compiler->last_error = e; \ | | | | 122| 40| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 40| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 40, False: 0] | | | | ------------------ | | | | 128| 40| YYERROR; \ | | | | ------------------ | | | | | | 1311| 40|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 40| } \ | | | | 130| 40| } | | ------------------ | | 138| 0| } ------------------ 4828| 8.66k| } 4829| 0|#line 4830 "libyara/grammar.c" 4830| 0| break; 4831| | 4832| 3.39k| case 156: /* primary_expression: '-' primary_expression */ ------------------ | Branch (4832:3): [True: 3.39k, False: 366k] ------------------ 4833| 3.39k|#line 2666 "libyara/grammar.y" 4834| 3.39k| { 4835| 3.39k| int result = ERROR_SUCCESS; ------------------ | | 40| 3.39k|#define ERROR_SUCCESS 0 ------------------ 4836| | 4837| 3.39k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER | EXPRESSION_TYPE_FLOAT, "-"); ------------------ | | 175| 3.39k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 3.39k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 20, False: 3.37k] | | | | ------------------ | | | | 146| 3.39k| { \ | | | | 147| 20| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 12, False: 8] | | | | ------------------ | | | | 148| 20| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 20] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 20] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 12] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 20] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| 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); \ | | | | ------------------ | | | | | | 49| 20|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 20| YYERROR; \ | | | | ------------------ | | | | | | 1311| 20|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 20| } | | ------------------ ------------------ 4838| | 4839| 3.37k| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 3.37k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4839:13): [True: 3.31k, False: 62] ------------------ 4840| 3.31k| { 4841| 3.31k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 3.31k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4842| 3.31k| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 3.31k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (4842:46): [True: 843, False: 2.46k] ------------------ 4843| 2.46k| YR_UNDEFINED : -((yyvsp[0].expression).value.integer); ------------------ | | 38| 843|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4844| 3.31k| result = yr_parser_emit(yyscanner, OP_INT_MINUS, NULL); ------------------ | | 152| 3.31k|#define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 141| 3.31k|#define OP_INT_BEGIN 100 | | ------------------ | | #define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 3.31k|#define _OP_MINUS 10 | | ------------------ ------------------ 4845| 3.31k| } 4846| 62| else if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 62|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (4846:18): [True: 62, False: 0] ------------------ 4847| 62| { 4848| 62| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 62|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4849| 62| result = yr_parser_emit(yyscanner, OP_DBL_MINUS, NULL); ------------------ | | 166| 62|#define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 155| 62|#define OP_DBL_BEGIN 120 | | ------------------ | | #define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 62|#define _OP_MINUS 10 | | ------------------ ------------------ 4850| 62| } 4851| | 4852| 3.37k| fail_if_error(result); ------------------ | | 135| 3.37k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.74k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 3.37k] | | ------------------ | | 136| 3.37k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4853| 3.37k| } 4854| 0|#line 4855 "libyara/grammar.c" 4855| 0| break; 4856| | 4857| 2.07k| case 157: /* primary_expression: primary_expression '+' primary_expression */ ------------------ | Branch (4857:3): [True: 2.07k, False: 367k] ------------------ 4858| 2.07k|#line 2687 "libyara/grammar.y" 4859| 2.07k| { 4860| 2.07k| int result = yr_parser_reduce_operation( 4861| 2.07k| yyscanner, "+", (yyvsp[-2].expression), (yyvsp[0].expression)); 4862| | 4863| 2.07k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 4.15k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4863:13): [True: 1.60k, False: 475] ------------------ 4864| 2.07k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 1.60k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4864:13): [True: 1.47k, False: 132] ------------------ 4865| 1.47k| { 4866| 1.47k| int64_t i1 = (yyvsp[-2].expression).value.integer; 4867| 1.47k| int64_t i2 = (yyvsp[0].expression).value.integer; 4868| | 4869| 1.47k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 2.94k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.47k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 2.80k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.32k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4869:15): [True: 1.32k, False: 143] | Branch (4869:36): [True: 895, False: 434] ------------------ 4870| 1.47k| ( 4871| 895| (i2 > 0 && i1 > INT64_MAX - i2) || ------------------ | Branch (4871:18): [True: 422, False: 473] | Branch (4871:28): [True: 0, False: 422] ------------------ 4872| 895| (i2 < 0 && i1 < INT64_MIN - i2) ------------------ | Branch (4872:18): [True: 152, False: 743] | Branch (4872:28): [True: 0, False: 152] ------------------ 4873| 895| )) 4874| 0| { 4875| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); ------------------ 4876| 0| compiler, "%" PRId64 " + %" PRId64, i1, i2); 4877| | 4878| 0| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 97| 0|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 4879| 0| } 4880| 1.47k| else 4881| 1.47k| { 4882| 1.47k| (yyval.expression).value.integer = OPERATION(+, i1, i2); ------------------ | | 197| 1.47k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 2.94k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.47k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 143, False: 1.32k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.32k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.32k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 434, False: 895] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 577|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 4883| 1.47k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.47k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4884| 1.47k| } 4885| 1.47k| } 4886| 607| else 4887| 607| { 4888| 607| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 607|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4889| 607| } 4890| | 4891| 2.07k| fail_if_error(result); ------------------ | | 135| 2.07k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.15k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.07k] | | ------------------ | | 136| 2.07k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4892| 2.07k| } 4893| 0|#line 4894 "libyara/grammar.c" 4894| 0| break; 4895| | 4896| 4.27k| case 158: /* primary_expression: primary_expression '-' primary_expression */ ------------------ | Branch (4896:3): [True: 4.27k, False: 365k] ------------------ 4897| 4.27k|#line 2722 "libyara/grammar.y" 4898| 4.27k| { 4899| 4.27k| int result = yr_parser_reduce_operation( 4900| 4.27k| yyscanner, "-", (yyvsp[-2].expression), (yyvsp[0].expression)); 4901| | 4902| 4.27k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 8.55k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4902:13): [True: 4.07k, False: 205] ------------------ 4903| 4.27k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 4.07k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4903:13): [True: 3.86k, False: 206] ------------------ 4904| 3.86k| { 4905| 3.86k| int64_t i1 = (yyvsp[-2].expression).value.integer; 4906| 3.86k| int64_t i2 = (yyvsp[0].expression).value.integer; 4907| | 4908| 3.86k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 7.73k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 3.86k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 5.29k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.42k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4908:15): [True: 1.42k, False: 2.43k] | Branch (4908:36): [True: 1.03k, False: 390] ------------------ 4909| 3.86k| ( 4910| 1.03k| (i2 < 0 && i1 > INT64_MAX + i2) || ------------------ | Branch (4910:18): [True: 160, False: 879] | Branch (4910:28): [True: 0, False: 160] ------------------ 4911| 1.03k| (i2 > 0 && i1 < INT64_MIN + i2) ------------------ | Branch (4911:18): [True: 813, False: 226] | Branch (4911:28): [True: 2, False: 811] ------------------ 4912| 1.03k| )) 4913| 2| { 4914| 2| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 2| snprintf( \ | | 305| 2| compiler->last_error_extra_info, \ | | 306| 2| sizeof(compiler->last_error_extra_info), \ | | 307| 2| fmt, \ | | 308| 2| __VA_ARGS__); ------------------ 4915| 2| compiler, "%" PRId64 " - %" PRId64, i1, i2); 4916| | 4917| 2| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 97| 2|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 4918| 2| } 4919| 3.86k| else 4920| 3.86k| { 4921| 3.86k| (yyval.expression).value.integer = OPERATION(-, i1, i2); ------------------ | | 197| 3.86k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 7.72k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 3.86k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 2.43k, False: 1.42k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.42k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.42k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 390, False: 1.03k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 2.82k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 4922| 3.86k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 3.86k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4923| 3.86k| } 4924| 3.86k| } 4925| 411| else 4926| 411| { 4927| 411| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 411|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4928| 411| } 4929| | 4930| 4.27k| fail_if_error(result); ------------------ | | 135| 4.27k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.55k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 2, False: 4.27k] | | ------------------ | | 136| 4.27k| { \ | | 137| 2| fail_with_error(e); \ | | ------------------ | | | | 120| 2| { \ | | | | 121| 2| compiler->last_error = e; \ | | | | 122| 2| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 2| switch (e) \ | | | | 124| 2| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 2] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 2| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 2, False: 0] | | | | ------------------ | | | | 128| 2| YYERROR; \ | | | | ------------------ | | | | | | 1311| 2|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 2| } \ | | | | 130| 2| } | | ------------------ | | 138| 0| } ------------------ 4931| 4.27k| } 4932| 0|#line 4933 "libyara/grammar.c" 4933| 0| break; 4934| | 4935| 1.62k| case 159: /* primary_expression: primary_expression '*' primary_expression */ ------------------ | Branch (4935:3): [True: 1.62k, False: 368k] ------------------ 4936| 1.62k|#line 2757 "libyara/grammar.y" 4937| 1.62k| { 4938| 1.62k| int result = yr_parser_reduce_operation( 4939| 1.62k| yyscanner, "*", (yyvsp[-2].expression), (yyvsp[0].expression)); 4940| | 4941| 1.62k| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 3.25k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4941:13): [True: 1.48k, False: 142] ------------------ 4942| 1.62k| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 1.48k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4942:13): [True: 1.18k, False: 300] ------------------ 4943| 1.18k| { 4944| 1.18k| int64_t i1 = (yyvsp[-2].expression).value.integer; 4945| 1.18k| int64_t i2 = (yyvsp[0].expression).value.integer; 4946| | 4947| 1.18k| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 2.37k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.18k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 2.19k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.01k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4947:15): [True: 1.01k, False: 173] | Branch (4947:36): [True: 720, False: 292] ------------------ 4948| 1.18k| ( 4949| 720| i2 != 0 && llabs(i1) > INT64_MAX / llabs(i2) ------------------ | Branch (4949:17): [True: 395, False: 325] | Branch (4949:28): [True: 0, False: 395] ------------------ 4950| 720| )) 4951| 0| { 4952| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 0| snprintf( \ | | 305| 0| compiler->last_error_extra_info, \ | | 306| 0| sizeof(compiler->last_error_extra_info), \ | | 307| 0| fmt, \ | | 308| 0| __VA_ARGS__); ------------------ 4953| 0| compiler, "%" PRId64 " * %" PRId64, i1, i2); 4954| | 4955| 0| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 97| 0|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 4956| 0| } 4957| 1.18k| else 4958| 1.18k| { 4959| 1.18k| (yyval.expression).value.integer = OPERATION(*, i1, i2); ------------------ | | 197| 1.18k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 2.37k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.18k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 173, False: 1.01k] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.01k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.01k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 292, False: 720] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 465|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 4960| 1.18k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.18k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4961| 1.18k| } 4962| 1.18k| } 4963| 442| else 4964| 442| { 4965| 442| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 442|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4966| 442| } 4967| | 4968| 1.62k| fail_if_error(result); ------------------ | | 135| 1.62k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.25k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 8, False: 1.61k] | | ------------------ | | 136| 1.62k| { \ | | 137| 8| fail_with_error(e); \ | | ------------------ | | | | 120| 8| { \ | | | | 121| 8| compiler->last_error = e; \ | | | | 122| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 8| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 8, False: 0] | | | | ------------------ | | | | 128| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 8| } \ | | | | 130| 8| } | | ------------------ | | 138| 0| } ------------------ 4969| 1.61k| } 4970| 0|#line 4971 "libyara/grammar.c" 4971| 0| break; 4972| | 4973| 938| case 160: /* primary_expression: primary_expression '\\' primary_expression */ ------------------ | Branch (4973:3): [True: 938, False: 368k] ------------------ 4974| 938|#line 2791 "libyara/grammar.y" 4975| 938| { 4976| 938| int result = yr_parser_reduce_operation( 4977| 938| yyscanner, "\\", (yyvsp[-2].expression), (yyvsp[0].expression)); 4978| | 4979| 938| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 1.87k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4979:13): [True: 809, False: 129] ------------------ 4980| 938| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 809|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4980:13): [True: 649, False: 160] ------------------ 4981| 649| { 4982| 649| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (4982:15): [True: 649, False: 0] ------------------ 4983| 649| { 4984| 649| (yyval.expression).value.integer = OPERATION(/, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 649| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.29k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 649|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 405, False: 244] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 244|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 244|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 64, False: 180] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 469|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 4985| 649| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 649|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4986| 649| } 4987| 0| else 4988| 0| { 4989| 0| result = ERROR_DIVISION_BY_ZERO; ------------------ | | 89| 0|#define ERROR_DIVISION_BY_ZERO 44 ------------------ 4990| 0| } 4991| 649| } 4992| 289| else 4993| 289| { 4994| 289| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 289|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4995| 289| } 4996| | 4997| 938| fail_if_error(result); ------------------ | | 135| 938| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.87k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 938] | | ------------------ | | 136| 938| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4998| 938| } 4999| 0|#line 5000 "libyara/grammar.c" 5000| 0| break; 5001| | 5002| 674| case 161: /* primary_expression: primary_expression '%' primary_expression */ ------------------ | Branch (5002:3): [True: 674, False: 368k] ------------------ 5003| 674|#line 2816 "libyara/grammar.y" 5004| 674| { 5005| 674| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 674| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 674| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 16, False: 658] | | | | ------------------ | | | | 146| 674| { \ | | | | 147| 16| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 8] | | | | ------------------ | | | | 148| 16| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 16] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 16| } \ | | | | 166| 16| cleanup; \ | | | | 167| 16| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 16|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 16| YYERROR; \ | | | | ------------------ | | | | | | 1311| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 16| } | | ------------------ ------------------ 5006| 658| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 175| 658| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 658| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 26, False: 632] | | | | ------------------ | | | | 146| 658| { \ | | | | 147| 26| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 10, False: 16] | | | | ------------------ | | | | 148| 26| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 26] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 26] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 18] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 8| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 8| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 18] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 26| } \ | | | | 166| 26| cleanup; \ | | | | 167| 26| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 26|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 26| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 26|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 26| YYERROR; \ | | | | ------------------ | | | | | | 1311| 26|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 26| } | | ------------------ ------------------ 5007| | 5008| 632| fail_if_error(yr_parser_emit(yyscanner, OP_MOD, NULL)); ------------------ | | 135| 632| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.26k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 632] | | ------------------ | | 136| 632| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5009| | 5010| 632| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (5010:13): [True: 632, False: 0] ------------------ 5011| 632| { 5012| 632| (yyval.expression).value.integer = OPERATION(%, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 632| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.26k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 632|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 146, 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: 328, False: 158] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 474|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5013| 632| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 632|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5014| 632| } 5015| 0| else 5016| 0| { 5017| 0| fail_if_error(ERROR_DIVISION_BY_ZERO); ------------------ | | 135| 0| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [Folded - Ignored] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5018| 0| } 5019| 632| } 5020| 632|#line 5021 "libyara/grammar.c" 5021| 632| break; 5022| | 5023| 1.61k| case 162: /* primary_expression: primary_expression '^' primary_expression */ ------------------ | Branch (5023:3): [True: 1.61k, False: 368k] ------------------ 5024| 1.61k|#line 2833 "libyara/grammar.y" 5025| 1.61k| { 5026| 1.61k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 1.61k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.61k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 48, False: 1.56k] | | | | ------------------ | | | | 146| 1.61k| { \ | | | | 147| 48| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 24, False: 24] | | | | ------------------ | | | | 148| 48| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 48] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 48] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 24| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 24|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 24, False: 24] | | | | ------------------ | | | | 158| 24| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 24| strlcpy( \ | | | | | | 299| 24| compiler->last_error_extra_info, \ | | | | | | 300| 24| info, \ | | | | | | 301| 24| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 24| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 24| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 48] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 48| } \ | | | | 166| 48| cleanup; \ | | | | 167| 48| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 48|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 48| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 48|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 48| YYERROR; \ | | | | ------------------ | | | | | | 1311| 48|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 48| } | | ------------------ ------------------ 5027| 1.56k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 1.56k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.56k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 1.56k] | | | | ------------------ | | | | 146| 1.56k| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5028| | 5029| 1.56k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_XOR, NULL)); ------------------ | | 135| 1.56k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.12k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.56k] | | ------------------ | | 136| 1.56k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5030| | 5031| 1.56k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.56k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5032| 1.56k| (yyval.expression).value.integer = OPERATION(^, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.56k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 3.12k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.56k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 1.17k, False: 384] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 384|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 384|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 241, False: 143] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.41k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5033| 1.56k| } 5034| 0|#line 5035 "libyara/grammar.c" 5035| 0| break; 5036| | 5037| 2.06k| case 163: /* primary_expression: primary_expression '&' primary_expression */ ------------------ | Branch (5037:3): [True: 2.06k, False: 367k] ------------------ 5038| 2.06k|#line 2843 "libyara/grammar.y" 5039| 2.06k| { 5040| 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: 16, False: 2.05k] | | | | ------------------ | | | | 146| 2.06k| { \ | | | | 147| 16| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 8] | | | | ------------------ | | | | 148| 16| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 16] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 16| } \ | | | | 166| 16| cleanup; \ | | | | 167| 16| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 16|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 16| YYERROR; \ | | | | ------------------ | | | | | | 1311| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 16| } | | ------------------ ------------------ 5041| 2.05k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 175| 2.05k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 2.05k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 2.05k] | | | | ------------------ | | | | 146| 2.05k| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5042| | 5043| 2.05k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_AND, NULL)); ------------------ | | 135| 2.05k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.10k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 2.05k] | | ------------------ | | 136| 2.05k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5044| | 5045| 2.05k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 2.05k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5046| 2.05k| (yyval.expression).value.integer = OPERATION(&, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 2.05k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 4.10k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 2.05k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 1.46k, False: 589] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 589|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 589|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 340, False: 249] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 1.80k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5047| 2.05k| } 5048| 0|#line 5049 "libyara/grammar.c" 5049| 0| break; 5050| | 5051| 3.31k| case 164: /* primary_expression: primary_expression '|' primary_expression */ ------------------ | Branch (5051:3): [True: 3.31k, False: 366k] ------------------ 5052| 3.31k|#line 2853 "libyara/grammar.y" 5053| 3.31k| { 5054| 3.31k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 175| 3.31k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 3.31k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 56, False: 3.25k] | | | | ------------------ | | | | 146| 3.31k| { \ | | | | 147| 56| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 24, False: 32] | | | | ------------------ | | | | 148| 56| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 56] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 56] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 24| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 24|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 24, False: 32] | | | | ------------------ | | | | 158| 24| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 24| strlcpy( \ | | | | | | 299| 24| compiler->last_error_extra_info, \ | | | | | | 300| 24| info, \ | | | | | | 301| 24| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 24| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 24| break; \ | | | | 161| 8| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 8|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 8, False: 48] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| break; \ | | | | 165| 56| } \ | | | | 166| 56| cleanup; \ | | | | 167| 56| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 56|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 56| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 56|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 56| YYERROR; \ | | | | ------------------ | | | | | | 1311| 56|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 56| } | | ------------------ ------------------ 5055| 3.25k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 175| 3.25k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 3.25k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 16, False: 3.23k] | | | | ------------------ | | | | 146| 3.25k| { \ | | | | 147| 16| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 8, False: 8] | | | | ------------------ | | | | 148| 16| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 16] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 16| } \ | | | | 166| 16| cleanup; \ | | | | 167| 16| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 16|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 16| YYERROR; \ | | | | ------------------ | | | | | | 1311| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 16| } | | ------------------ ------------------ 5056| | 5057| 3.23k| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_OR, NULL)); ------------------ | | 135| 3.23k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.47k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 3.23k] | | ------------------ | | 136| 3.23k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5058| | 5059| 3.23k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 3.23k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5060| 3.23k| (yyval.expression).value.integer = OPERATION(|, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 3.23k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 6.47k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 3.23k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 2.68k, False: 551] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 551|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 551|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 246, False: 305] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 2.93k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5061| 3.23k| } 5062| 0|#line 5063 "libyara/grammar.c" 5063| 0| break; 5064| | 5065| 253| case 165: /* primary_expression: '~' primary_expression */ ------------------ | Branch (5065:3): [True: 253, False: 369k] ------------------ 5066| 253|#line 2863 "libyara/grammar.y" 5067| 253| { 5068| 253| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "~"); ------------------ | | 175| 253| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 253| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 28, False: 225] | | | | ------------------ | | | | 146| 253| { \ | | | | 147| 28| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 20, False: 8] | | | | ------------------ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 28] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 28] | | | | ------------------ | | | | 158| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 20] | | | | ------------------ | | | | 162| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 8| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 8| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 8| 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); \ | | | | ------------------ | | | | | | 49| 28|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 28| YYERROR; \ | | | | ------------------ | | | | | | 1311| 28|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 28| } | | ------------------ ------------------ 5069| | 5070| 225| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_NOT, NULL)); ------------------ | | 135| 225| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 450|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 225] | | ------------------ | | 136| 225| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5071| | 5072| 225| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 225|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5073| 225| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 225|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (5073:44): [True: 206, False: 19] ------------------ 5074| 206| YR_UNDEFINED : ~((yyvsp[0].expression).value.integer); ------------------ | | 38| 206|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 5075| 225| } 5076| 0|#line 5077 "libyara/grammar.c" 5077| 0| break; 5078| | 5079| 1.15k| case 166: /* primary_expression: primary_expression "<<" primary_expression */ ------------------ | Branch (5079:3): [True: 1.15k, False: 368k] ------------------ 5080| 1.15k|#line 2873 "libyara/grammar.y" 5081| 1.15k| { 5082| 1.15k| int result; 5083| | 5084| 1.15k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 175| 1.15k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.15k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 16, False: 1.14k] | | | | ------------------ | | | | 146| 1.15k| { \ | | | | 147| 16| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 16] | | | | ------------------ | | | | 148| 16| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 16] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 16] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 155| 0| compiler, "wrong type \"float\" for " op " operator"); \ | | | | 156| 0| break; \ | | | | 157| 16| case EXPRESSION_TYPE_STRING: \ | | | | ------------------ | | | | | | 48| 16|#define EXPRESSION_TYPE_STRING 4 | | | | ------------------ | | | | | Branch (157:9): [True: 16, False: 0] | | | | ------------------ | | | | 158| 16| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 16| strlcpy( \ | | | | | | 299| 16| compiler->last_error_extra_info, \ | | | | | | 300| 16| info, \ | | | | | | 301| 16| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 159| 16| compiler, "wrong type \"string\" for " op " operator"); \ | | | | 160| 16| break; \ | | | | 161| 0| case EXPRESSION_TYPE_BOOLEAN: \ | | | | ------------------ | | | | | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 | | | | ------------------ | | | | | Branch (161:9): [True: 0, False: 16] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 16| } \ | | | | 166| 16| cleanup; \ | | | | 167| 16| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 16|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 16| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 16|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 16| YYERROR; \ | | | | ------------------ | | | | | | 1311| 16|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 16| } | | ------------------ ------------------ 5085| 1.14k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 175| 1.14k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.14k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 8, False: 1.13k] | | | | ------------------ | | | | 146| 1.14k| { \ | | | | 147| 8| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 0, False: 8] | | | | ------------------ | | | | 148| 8| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 8] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 154| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 0] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 8] | | | | ------------------ | | | | 162| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 8| } \ | | | | 166| 8| cleanup; \ | | | | 167| 8| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 8|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 8| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 8|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 8| YYERROR; \ | | | | ------------------ | | | | | | 1311| 8|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 8| } | | ------------------ ------------------ 5086| | 5087| 1.13k| result = yr_parser_emit(yyscanner, OP_SHL, NULL); ------------------ | | 56| 1.13k|#define OP_SHL 8 ------------------ 5088| | 5089| 1.13k| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 2.26k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.13k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5089:13): [True: 305, False: 827] | Branch (5089:67): [True: 0, False: 305] ------------------ 5090| 0| result = ERROR_INVALID_OPERAND; ------------------ | | 99| 0|#define ERROR_INVALID_OPERAND 54 ------------------ 5091| 1.13k| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 2.26k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.13k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5091:18): [True: 305, False: 827] | Branch (5091:72): [True: 160, False: 145] ------------------ 5092| 160| (yyval.expression).value.integer = 0; 5093| 972| else 5094| 972| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 972| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 1.94k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 972|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 521, False: 451] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 451|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 451|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 318, False: 133] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 839|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5095| | 5096| 1.13k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.13k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5097| | 5098| 1.13k| fail_if_error(result); ------------------ | | 135| 1.13k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.26k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 0, False: 1.13k] | | ------------------ | | 136| 1.13k| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5099| 1.13k| } 5100| 0|#line 5101 "libyara/grammar.c" 5101| 0| break; 5102| | 5103| 1.42k| case 167: /* primary_expression: primary_expression ">>" primary_expression */ ------------------ | Branch (5103:3): [True: 1.42k, False: 368k] ------------------ 5104| 1.42k|#line 2893 "libyara/grammar.y" 5105| 1.42k| { 5106| 1.42k| int result; 5107| | 5108| 1.42k| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 175| 1.42k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.42k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 0, False: 1.42k] | | | | ------------------ | | | | 146| 1.42k| { \ | | | | 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1311| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5109| 1.42k| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 175| 1.42k| check_type_with_cleanup(expression, expected_type, op, ) | | ------------------ | | | | 145| 1.42k| if (((expression.type) & (expected_type)) == 0) \ | | | | ------------------ | | | | | Branch (145:9): [True: 23, False: 1.40k] | | | | ------------------ | | | | 146| 1.42k| { \ | | | | 147| 23| switch(expression.type) \ | | | | ------------------ | | | | | Branch (147:14): [True: 3, False: 20] | | | | ------------------ | | | | 148| 23| { \ | | | | 149| 0| case EXPRESSION_TYPE_INTEGER: \ | | | | ------------------ | | | | | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 | | | | ------------------ | | | | | Branch (149:9): [True: 0, False: 23] | | | | ------------------ | | | | 150| 0| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 0| strlcpy( \ | | | | | | 299| 0| compiler->last_error_extra_info, \ | | | | | | 300| 0| info, \ | | | | | | 301| 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: 15] | | | | ------------------ | | | | 154| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 15] | | | | ------------------ | | | | 158| 8| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 8| strlcpy( \ | | | | | | 299| 8| compiler->last_error_extra_info, \ | | | | | | 300| 8| info, \ | | | | | | 301| 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: 19] | | | | ------------------ | | | | 162| 4| yr_compiler_set_error_extra_info( \ | | | | ------------------ | | | | | | 298| 4| strlcpy( \ | | | | | | 299| 4| compiler->last_error_extra_info, \ | | | | | | 300| 4| info, \ | | | | | | 301| 4| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 4| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 4| 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); \ | | | | ------------------ | | | | | | 49| 23|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 23| YYERROR; \ | | | | ------------------ | | | | | | 1311| 23|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 23| } | | ------------------ ------------------ 5110| | 5111| 1.40k| result = yr_parser_emit(yyscanner, OP_SHR, NULL); ------------------ | | 57| 1.40k|#define OP_SHR 9 ------------------ 5112| | 5113| 1.40k| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 2.80k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.40k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5113:13): [True: 552, False: 851] | Branch (5113:67): [True: 1, False: 551] ------------------ 5114| 1| result = ERROR_INVALID_OPERAND; ------------------ | | 99| 1|#define ERROR_INVALID_OPERAND 54 ------------------ 5115| 1.40k| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 2.80k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 1.40k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5115:18): [True: 551, False: 851] | Branch (5115:72): [True: 204, False: 347] ------------------ 5116| 204| (yyval.expression).value.integer = 0; 5117| 1.19k| else 5118| 1.19k| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 1.19k| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 2.39k|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 1.19k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 569, False: 629] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 629|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 629|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 298, False: 331] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 867|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5119| | 5120| 1.40k| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 1.40k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5121| | 5122| 1.40k| fail_if_error(result); ------------------ | | 135| 1.40k| if (e != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (135:9): [True: 1, False: 1.40k] | | ------------------ | | 136| 1.40k| { \ | | 137| 1| fail_with_error(e); \ | | ------------------ | | | | 120| 1| { \ | | | | 121| 1| compiler->last_error = e; \ | | | | 122| 1| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 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; \ | | | | ------------------ | | | | | | 1310| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 1| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 1, False: 0] | | | | ------------------ | | | | 128| 1| YYERROR; \ | | | | ------------------ | | | | | | 1311| 1|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 1| } \ | | | | 130| 1| } | | ------------------ | | 138| 0| } ------------------ 5123| 1.40k| } 5124| 0|#line 5125 "libyara/grammar.c" 5125| 0| break; 5126| | 5127| 756| case 168: /* primary_expression: regexp */ ------------------ | Branch (5127:3): [True: 756, False: 368k] ------------------ 5128| 756|#line 2913 "libyara/grammar.y" 5129| 756| { 5130| 756| (yyval.expression) = (yyvsp[0].expression); 5131| 756| } 5132| 756|#line 5133 "libyara/grammar.c" 5133| 756| break; 5134| | 5135| | 5136| 0|#line 5137 "libyara/grammar.c" 5137| | 5138| 2.66k| default: break; ------------------ | Branch (5138:7): [True: 2.66k, False: 367k] ------------------ 5139| 369k| } 5140| | /* User semantic actions sometimes alter yychar, and that requires 5141| | that yytoken be updated with the new translation. We take the 5142| | approach of translating immediately before every use of yytoken. 5143| | One alternative is translating here after every semantic action, 5144| | but that translation would be missed if the semantic action invokes 5145| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5146| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5147| | incorrect destructor might then be invoked immediately. In the 5148| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5149| | to an incorrect destructor call or verbose syntax error message 5150| | before the lookahead is translated. */ 5151| 356k| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 5152| | 5153| 356k| YYPOPSTACK (yylen); ------------------ | | 1929| 356k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5154| 356k| yylen = 0; 5155| | 5156| 356k| *++yyvsp = yyval; 5157| | 5158| | /* Now 'shift' the result of the reduction. Determine what state 5159| | that goes to, based on the state we popped back to and the rule 5160| | number reduced by. */ 5161| 356k| { 5162| 356k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 884| 356k|#define YYNTOKENS 84 ------------------ 5163| 356k| const int yyi = yypgoto[yylhs] + *yyssp; 5164| 356k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 881| 494k|#define YYLAST 476 ------------------ | Branch (5164:16): [True: 137k, False: 218k] | Branch (5164:28): [True: 137k, False: 14] | Branch (5164:45): [True: 92.4k, False: 45.3k] ------------------ 5165| 356k| ? yytable[yyi] 5166| 356k| : yydefgoto[yylhs]); 5167| 356k| } 5168| | 5169| 356k| goto yynewstate; 5170| | 5171| | 5172| |/*--------------------------------------. 5173| || yyerrlab -- here on detecting error. | 5174| |`--------------------------------------*/ 5175| 63.7k|yyerrlab: 5176| | /* Make sure we have latest lookahead translation. See comments at 5177| | user semantic actions for why this is necessary. */ 5178| 63.7k| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 52| 63.7k|#define yychar yara_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 312| 63.7k|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 899| 127k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 63.7k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 63.7k, False: 0] | | | Branch (899:18): [True: 63.7k, False: 0] | | ------------------ | | 900| 127k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 63.7k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 127k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (5178:13): [True: 0, False: 63.7k] ------------------ 5179| | /* If not already recovering from an error, report this error. */ 5180| 63.7k| if (!yyerrstatus) ------------------ | Branch (5180:7): [True: 4.16k, False: 59.5k] ------------------ 5181| 4.16k| { 5182| 4.16k| ++yynerrs; ------------------ | | 54| 4.16k|#define yynerrs yara_yynerrs ------------------ 5183| 4.16k| { 5184| 4.16k| yypcontext_t yyctx 5185| 4.16k| = {yyssp, yytoken}; 5186| 4.16k| char const *yymsgp = YY_("syntax error"); ------------------ | | 683| 4.16k|# define YY_(Msgid) Msgid ------------------ 5187| 4.16k| int yysyntax_error_status; 5188| 4.16k| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5189| 4.16k| if (yysyntax_error_status == 0) ------------------ | Branch (5189:13): [True: 4.16k, False: 0] ------------------ 5190| 4.16k| yymsgp = yymsg; 5191| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (5191:18): [True: 0, False: 0] ------------------ 5192| 0| { 5193| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5193:17): [True: 0, False: 0] ------------------ 5194| 0| YYSTACK_FREE (yymsg); ------------------ | | 791| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5195| 0| yymsg = YY_CAST (char *, ------------------ | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 5196| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 5197| 0| if (yymsg) ------------------ | Branch (5197:17): [True: 0, False: 0] ------------------ 5198| 0| { 5199| 0| yysyntax_error_status 5200| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5201| 0| yymsgp = yymsg; 5202| 0| } 5203| 0| else 5204| 0| { 5205| 0| yymsg = yymsgbuf; 5206| 0| yymsg_alloc = sizeof yymsgbuf; 5207| 0| yysyntax_error_status = YYENOMEM; 5208| 0| } 5209| 0| } 5210| 4.16k| yyerror (yyscanner, compiler, yymsgp); ------------------ | | 49| 4.16k|#define yyerror yara_yyerror ------------------ 5211| 4.16k| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (5211:13): [True: 0, False: 4.16k] ------------------ 5212| 0| YYNOMEM; ------------------ | | 1312| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 5213| 4.16k| } 5214| 4.16k| } 5215| | 5216| 63.7k| if (yyerrstatus == 3) ------------------ | Branch (5216:7): [True: 57.1k, False: 6.61k] ------------------ 5217| 57.1k| { 5218| | /* If just tried and failed to reuse lookahead token after an 5219| | error, discard it. */ 5220| | 5221| 57.1k| if (yychar <= _END_OF_FILE_) ------------------ | | 52| 57.1k|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 57.1k|#define _END_OF_FILE_ 0 ------------------ | Branch (5221:11): [True: 1.11k, False: 56.0k] ------------------ 5222| 1.11k| { 5223| | /* Return failure if at end of input. */ 5224| 1.11k| if (yychar == _END_OF_FILE_) ------------------ | | 52| 1.11k|#define yychar yara_yychar ------------------ if (yychar == _END_OF_FILE_) ------------------ | | 313| 1.11k|#define _END_OF_FILE_ 0 ------------------ | Branch (5224:15): [True: 1.11k, False: 0] ------------------ 5225| 1.11k| YYABORT; ------------------ | | 1310| 1.11k|#define YYABORT goto yyabortlab ------------------ 5226| 1.11k| } 5227| 56.0k| else 5228| 56.0k| { 5229| 56.0k| yydestruct ("Error: discarding", 5230| 56.0k| yytoken, &yylval, yyscanner, compiler); 5231| 56.0k| yychar = YYEMPTY; ------------------ | | 52| 56.0k|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 56.0k|#define YYEMPTY -2 ------------------ 5232| 56.0k| } 5233| 57.1k| } 5234| | 5235| | /* Else will try to reuse lookahead token after shifting the error 5236| | token. */ 5237| 62.6k| goto yyerrlab1; 5238| | 5239| | 5240| |/*---------------------------------------------------. 5241| || yyerrorlab -- error raised explicitly by YYERROR. | 5242| |`---------------------------------------------------*/ 5243| 62.6k|yyerrorlab: 5244| | /* Pacify compilers when the user code never invokes YYERROR and the 5245| | label yyerrorlab therefore never appears in user code. */ 5246| 13.3k| if (0) ------------------ | Branch (5246:7): [Folded - Ignored] ------------------ 5247| 0| YYERROR; ------------------ | | 1311| 0|#define YYERROR goto yyerrorlab ------------------ 5248| 13.3k| ++yynerrs; ------------------ | | 54| 13.3k|#define yynerrs yara_yynerrs ------------------ 5249| | 5250| | /* Do not reclaim the symbols of the rule whose action triggered 5251| | this YYERROR. */ 5252| 13.3k| YYPOPSTACK (yylen); ------------------ | | 1929| 13.3k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5253| 13.3k| yylen = 0; 5254| 13.3k| YY_STACK_PRINT (yyss, yyssp); 5255| 13.3k| yystate = *yyssp; 5256| 13.3k| goto yyerrlab1; 5257| | 5258| | 5259| |/*-------------------------------------------------------------. 5260| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5261| |`-------------------------------------------------------------*/ 5262| 76.0k|yyerrlab1: 5263| 76.0k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5264| | 5265| | /* Pop stack until we find a state that shifts the error token. */ 5266| 76.0k| for (;;) 5267| 310k| { 5268| 310k| yyn = yypact[yystate]; 5269| 310k| if (!yypact_value_is_default (yyn)) ------------------ | | 1020| 310k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 310k|#define YYPACT_NINF (-172) | | ------------------ ------------------ | Branch (5269:11): [True: 296k, False: 14.2k] ------------------ 5270| 296k| { 5271| 296k| yyn += YYSYMBOL_YYerror; 5272| 296k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 881| 511k|#define YYLAST 476 ------------------ | Branch (5272:15): [True: 214k, False: 81.8k] | Branch (5272:27): [True: 214k, False: 0] | Branch (5272:44): [True: 76.0k, False: 138k] ------------------ 5273| 76.0k| { 5274| 76.0k| yyn = yytable[yyn]; 5275| 76.0k| if (0 < yyn) ------------------ | Branch (5275:19): [True: 76.0k, False: 0] ------------------ 5276| 76.0k| break; 5277| 76.0k| } 5278| 296k| } 5279| | 5280| | /* Pop the current state because it cannot handle the error token. */ 5281| 234k| if (yyssp == yyss) ------------------ | Branch (5281:11): [True: 0, False: 234k] ------------------ 5282| 0| YYABORT; ------------------ | | 1310| 0|#define YYABORT goto yyabortlab ------------------ 5283| | 5284| | 5285| 234k| yydestruct ("Error: popping", 5286| 234k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, compiler); ------------------ | | 966| 234k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 234k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5287| 234k| YYPOPSTACK (1); ------------------ | | 1929| 234k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5288| 234k| yystate = *yyssp; 5289| 234k| YY_STACK_PRINT (yyss, yyssp); 5290| 234k| } 5291| | 5292| 76.0k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5293| 76.0k| *++yyvsp = yylval; 5294| 76.0k| YY_IGNORE_MAYBE_UNINITIALIZED_END 5295| | 5296| | 5297| | /* Shift the error token. */ 5298| 76.0k| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 5299| | 5300| 76.0k| yystate = yyn; 5301| 76.0k| goto yynewstate; 5302| | 5303| | 5304| |/*-------------------------------------. 5305| || yyacceptlab -- YYACCEPT comes here. | 5306| |`-------------------------------------*/ 5307| 154|yyacceptlab: 5308| 154| yyresult = 0; 5309| 154| goto yyreturnlab; 5310| | 5311| | 5312| |/*-----------------------------------. 5313| || yyabortlab -- YYABORT comes here. | 5314| |`-----------------------------------*/ 5315| 1.11k|yyabortlab: 5316| 1.11k| yyresult = 1; 5317| 1.11k| goto yyreturnlab; 5318| | 5319| | 5320| |/*-----------------------------------------------------------. 5321| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 5322| |`-----------------------------------------------------------*/ 5323| 1|yyexhaustedlab: 5324| 1| yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 49| 1|#define yyerror yara_yyerror ------------------ yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 683| 1|# define YY_(Msgid) Msgid ------------------ 5325| 1| yyresult = 2; 5326| 1| goto yyreturnlab; 5327| | 5328| | 5329| |/*----------------------------------------------------------. 5330| || yyreturnlab -- parsing is finished, clean up and return. | 5331| |`----------------------------------------------------------*/ 5332| 1.27k|yyreturnlab: 5333| 1.27k| if (yychar != YYEMPTY) ------------------ | | 52| 1.27k|#define yychar yara_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 312| 1.27k|#define YYEMPTY -2 ------------------ | Branch (5333:7): [True: 1.11k, False: 155] ------------------ 5334| 1.11k| { 5335| | /* Make sure we have latest lookahead translation. See comments at 5336| | user semantic actions for why this is necessary. */ 5337| 1.11k| yytoken = YYTRANSLATE (yychar); ------------------ | | 899| 1.11k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 893| 1.11k|#define YYMAXUTOK 319 | | ------------------ | | | Branch (899:4): [True: 1.11k, False: 0] | | | Branch (899:18): [True: 1.11k, False: 0] | | ------------------ | | 900| 1.11k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 1.11k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 901| 1.11k| : YYSYMBOL_YYUNDEF) ------------------ 5338| 1.11k| yydestruct ("Cleanup: discarding lookahead", 5339| 1.11k| yytoken, &yylval, yyscanner, compiler); 5340| 1.11k| } 5341| | /* Do not reclaim the symbols of the rule whose action triggered 5342| | this YYABORT or YYACCEPT. */ 5343| 1.27k| YYPOPSTACK (yylen); ------------------ | | 1929| 1.27k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5344| 1.27k| YY_STACK_PRINT (yyss, yyssp); 5345| 14.9k| while (yyssp != yyss) ------------------ | Branch (5345:10): [True: 13.6k, False: 1.27k] ------------------ 5346| 13.6k| { 5347| 13.6k| yydestruct ("Cleanup: popping", 5348| 13.6k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, compiler); ------------------ | | 966| 13.6k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 13.6k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5349| 13.6k| YYPOPSTACK (1); ------------------ | | 1929| 13.6k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5350| 13.6k| } 5351| 1.27k|#ifndef yyoverflow 5352| 1.27k| if (yyss != yyssa) ------------------ | Branch (5352:7): [True: 40, False: 1.23k] ------------------ 5353| 40| YYSTACK_FREE (yyss); ------------------ | | 791| 40|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 40|#define YYFREE yr_free | | ------------------ ------------------ 5354| 1.27k|#endif 5355| 1.27k| if (yymsg != yymsgbuf) ------------------ | Branch (5355:7): [True: 0, False: 1.27k] ------------------ 5356| 0| YYSTACK_FREE (yymsg); ------------------ | | 791| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5357| 1.27k| return yyresult; 5358| 76.0k|} grammar.c:yysyntax_error: 1678| 4.16k|{ 1679| 4.16k| enum { YYARGS_MAX = 5 }; 1680| | /* Internationalized format string. */ 1681| 4.16k| const char *yyformat = YY_NULLPTR; ------------------ | | 222| 4.16k|# define YY_NULLPTR ((void*)0) ------------------ 1682| | /* Arguments of yyformat: reported tokens (one for the "unexpected", 1683| | one per "expected"). */ 1684| 4.16k| yysymbol_kind_t yyarg[YYARGS_MAX]; 1685| | /* Cumulated lengths of YYARG. */ 1686| 4.16k| YYPTRDIFF_T yysize = 0; ------------------ | | 633| 4.16k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1687| | 1688| | /* Actual size of YYARG. */ 1689| 4.16k| int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); 1690| 4.16k| if (yycount == YYENOMEM) ------------------ | Branch (1690:7): [True: 0, False: 4.16k] ------------------ 1691| 0| return YYENOMEM; 1692| | 1693| 4.16k| switch (yycount) 1694| 4.16k| { 1695| 0|#define YYCASE_(N, S) \ 1696| 0| case N: \ 1697| 0| yyformat = S; \ 1698| 0| break 1699| 0| default: /* Avoid compiler warnings. */ ------------------ | Branch (1699:5): [True: 0, False: 4.16k] ------------------ 1700| 0| YYCASE_(0, YY_("syntax error")); ------------------ | | 1696| 0| case N: \ | | ------------------ | | | Branch (1696:7): [True: 0, False: 4.16k] | | ------------------ | | 1697| 0| yyformat = S; \ | | 1698| 0| break ------------------ 1701| 653| YYCASE_(1, YY_("syntax error, unexpected %s")); ------------------ | | 1696| 653| case N: \ | | ------------------ | | | Branch (1696:7): [True: 653, False: 3.51k] | | ------------------ | | 1697| 653| yyformat = S; \ | | 1698| 653| break ------------------ 1702| 2.90k| YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); ------------------ | | 1696| 2.90k| case N: \ | | ------------------ | | | Branch (1696:7): [True: 2.90k, False: 1.26k] | | ------------------ | | 1697| 2.90k| yyformat = S; \ | | 1698| 2.90k| break ------------------ 1703| 218| YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); ------------------ | | 1696| 218| case N: \ | | ------------------ | | | Branch (1696:7): [True: 218, False: 3.95k] | | ------------------ | | 1697| 218| yyformat = S; \ | | 1698| 218| break ------------------ 1704| 397| YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); ------------------ | | 1696| 397| case N: \ | | ------------------ | | | Branch (1696:7): [True: 397, False: 3.77k] | | ------------------ | | 1697| 397| yyformat = S; \ | | 1698| 397| break ------------------ 1705| 4.16k| YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); ------------------ | | 1696| 0| case N: \ | | ------------------ | | | Branch (1696:7): [True: 0, False: 4.16k] | | ------------------ | | 1697| 0| yyformat = S; \ | | 1698| 0| break ------------------ 1706| 4.16k|#undef YYCASE_ 1707| 4.16k| } 1708| | 1709| | /* Compute error message size. Don't count the "%s"s, but reserve 1710| | room for the terminator. */ 1711| 4.16k| yysize = yystrlen (yyformat) - 2 * yycount + 1; ------------------ | | 1537| 4.16k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 210| 4.16k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1712| 4.16k| { 1713| 4.16k| int yyi; 1714| 12.8k| for (yyi = 0; yyi < yycount; ++yyi) ------------------ | Branch (1714:19): [True: 8.69k, False: 4.16k] ------------------ 1715| 8.69k| { 1716| 8.69k| YYPTRDIFF_T yysize1 ------------------ | | 633| 8.69k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1717| 8.69k| = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); ------------------ | | 222| 8.69k|# define YY_NULLPTR ((void*)0) ------------------ 1718| 8.69k| if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) ------------------ | | 793| 8.69k|# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM | | ------------------ | | | | 661| 8.69k| YY_CAST (YYPTRDIFF_T, \ | | | | ------------------ | | | | | | 210| 17.3k|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | | | | Branch (210:40): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1718:13): [True: 8.69k, False: 0] | Branch (1718:34): [True: 8.69k, False: 0] ------------------ 1719| 8.69k| yysize = yysize1; 1720| 0| else 1721| 0| return YYENOMEM; 1722| 8.69k| } 1723| 4.16k| } 1724| | 1725| 4.16k| if (*yymsg_alloc < yysize) ------------------ | Branch (1725:7): [True: 0, False: 4.16k] ------------------ 1726| 0| { 1727| 0| *yymsg_alloc = 2 * yysize; 1728| 0| if (! (yysize <= *yymsg_alloc ------------------ | Branch (1728:14): [True: 0, False: 0] ------------------ 1729| 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 (1729:17): [True: 0, False: 0] ------------------ 1730| 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] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1731| 0| return -1; 1732| 0| } 1733| | 1734| | /* Avoid sprintf, as that infringes on the user's name space. 1735| | Don't have undefined behavior even if the translation 1736| | produced a string with the wrong number of "%s"s. */ 1737| 4.16k| { 1738| 4.16k| char *yyp = *yymsg; 1739| 4.16k| int yyi = 0; 1740| 163k| while ((*yyp = *yyformat) != '\0') ------------------ | Branch (1740:12): [True: 159k, False: 4.16k] ------------------ 1741| 159k| if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) ------------------ | Branch (1741:11): [True: 8.69k, False: 150k] | Branch (1741:26): [True: 8.69k, False: 0] | Branch (1741:48): [True: 8.69k, False: 0] ------------------ 1742| 8.69k| { 1743| 8.69k| yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); 1744| 8.69k| yyformat += 2; 1745| 8.69k| } 1746| 150k| else 1747| 150k| { 1748| 150k| ++yyp; 1749| 150k| ++yyformat; 1750| 150k| } 1751| 4.16k| } 1752| 4.16k| return 0; 1753| 4.16k|} grammar.c:yy_syntax_error_arguments: 1625| 4.16k|{ 1626| | /* Actual size of YYARG. */ 1627| 4.16k| int yycount = 0; 1628| | /* There are many possibilities here to consider: 1629| | - If this state is a consistent state with a default action, then 1630| | the only way this function was invoked is if the default action 1631| | is an error action. In that case, don't check for expected 1632| | tokens because there are none. 1633| | - The only way there can be no lookahead present (in yychar) is if 1634| | this state is a consistent state with a default action. Thus, 1635| | detecting the absence of a lookahead is sufficient to determine 1636| | that there is no unexpected or expected token to report. In that 1637| | case, just report a simple "syntax error". 1638| | - Don't assume there isn't a lookahead just because this state is a 1639| | consistent state with a default action. There might have been a 1640| | previous inconsistent state, consistent state with a non-default 1641| | action, or user semantic action that manipulated yychar. 1642| | - Of course, the expected token list depends on states to have 1643| | correct lookahead information, and it depends on the parser not 1644| | to perform extra reductions after fetching a lookahead from the 1645| | scanner and before detecting a syntax error. Thus, state merging 1646| | (from LALR or IELR) and default reductions corrupt the expected 1647| | token list. However, the list is correct for canonical LR with 1648| | one exception: it will still contain any token that will not be 1649| | accepted due to an error action in a later state. 1650| | */ 1651| 4.16k| if (yyctx->yytoken != YYSYMBOL_YYEMPTY) ------------------ | Branch (1651:7): [True: 4.16k, False: 0] ------------------ 1652| 4.16k| { 1653| 4.16k| int yyn; 1654| 4.16k| if (yyarg) ------------------ | Branch (1654:11): [True: 4.16k, False: 0] ------------------ 1655| 4.16k| yyarg[yycount] = yyctx->yytoken; 1656| 4.16k| ++yycount; 1657| 4.16k| yyn = yypcontext_expected_tokens (yyctx, 1658| 4.16k| yyarg ? yyarg + 1 : yyarg, yyargn - 1); ------------------ | Branch (1658:41): [True: 4.16k, False: 0] ------------------ 1659| 4.16k| if (yyn == YYENOMEM) ------------------ | Branch (1659:11): [True: 0, False: 4.16k] ------------------ 1660| 0| return YYENOMEM; 1661| 4.16k| else 1662| 4.16k| yycount += yyn; 1663| 4.16k| } 1664| 4.16k| return yycount; 1665| 4.16k|} grammar.c:yypcontext_expected_tokens: 1501| 4.16k|{ 1502| | /* Actual size of YYARG. */ 1503| 4.16k| int yycount = 0; 1504| 4.16k| int yyn = yypact[+*yyctx->yyssp]; 1505| 4.16k| if (!yypact_value_is_default (yyn)) ------------------ | | 1020| 4.16k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1017| 4.16k|#define YYPACT_NINF (-172) | | ------------------ ------------------ | Branch (1505:7): [True: 4.16k, False: 0] ------------------ 1506| 4.16k| { 1507| | /* Start YYX at -YYN if negative to avoid negative indexes in 1508| | YYCHECK. In other words, skip the first -YYN actions for 1509| | this state because they are default actions. */ 1510| 4.16k| int yyxbegin = yyn < 0 ? -yyn : 0; ------------------ | Branch (1510:22): [True: 13, False: 4.15k] ------------------ 1511| | /* Stay within bounds of both yycheck and yytname. */ 1512| 4.16k| int yychecklim = YYLAST - yyn + 1; ------------------ | | 881| 4.16k|#define YYLAST 476 ------------------ 1513| 4.16k| int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 884| 4.16k|#define YYNTOKENS 84 ------------------ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ------------------ | | 884| 4.16k|#define YYNTOKENS 84 ------------------ | Branch (1513:20): [True: 0, False: 4.16k] ------------------ 1514| 4.16k| int yyx; 1515| 305k| for (yyx = yyxbegin; yyx < yyxend; ++yyx) ------------------ | Branch (1515:28): [True: 301k, False: 3.51k] ------------------ 1516| 301k| if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror ------------------ | Branch (1516:13): [True: 8.38k, False: 293k] | Branch (1516:42): [True: 7.79k, False: 596] ------------------ 1517| 301k| && !yytable_value_is_error (yytable[yyx + yyn])) ------------------ | | 1025| 0| 0 ------------------ | Branch (1517:16): [Folded - Ignored] ------------------ 1518| 7.79k| { 1519| 7.79k| if (!yyarg) ------------------ | Branch (1519:17): [True: 0, False: 7.79k] ------------------ 1520| 0| ++yycount; 1521| 7.79k| else if (yycount == yyargn) ------------------ | Branch (1521:22): [True: 653, False: 7.14k] ------------------ 1522| 653| return 0; 1523| 7.14k| else 1524| 7.14k| yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); ------------------ | | 210| 7.14k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1525| 7.79k| } 1526| 4.16k| } 1527| 3.51k| if (yyarg && yycount == 0 && 0 < yyargn) ------------------ | Branch (1527:7): [True: 3.51k, False: 0] | Branch (1527:16): [True: 0, False: 3.51k] | Branch (1527:32): [True: 0, False: 0] ------------------ 1528| 0| yyarg[0] = YYSYMBOL_YYEMPTY; 1529| 3.51k| return yycount; 1530| 4.16k|} grammar.c:yytnamerr: 1581| 17.3k|{ 1582| 17.3k| if (*yystr == '"') ------------------ | Branch (1582:7): [True: 14.5k, False: 2.86k] ------------------ 1583| 14.5k| { 1584| 14.5k| YYPTRDIFF_T yyn = 0; ------------------ | | 633| 14.5k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1585| 14.5k| char const *yyp = yystr; 1586| 14.5k| for (;;) 1587| 150k| switch (*++yyp) 1588| 150k| { 1589| 0| case '\'': ------------------ | Branch (1589:11): [True: 0, False: 150k] ------------------ 1590| 0| case ',': ------------------ | Branch (1590:11): [True: 0, False: 150k] ------------------ 1591| 0| goto do_not_strip_quotes; 1592| | 1593| 0| case '\\': ------------------ | Branch (1593:11): [True: 0, False: 150k] ------------------ 1594| 0| if (*++yyp != '\\') ------------------ | Branch (1594:17): [True: 0, False: 0] ------------------ 1595| 0| goto do_not_strip_quotes; 1596| 0| else 1597| 0| goto append; 1598| | 1599| 0| append: 1600| 135k| default: ------------------ | Branch (1600:11): [True: 135k, False: 14.5k] ------------------ 1601| 135k| if (yyres) ------------------ | Branch (1601:17): [True: 67.9k, False: 67.9k] ------------------ 1602| 67.9k| yyres[yyn] = *yyp; 1603| 135k| yyn++; 1604| 135k| break; 1605| | 1606| 14.5k| case '"': ------------------ | Branch (1606:11): [True: 14.5k, False: 135k] ------------------ 1607| 14.5k| if (yyres) ------------------ | Branch (1607:17): [True: 7.26k, False: 7.26k] ------------------ 1608| 7.26k| yyres[yyn] = '\0'; 1609| 14.5k| return yyn; 1610| 150k| } 1611| 0| do_not_strip_quotes: ; 1612| 0| } 1613| | 1614| 2.86k| if (yyres) ------------------ | Branch (1614:7): [True: 1.43k, False: 1.43k] ------------------ 1615| 1.43k| return yystpcpy (yyres, yystr) - yyres; ------------------ | | 1553| 1.43k|# define yystpcpy stpcpy ------------------ 1616| 1.43k| else 1617| 1.43k| return yystrlen (yystr); ------------------ | | 1537| 1.43k|# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) | | ------------------ | | | | 210| 1.43k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1618| 2.86k|} grammar.c:yydestruct: 1763| 305k|{ 1764| 305k| YY_USE (yyvaluep); ------------------ | | 706| 305k|# define YY_USE(E) ((void) (E)) ------------------ 1765| 305k| YY_USE (yyscanner); ------------------ | | 706| 305k|# define YY_USE(E) ((void) (E)) ------------------ 1766| 305k| YY_USE (compiler); ------------------ | | 706| 305k|# define YY_USE(E) ((void) (E)) ------------------ 1767| 305k| if (!yymsg) ------------------ | Branch (1767:7): [True: 0, False: 305k] ------------------ 1768| 0| yymsg = "Deleting"; 1769| 305k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1770| | 1771| 305k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1772| 305k| switch (yykind) 1773| 305k| { 1774| 21.2k| case YYSYMBOL__IDENTIFIER_: /* "identifier" */ ------------------ | Branch (1774:5): [True: 21.2k, False: 284k] ------------------ 1775| 21.2k|#line 312 "libyara/grammar.y" 1776| 21.2k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1777| 21.2k|#line 1778 "libyara/grammar.c" 1778| 21.2k| break; 1779| | 1780| 1.11k| case YYSYMBOL__STRING_IDENTIFIER_: /* "string identifier" */ ------------------ | Branch (1780:5): [True: 1.11k, False: 304k] ------------------ 1781| 1.11k|#line 316 "libyara/grammar.y" 1782| 1.11k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1783| 1.11k|#line 1784 "libyara/grammar.c" 1784| 1.11k| break; 1785| | 1786| 126| case YYSYMBOL__STRING_COUNT_: /* "string count" */ ------------------ | Branch (1786:5): [True: 126, False: 305k] ------------------ 1787| 126|#line 313 "libyara/grammar.y" 1788| 126| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1789| 126|#line 1790 "libyara/grammar.c" 1790| 126| break; 1791| | 1792| 255| case YYSYMBOL__STRING_OFFSET_: /* "string offset" */ ------------------ | Branch (1792:5): [True: 255, False: 305k] ------------------ 1793| 255|#line 314 "libyara/grammar.y" 1794| 255| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1795| 255|#line 1796 "libyara/grammar.c" 1796| 255| break; 1797| | 1798| 1.11k| case YYSYMBOL__STRING_LENGTH_: /* "string length" */ ------------------ | Branch (1798:5): [True: 1.11k, False: 304k] ------------------ 1799| 1.11k|#line 315 "libyara/grammar.y" 1800| 1.11k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1801| 1.11k|#line 1802 "libyara/grammar.c" 1802| 1.11k| break; 1803| | 1804| 167| case YYSYMBOL__STRING_IDENTIFIER_WITH_WILDCARD_: /* "string identifier with wildcard" */ ------------------ | Branch (1804:5): [True: 167, False: 305k] ------------------ 1805| 167|#line 317 "libyara/grammar.y" 1806| 167| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1807| 167|#line 1808 "libyara/grammar.c" 1808| 167| break; 1809| | 1810| 1.88k| case YYSYMBOL__TEXT_STRING_: /* "text string" */ ------------------ | Branch (1810:5): [True: 1.88k, False: 303k] ------------------ 1811| 1.88k|#line 318 "libyara/grammar.y" 1812| 1.88k| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1813| 1.88k|#line 1814 "libyara/grammar.c" 1814| 1.88k| break; 1815| | 1816| 294| case YYSYMBOL__HEX_STRING_: /* "hex string" */ ------------------ | Branch (1816:5): [True: 294, False: 305k] ------------------ 1817| 294|#line 319 "libyara/grammar.y" 1818| 294| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1819| 294|#line 1820 "libyara/grammar.c" 1820| 294| break; 1821| | 1822| 1.34k| case YYSYMBOL__REGEXP_: /* "regular expression" */ ------------------ | Branch (1822:5): [True: 1.34k, False: 304k] ------------------ 1823| 1.34k|#line 320 "libyara/grammar.y" 1824| 1.34k| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1825| 1.34k|#line 1826 "libyara/grammar.c" 1826| 1.34k| break; 1827| | 1828| 13| case YYSYMBOL_string_modifiers: /* string_modifiers */ ------------------ | Branch (1828:5): [True: 13, False: 305k] ------------------ 1829| 13|#line 333 "libyara/grammar.y" 1830| 13| { 1831| 13| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1831:7): [True: 4, False: 9] ------------------ 1832| 4| { 1833| 4| yr_free(((*yyvaluep).modifier).alphabet); 1834| 4| ((*yyvaluep).modifier).alphabet = NULL; 1835| 4| } 1836| 13|} 1837| 13|#line 1838 "libyara/grammar.c" 1838| 13| break; 1839| | 1840| 0| case YYSYMBOL_string_modifier: /* string_modifier */ ------------------ | Branch (1840:5): [True: 0, False: 305k] ------------------ 1841| 0|#line 325 "libyara/grammar.y" 1842| 0| { 1843| 0| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1843:7): [True: 0, False: 0] ------------------ 1844| 0| { 1845| 0| yr_free(((*yyvaluep).modifier).alphabet); 1846| 0| ((*yyvaluep).modifier).alphabet = NULL; 1847| 0| } 1848| 0|} 1849| 0|#line 1850 "libyara/grammar.c" 1850| 0| break; 1851| | 1852| 64| case YYSYMBOL_arguments: /* arguments */ ------------------ | Branch (1852:5): [True: 64, False: 305k] ------------------ 1853| 64|#line 322 "libyara/grammar.y" 1854| 64| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1855| 64|#line 1856 "libyara/grammar.c" 1856| 64| break; 1857| | 1858| 1.18k| case YYSYMBOL_arguments_list: /* arguments_list */ ------------------ | Branch (1858:5): [True: 1.18k, False: 304k] ------------------ 1859| 1.18k|#line 323 "libyara/grammar.y" 1860| 1.18k| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1861| 1.18k|#line 1862 "libyara/grammar.c" 1862| 1.18k| break; 1863| | 1864| 276k| default: ------------------ | Branch (1864:7): [True: 276k, False: 28.7k] ------------------ 1865| 276k| break; 1866| 305k| } 1867| 305k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1868| 305k|} yr_hash: 94| 164k|{ 95| 164k| const uint8_t* b = (uint8_t*) buffer; 96| | 97| 164k| uint32_t result = seed; 98| 164k| size_t i; 99| | 100| 164k| if (len == 0) ------------------ | Branch (100:7): [True: 0, False: 164k] ------------------ 101| 0| return result; 102| | 103| 1.94M| for (i = len - 1; i > 0; i--) ------------------ | Branch (103:21): [True: 1.78M, False: 164k] ------------------ 104| 1.78M| { 105| 1.78M| result ^= ROTATE_INT32(byte_to_int32[*b], i); ------------------ | | 46| 1.78M|#define ROTATE_INT32(x, shift) rotl32(x, shift % 32) ------------------ 106| 1.78M| b++; 107| 1.78M| } 108| | 109| 164k| result ^= byte_to_int32[*b]; 110| 164k| return result; 111| 164k|} yr_hash_table_create: 178| 6.35k|{ 179| 6.35k| YR_HASH_TABLE* new_table; 180| 6.35k| int i; 181| | 182| 6.35k| new_table = (YR_HASH_TABLE*) yr_malloc( 183| 6.35k| sizeof(YR_HASH_TABLE) + size * sizeof(YR_HASH_TABLE_ENTRY*)); 184| | 185| 6.35k| if (new_table == NULL) ------------------ | Branch (185:7): [True: 0, False: 6.35k] ------------------ 186| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 187| | 188| 6.35k| new_table->size = size; 189| | 190| 34.2M| for (i = 0; i < size; i++) new_table->buckets[i] = NULL; ------------------ | Branch (190:15): [True: 34.2M, False: 6.35k] ------------------ 191| | 192| 6.35k| *table = new_table; 193| | 194| 6.35k| return ERROR_SUCCESS; ------------------ | | 40| 6.35k|#define ERROR_SUCCESS 0 ------------------ 195| 6.35k|} yr_hash_table_clean: 200| 13.1k|{ 201| 13.1k| YR_HASH_TABLE_ENTRY* entry; 202| 13.1k| YR_HASH_TABLE_ENTRY* next_entry; 203| | 204| 13.1k| int i; 205| | 206| 13.1k| if (table == NULL) ------------------ | Branch (206:7): [True: 0, False: 13.1k] ------------------ 207| 0| return; 208| | 209| 102M| for (i = 0; i < table->size; i++) ------------------ | Branch (209:15): [True: 102M, False: 13.1k] ------------------ 210| 102M| { 211| 102M| entry = table->buckets[i]; 212| | 213| 102M| while (entry != NULL) ------------------ | Branch (213:12): [True: 19.7k, False: 102M] ------------------ 214| 19.7k| { 215| 19.7k| next_entry = entry->next; 216| | 217| 19.7k| if (free_value != NULL) ------------------ | Branch (217:11): [True: 151, False: 19.5k] ------------------ 218| 151| free_value(entry->value); 219| | 220| 19.7k| if (entry->ns != NULL) ------------------ | Branch (220:11): [True: 7.96k, False: 11.7k] ------------------ 221| 7.96k| yr_free(entry->ns); 222| | 223| 19.7k| yr_free(entry->key); 224| 19.7k| yr_free(entry); 225| | 226| 19.7k| entry = next_entry; 227| 19.7k| } 228| | 229| 102M| table->buckets[i] = NULL; 230| 102M| } 231| 13.1k|} yr_hash_table_destroy: 236| 6.35k|{ 237| 6.35k| yr_hash_table_clean(table, free_value); 238| 6.35k| yr_free(table); 239| 6.35k|} yr_hash_table_iterate: 246| 7.77k|{ 247| 7.77k| int result; 248| 7.77k| YR_HASH_TABLE_ENTRY* entry; 249| | 250| 7.77k| if (table == NULL) ------------------ | Branch (250:7): [True: 0, False: 7.77k] ------------------ 251| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 252| | 253| 7.12M| for (int i = 0; i < table->size; i++) ------------------ | Branch (253:19): [True: 7.11M, False: 6.80k] ------------------ 254| 7.11M| { 255| 7.11M| entry = table->buckets[i]; 256| 7.11M| while (entry != NULL) ------------------ | Branch (256:12): [True: 1.48k, False: 7.11M] ------------------ 257| 1.48k| { 258| 1.48k| if ((entry->ns == NULL && ns == NULL) ------------------ | Branch (258:12): [True: 0, False: 1.48k] | Branch (258:33): [True: 0, False: 0] ------------------ 259| 1.48k| || (entry->ns != NULL && ns != NULL && !strcmp(entry->ns, ns))) ------------------ | Branch (259:15): [True: 1.48k, False: 0] | Branch (259:36): [True: 1.48k, False: 0] | Branch (259:50): [True: 1.48k, False: 0] ------------------ 260| 1.48k| { 261| 1.48k| result = iterate_func( 262| 1.48k| entry->key, entry->key_length, entry->value, data); 263| | 264| 1.48k| if (result != ERROR_SUCCESS) ------------------ | | 40| 1.48k|#define ERROR_SUCCESS 0 ------------------ | Branch (264:13): [True: 978, False: 503] ------------------ 265| 978| return result; 266| 1.48k| } 267| 503| entry = entry->next; 268| 503| } 269| 7.11M| } 270| 6.80k| return ERROR_SUCCESS; ------------------ | | 40| 6.80k|#define ERROR_SUCCESS 0 ------------------ 271| 7.77k|} yr_hash_table_lookup_raw_key: 278| 114k|{ 279| 114k| return _yr_hash_table_lookup(table, key, key_length, ns, false); 280| 114k|} yr_hash_table_add_raw_key: 297| 19.7k|{ 298| 19.7k| YR_HASH_TABLE_ENTRY* entry; 299| 19.7k| uint32_t bucket_index; 300| | 301| 19.7k| entry = (YR_HASH_TABLE_ENTRY*) yr_malloc(sizeof(YR_HASH_TABLE_ENTRY)); 302| | 303| 19.7k| if (entry == NULL) ------------------ | Branch (303:7): [True: 0, False: 19.7k] ------------------ 304| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 305| | 306| 19.7k| entry->key = yr_malloc(key_length); 307| | 308| 19.7k| if (entry->key == NULL) ------------------ | Branch (308:7): [True: 0, False: 19.7k] ------------------ 309| 0| { 310| 0| yr_free(entry); 311| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 312| 0| } 313| | 314| 19.7k| if (ns != NULL) ------------------ | Branch (314:7): [True: 7.96k, False: 11.7k] ------------------ 315| 7.96k| { 316| 7.96k| entry->ns = yr_strdup(ns); 317| | 318| 7.96k| if (entry->ns == NULL) ------------------ | Branch (318:9): [True: 0, False: 7.96k] ------------------ 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| 7.96k| } 326| 11.7k| else 327| 11.7k| { 328| 11.7k| entry->ns = NULL; 329| 11.7k| } 330| | 331| 19.7k| entry->key_length = key_length; 332| 19.7k| entry->value = value; 333| | 334| 19.7k| memcpy(entry->key, key, key_length); 335| | 336| 19.7k| bucket_index = yr_hash(0, key, key_length); 337| | 338| 19.7k| if (ns != NULL) ------------------ | Branch (338:7): [True: 7.96k, False: 11.7k] ------------------ 339| 7.96k| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 340| | 341| 19.7k| bucket_index = bucket_index % table->size; 342| | 343| 19.7k| entry->next = table->buckets[bucket_index]; 344| 19.7k| table->buckets[bucket_index] = entry; 345| | 346| 19.7k| return ERROR_SUCCESS; ------------------ | | 40| 19.7k|#define ERROR_SUCCESS 0 ------------------ 347| 19.7k|} yr_hash_table_lookup: 353| 17.1k|{ 354| 17.1k| return yr_hash_table_lookup_raw_key(table, (void*) key, strlen(key), ns); 355| 17.1k|} yr_hash_table_add: 370| 151|{ 371| 151| return yr_hash_table_add_raw_key(table, (void*) key, strlen(key), ns, value); 372| 151|} yr_hash_table_add_uint32: 379| 8.20k|{ 380| 8.20k| return yr_hash_table_add_uint32_raw_key( 381| 8.20k| table, (void*) key, strlen(key), ns, value); 382| 8.20k|} yr_hash_table_lookup_uint32: 388| 39.6k|{ 389| 39.6k| return yr_hash_table_lookup_uint32_raw_key( 390| 39.6k| table, (void*) key, strlen(key), ns); 391| 39.6k|} yr_hash_table_add_uint32_raw_key: 399| 19.5k|{ 400| | // Don't allow values equal to UINT32_MAX or UINT32_MAX - 1. 401| 19.5k| if (value >= UINT32_MAX - 1) ------------------ | Branch (401:7): [True: 0, False: 19.5k] ------------------ 402| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 74| 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| 19.5k| return yr_hash_table_add_raw_key( 408| 19.5k| table, key, key_length, ns, (void*) (size_t) (value + 1)); 409| 19.5k|} yr_hash_table_lookup_uint32_raw_key: 416| 97.3k|{ 417| 97.3k| void* ptr = yr_hash_table_lookup_raw_key(table, key, key_length, ns); 418| | 419| 97.3k| if (ptr == NULL) ------------------ | Branch (419:7): [True: 41.6k, False: 55.6k] ------------------ 420| 41.6k| 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| 55.6k| return ((uint32_t) (size_t) (uint8_t*) ptr) - 1; 425| 97.3k|} hash.c:rotl32: 41| 1.78M|{ 42| 1.78M| assert(shift < 32); 43| 1.78M| return (x << shift) | (x >> (-shift & 31)); 44| 1.78M|} hash.c:_yr_hash_table_lookup: 124| 114k|{ 125| 114k| YR_HASH_TABLE_ENTRY* entry; 126| 114k| YR_HASH_TABLE_ENTRY* prev_entry; 127| | 128| 114k| void* result; 129| | 130| 114k| uint32_t bucket_index = yr_hash(0, key, key_length); 131| | 132| 114k| if (ns != NULL) ------------------ | Branch (132:7): [True: 22.4k, False: 92.0k] ------------------ 133| 22.4k| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 134| | 135| 114k| bucket_index = bucket_index % table->size; 136| 114k| prev_entry = NULL; 137| 114k| entry = table->buckets[bucket_index]; 138| | 139| 115k| while (entry != NULL) ------------------ | Branch (139:10): [True: 58.2k, False: 56.9k] ------------------ 140| 58.2k| { 141| 58.2k| int key_match = 142| 58.2k| ((entry->key_length == key_length) && ------------------ | Branch (142:10): [True: 57.6k, False: 590] ------------------ 143| 58.2k| (memcmp(entry->key, key, key_length) == 0)); ------------------ | Branch (143:10): [True: 57.5k, False: 174] ------------------ 144| | 145| 58.2k| int ns_match = 146| 58.2k| ((entry->ns == ns) || ------------------ | Branch (146:10): [True: 46.8k, False: 11.4k] ------------------ 147| 58.2k| (entry->ns != NULL && ns != NULL && strcmp(entry->ns, ns) == 0)); ------------------ | Branch (147:11): [True: 11.4k, False: 0] | Branch (147:32): [True: 11.3k, False: 135] | Branch (147:46): [True: 11.3k, False: 0] ------------------ 148| | 149| 58.2k| if (key_match && ns_match) ------------------ | Branch (149:9): [True: 57.5k, False: 764] | Branch (149:22): [True: 57.5k, False: 0] ------------------ 150| 57.5k| { 151| 57.5k| result = entry->value; 152| | 153| 57.5k| if (remove) ------------------ | Branch (153:11): [True: 0, False: 57.5k] ------------------ 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| 57.5k| return result; 168| 57.5k| } 169| | 170| 764| prev_entry = entry; 171| 764| entry = entry->next; 172| 764| } 173| | 174| 56.9k| return NULL; 175| 114k|} hex_yyparse: 1000| 1.07k|{ 1001| |/* Lookahead token kind. */ 1002| 1.07k|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.07k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 403| 1.07k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1009| 1.07k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 403| 1.07k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1010| | 1011| | /* Number of syntax errors so far. */ 1012| 1.07k| int yynerrs = 0; 1013| | 1014| 1.07k| yy_state_fast_t yystate = 0; 1015| | /* Number of tokens to shift before error messages enabled. */ 1016| 1.07k| 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.07k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 310| 1.07k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 904| 1.07k|# define YYINITDEPTH 200 ------------------ 1023| | 1024| | /* The state stack: array, bottom, top. */ 1025| 1.07k| yy_state_t yyssa[YYINITDEPTH]; 1026| 1.07k| yy_state_t *yyss = yyssa; 1027| 1.07k| yy_state_t *yyssp = yyss; 1028| | 1029| | /* The semantic value stack: array, bottom, top. */ 1030| 1.07k| YYSTYPE yyvsa[YYINITDEPTH]; 1031| 1.07k| YYSTYPE *yyvs = yyvsa; 1032| 1.07k| YYSTYPE *yyvsp = yyvs; 1033| | 1034| 1.07k| int yyn; 1035| | /* The return value of yyparse. */ 1036| 1.07k| int yyresult; 1037| | /* Lookahead symbol kind. */ 1038| 1.07k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1039| | /* The variables used to return semantic value and location from the 1040| | action routines. */ 1041| 1.07k| YYSTYPE yyval; 1042| | 1043| | 1044| | 1045| 1.07k|#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.07k| int yylen = 0; 1050| | 1051| 1.07k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 895| 1.07k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1052| | 1053| 1.07k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 50| 1.07k|#define yychar hex_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 66| 1.07k|#define YYEMPTY -2 ------------------ 1054| | 1055| 1.07k| goto yysetstate; 1056| | 1057| | 1058| |/*------------------------------------------------------------. 1059| || yynewstate -- push a new state, which is found in yystate. | 1060| |`------------------------------------------------------------*/ 1061| 527k|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| 527k| yyssp++; 1065| | 1066| | 1067| |/*--------------------------------------------------------------------. 1068| || yysetstate -- set current state (the top of the stack) to yystate. | 1069| |`--------------------------------------------------------------------*/ 1070| 528k|yysetstate: 1071| 528k| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 895| 528k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1072| 528k| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 426| 528k|#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| 528k| YY_IGNORE_USELESS_CAST_BEGIN 1074| 528k| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 121| 528k|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1075| 528k| YY_IGNORE_USELESS_CAST_END 1076| 528k| YY_STACK_PRINT (yyss, yyssp); 1077| | 1078| 528k| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1078:7): [True: 375, False: 528k] ------------------ 1079| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1080| | YYNOMEM; 1081| |#else 1082| 375| { 1083| | /* Get the current used size of the three stacks, in elements. */ 1084| 375| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 310| 375|# 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| 375| if (YYMAXDEPTH <= yystacksize) ------------------ | | 915| 375|# define YYMAXDEPTH 10000 ------------------ | Branch (1107:11): [True: 10, False: 365] ------------------ 1108| 10| YYNOMEM; ------------------ | | 746| 10|#define YYNOMEM goto yyexhaustedlab ------------------ 1109| 365| yystacksize *= 2; 1110| 365| if (YYMAXDEPTH < yystacksize) ------------------ | | 915| 365|# define YYMAXDEPTH 10000 ------------------ | Branch (1110:11): [True: 22, False: 343] ------------------ 1111| 22| yystacksize = YYMAXDEPTH; ------------------ | | 915| 22|# define YYMAXDEPTH 10000 ------------------ 1112| | 1113| 365| { 1114| 365| yy_state_t *yyss1 = yyss; 1115| 365| union yyalloc *yyptr = 1116| 365| YY_CAST (union yyalloc *, ------------------ | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1117| 365| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1118| 365| if (! yyptr) ------------------ | Branch (1118:13): [True: 0, False: 365] ------------------ 1119| 0| YYNOMEM; ------------------ | | 746| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1120| 365| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 523| 365| do \ | | 524| 365| { \ | | 525| 365| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 310| 365|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 526| 365| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 541| 365| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 527| 365| Stack = &yyptr->Stack_alloc; \ | | 528| 365| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 507| 365|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 529| 365| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 530| 365| } \ | | 531| 365| while (0) | | ------------------ | | | Branch (531:12): [Folded - Ignored] | | ------------------ ------------------ 1121| 365| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 523| 365| do \ | | 524| 365| { \ | | 525| 365| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 310| 365|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 526| 365| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 541| 365| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 527| 365| Stack = &yyptr->Stack_alloc; \ | | 528| 365| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 507| 365|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 529| 365| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 343| 365|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 121| 365|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 530| 365| } \ | | 531| 365| while (0) | | ------------------ | | | Branch (531:12): [Folded - Ignored] | | ------------------ ------------------ 1122| 365|# undef YYSTACK_RELOCATE 1123| 365| if (yyss1 != yyssa) ------------------ | Branch (1123:13): [True: 254, False: 111] ------------------ 1124| 254| YYSTACK_FREE (yyss1); ------------------ | | 468| 254|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 95| 254|#define YYFREE yr_free | | ------------------ ------------------ 1125| 365| } 1126| 0|# endif 1127| | 1128| 0| yyssp = yyss + yysize - 1; 1129| 365| yyvsp = yyvs + yysize - 1; 1130| | 1131| 365| YY_IGNORE_USELESS_CAST_BEGIN 1132| 365| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 895| 365|# define YYDPRINTF(Args) ((void) 0) ------------------ 1133| 365| YY_CAST (long, yystacksize))); 1134| 365| YY_IGNORE_USELESS_CAST_END 1135| | 1136| 365| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1136:11): [True: 0, False: 365] ------------------ 1137| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1138| 365| } 1139| 528k|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1140| | 1141| | 1142| 528k| if (yystate == YYFINAL) ------------------ | | 556| 528k|#define YYFINAL 11 ------------------ | Branch (1142:7): [True: 824, False: 527k] ------------------ 1143| 824| YYACCEPT; ------------------ | | 743| 824|#define YYACCEPT goto yyacceptlab ------------------ 1144| | 1145| 527k| goto yybackup; 1146| | 1147| | 1148| |/*-----------. 1149| || yybackup. | 1150| |`-----------*/ 1151| 527k|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| 527k| yyn = yypact[yystate]; 1157| 527k| if (yypact_value_is_default (yyn)) ------------------ | | 652| 527k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 649| 527k|#define YYPACT_NINF (-13) | | ------------------ | | | Branch (652:3): [True: 284k, False: 242k] | | ------------------ ------------------ 1158| 284k| 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| 242k| if (yychar == YYEMPTY) ------------------ | | 50| 242k|#define yychar hex_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 66| 242k|#define YYEMPTY -2 ------------------ | Branch (1163:7): [True: 196k, False: 46.6k] ------------------ 1164| 196k| { 1165| 196k| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 895| 196k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1166| 196k| yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 50| 196k|#define yychar hex_yychar ------------------ yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 47| 196k|#define yylex hex_yylex ------------------ 1167| 196k| } 1168| | 1169| 242k| if (yychar <= YYEOF) ------------------ | | 50| 242k|#define yychar hex_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 67| 242k|#define YYEOF 0 ------------------ | Branch (1169:7): [True: 867, False: 242k] ------------------ 1170| 867| { 1171| 867| yychar = YYEOF; ------------------ | | 50| 867|#define yychar hex_yychar ------------------ yychar = YYEOF; ------------------ | | 67| 867|#define YYEOF 0 ------------------ 1172| 867| yytoken = YYSYMBOL_YYEOF; 1173| 867| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 895| 867|# define YYDPRINTF(Args) ((void) 0) ------------------ 1174| 867| } 1175| 242k| else if (yychar == YYerror) ------------------ | | 50| 242k|#define yychar hex_yychar ------------------ else if (yychar == YYerror) ------------------ | | 68| 242k|#define YYerror 256 ------------------ | Branch (1175:12): [True: 0, False: 242k] ------------------ 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| 242k| else 1186| 242k| { 1187| 242k| yytoken = YYTRANSLATE (yychar); ------------------ | | 576| 242k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 242k|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 242k, False: 0] | | | Branch (576:18): [True: 242k, False: 0] | | ------------------ | | 577| 242k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 242k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 242k| : YYSYMBOL_YYUNDEF) ------------------ 1188| 242k| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1189| 242k| } 1190| | 1191| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1192| | detect an error, take that action. */ 1193| 242k| yyn += yytoken; 1194| 242k| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 558| 242k|#define YYLAST 35 ------------------ | Branch (1194:7): [True: 353, False: 242k] | Branch (1194:18): [True: 0, False: 242k] | Branch (1194:34): [True: 45.7k, False: 196k] ------------------ 1195| 46.0k| goto yydefault; 1196| 196k| yyn = yytable[yyn]; 1197| 196k| if (yyn <= 0) ------------------ | Branch (1197:7): [True: 775, False: 196k] ------------------ 1198| 775| { 1199| 775| if (yytable_value_is_error (yyn)) ------------------ | | 657| 775| 0 | | ------------------ | | | Branch (657:3): [Folded - Ignored] | | ------------------ ------------------ 1200| 0| goto yyerrlab; 1201| 775| yyn = -yyn; 1202| 775| goto yyreduce; 1203| 775| } 1204| | 1205| | /* Count tokens shifted since error; after three, turn off error 1206| | status. */ 1207| 196k| if (yyerrstatus) ------------------ | Branch (1207:7): [True: 0, False: 196k] ------------------ 1208| 0| yyerrstatus--; 1209| | 1210| | /* Shift the lookahead token. */ 1211| 196k| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1212| 196k| yystate = yyn; 1213| 196k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1214| 196k| *++yyvsp = yylval; 1215| 196k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1216| | 1217| | /* Discard the shifted token. */ 1218| 196k| yychar = YYEMPTY; ------------------ | | 50| 196k|#define yychar hex_yychar ------------------ yychar = YYEMPTY; ------------------ | | 66| 196k|#define YYEMPTY -2 ------------------ 1219| 196k| goto yynewstate; 1220| | 1221| | 1222| |/*-----------------------------------------------------------. 1223| || yydefault -- do the default action for the current state. | 1224| |`-----------------------------------------------------------*/ 1225| 330k|yydefault: 1226| 330k| yyn = yydefact[yystate]; 1227| 330k| if (yyn == 0) ------------------ | Branch (1227:7): [True: 207, False: 330k] ------------------ 1228| 207| goto yyerrlab; 1229| 330k| goto yyreduce; 1230| | 1231| | 1232| |/*-----------------------------. 1233| || yyreduce -- do a reduction. | 1234| |`-----------------------------*/ 1235| 331k|yyreduce: 1236| | /* yyn is the number of a rule to reduce with. */ 1237| 331k| 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| 331k| yyval = yyvsp[1-yylen]; 1248| | 1249| | 1250| 331k| YY_REDUCE_PRINT (yyn); 1251| 331k| switch (yyn) 1252| 331k| { 1253| 824| case 2: /* hex_string: '{' tokens '}' */ ------------------ | Branch (1253:3): [True: 824, False: 330k] ------------------ 1254| 824|#line 108 "hex_grammar.y" 1255| 824| { 1256| 824| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 53| 824|#define yyget_extra hex_yyget_extra ------------------ 1257| 824| re_ast->root_node = (yyvsp[-1].re_node); 1258| 824| } 1259| 824|#line 1260 "hex_grammar.c" 1260| 824| break; 1261| | 1262| 1.43k| case 3: /* tokens: token */ ------------------ | Branch (1262:3): [True: 1.43k, False: 330k] ------------------ 1263| 1.43k|#line 117 "hex_grammar.y" 1264| 1.43k| { 1265| 1.43k| (yyval.re_node) = (yyvsp[0].re_node); 1266| 1.43k| } 1267| 1.43k|#line 1268 "hex_grammar.c" 1268| 1.43k| break; 1269| | 1270| 358| case 4: /* tokens: token token */ ------------------ | Branch (1270:3): [True: 358, False: 331k] ------------------ 1271| 358|#line 121 "hex_grammar.y" 1272| 358| { 1273| 358| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 358|#define RE_NODE_CONCAT 4 ------------------ 1274| | 1275| 358| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 108| 358| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 358] | | ------------------ | | 109| 358| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1276| 358| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 358| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 358] | | ------------------ | | 109| 358| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1277| | 1278| 358| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 358| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 358] | | ------------------ | | 102| 358| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1279| | 1280| 358| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1281| 358| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1282| 358| } 1283| 0|#line 1284 "hex_grammar.c" 1284| 0| break; 1285| | 1286| 417| case 5: /* tokens: token token_sequence token */ ------------------ | Branch (1286:3): [True: 417, False: 331k] ------------------ 1287| 417|#line 133 "hex_grammar.y" 1288| 417| { 1289| 417| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1290| 417| yr_re_node_prepend_child((yyvsp[-1].re_node), (yyvsp[-2].re_node)); 1291| | 1292| 417| (yyval.re_node) = (yyvsp[-1].re_node); 1293| 417| } 1294| 417|#line 1295 "hex_grammar.c" 1295| 417| break; 1296| | 1297| 711| case 6: /* token_sequence: token_or_range */ ------------------ | Branch (1297:3): [True: 711, False: 330k] ------------------ 1298| 711|#line 144 "hex_grammar.y" 1299| 711| { 1300| 711| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 711|#define RE_NODE_CONCAT 4 ------------------ 1301| | 1302| 711| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 711| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 711] | | ------------------ | | 109| 711| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1303| 711| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 711| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 711] | | ------------------ | | 102| 711| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1304| | 1305| 711| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1306| 711| } 1307| 0|#line 1308 "hex_grammar.c" 1308| 0| break; 1309| | 1310| 46.4k| case 7: /* token_sequence: token_sequence token_or_range */ ------------------ | Branch (1310:3): [True: 46.4k, False: 285k] ------------------ 1311| 46.4k|#line 153 "hex_grammar.y" 1312| 46.4k| { 1313| 46.4k| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1314| 46.4k| (yyval.re_node) = (yyvsp[-1].re_node); 1315| 46.4k| } 1316| 46.4k|#line 1317 "hex_grammar.c" 1317| 46.4k| break; 1318| | 1319| 44.4k| case 8: /* token_or_range: token */ ------------------ | Branch (1319:3): [True: 44.4k, False: 287k] ------------------ 1320| 44.4k|#line 162 "hex_grammar.y" 1321| 44.4k| { 1322| 44.4k| (yyval.re_node) = (yyvsp[0].re_node); 1323| 44.4k| } 1324| 44.4k|#line 1325 "hex_grammar.c" 1325| 44.4k| break; 1326| | 1327| 2.73k| case 9: /* token_or_range: range */ ------------------ | Branch (1327:3): [True: 2.73k, False: 328k] ------------------ 1328| 2.73k|#line 166 "hex_grammar.y" 1329| 2.73k| { 1330| 2.73k| (yyval.re_node) = (yyvsp[0].re_node); 1331| 2.73k| (yyval.re_node)->greedy = false; 1332| 2.73k| } 1333| 2.73k|#line 1334 "hex_grammar.c" 1334| 2.73k| break; 1335| | 1336| 47.2k| case 10: /* token: byte */ ------------------ | Branch (1336:3): [True: 47.2k, False: 284k] ------------------ 1337| 47.2k|#line 175 "hex_grammar.y" 1338| 47.2k| { 1339| 47.2k| (yyval.re_node) = (yyvsp[0].re_node); 1340| 47.2k| } 1341| 47.2k|#line 1342 "hex_grammar.c" 1342| 47.2k| break; 1343| | 1344| 134k| case 11: /* $@1: %empty */ ------------------ | Branch (1344:3): [True: 134k, False: 196k] ------------------ 1345| 134k|#line 179 "hex_grammar.y" 1346| 134k| { 1347| 134k| lex_env->inside_or++; 1348| 134k| } 1349| 134k|#line 1350 "hex_grammar.c" 1350| 134k| break; 1351| | 1352| 704| case 12: /* token: '(' $@1 alternatives ')' */ ------------------ | Branch (1352:3): [True: 704, False: 330k] ------------------ 1353| 704|#line 183 "hex_grammar.y" 1354| 704| { 1355| 704| (yyval.re_node) = (yyvsp[-1].re_node); 1356| 704| lex_env->inside_or--; 1357| 704| } 1358| 704|#line 1359 "hex_grammar.c" 1359| 704| break; 1360| | 1361| 1.57k| case 13: /* range: '[' _NUMBER_ ']' */ ------------------ | Branch (1361:3): [True: 1.57k, False: 329k] ------------------ 1362| 1.57k|#line 192 "hex_grammar.y" 1363| 1.57k| { 1364| 1.57k| if ((yyvsp[-1].integer) <= 0) ------------------ | Branch (1364:13): [True: 8, False: 1.57k] ------------------ 1365| 8| { 1366| 8| yyerror(yyscanner, lex_env, "invalid jump length"); ------------------ | | 48| 8|#define yyerror hex_yyerror ------------------ 1367| 8| YYABORT; ------------------ | | 744| 8|#define YYABORT goto yyabortlab ------------------ 1368| 8| } 1369| | 1370| 1.57k| if (lex_env->inside_or && (yyvsp[-1].integer) > YR_STRING_CHAINING_THRESHOLD) ------------------ | | 143| 160|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1370:13): [True: 160, False: 1.41k] | Branch (1370:35): [True: 0, False: 160] ------------------ 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| 1.57k| if ((yyvsp[-1].integer) == 1) ------------------ | Branch (1379:13): [True: 327, False: 1.24k] ------------------ 1380| 327| { 1381| 327| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_LITERAL); ------------------ | | 42| 327|#define RE_NODE_MASKED_LITERAL 2 ------------------ 1382| | 1383| 327| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 327| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 327] | | ------------------ | | 102| 327| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1384| | 1385| 327| (yyval.re_node)->value = 0x00; 1386| 327| (yyval.re_node)->mask = 0x00; 1387| 327| } 1388| 1.24k| else 1389| 1.24k| { 1390| 1.24k| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 1.24k|#define RE_NODE_RANGE_ANY 21 ------------------ 1391| | 1392| 1.24k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 1.24k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 1.24k] | | ------------------ | | 102| 1.24k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1393| | 1394| 1.24k| (yyval.re_node)->start = (int) (yyvsp[-1].integer); 1395| 1.24k| (yyval.re_node)->end = (int) (yyvsp[-1].integer); 1396| 1.24k| } 1397| 1.57k| } 1398| 1.57k|#line 1399 "hex_grammar.c" 1399| 1.57k| break; 1400| | 1401| 1.57k| case 14: /* range: '[' _NUMBER_ '-' _NUMBER_ ']' */ ------------------ | Branch (1401:3): [True: 748, False: 330k] ------------------ 1402| 748|#line 228 "hex_grammar.y" 1403| 748| { 1404| 748| if (lex_env->inside_or && ------------------ | Branch (1404:13): [True: 554, False: 194] ------------------ 1405| 748| ((yyvsp[-3].integer) > YR_STRING_CHAINING_THRESHOLD || ------------------ | | 143| 1.10k|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1405:14): [True: 0, False: 554] ------------------ 1406| 554| (yyvsp[-1].integer) > YR_STRING_CHAINING_THRESHOLD) ) ------------------ | | 143| 554|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (1406:14): [True: 1, False: 553] ------------------ 1407| 1| { 1408| 1| yyerror(yyscanner, lex_env, "jumps over " ------------------ | | 48| 1|#define yyerror hex_yyerror ------------------ 1409| 1| STR(YR_STRING_CHAINING_THRESHOLD) 1410| 1| " not allowed inside alternation (|)"); 1411| | 1412| 1| YYABORT; ------------------ | | 744| 1|#define YYABORT goto yyabortlab ------------------ 1413| 1| } 1414| | 1415| 747| if ((yyvsp[-3].integer) < 0 || (yyvsp[-1].integer) < 0) ------------------ | Branch (1415:13): [True: 8, False: 739] | Branch (1415:40): [True: 0, False: 739] ------------------ 1416| 8| { 1417| 8| yyerror(yyscanner, lex_env, "invalid negative jump length"); ------------------ | | 48| 8|#define yyerror hex_yyerror ------------------ 1418| 8| YYABORT; ------------------ | | 744| 8|#define YYABORT goto yyabortlab ------------------ 1419| 8| } 1420| | 1421| 739| if ((yyvsp[-3].integer) > (yyvsp[-1].integer)) ------------------ | Branch (1421:13): [True: 0, False: 739] ------------------ 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| 739| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 739|#define RE_NODE_RANGE_ANY 21 ------------------ 1428| | 1429| 739| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 739| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 739] | | ------------------ | | 102| 739| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1430| | 1431| 739| (yyval.re_node)->start = (int) (yyvsp[-3].integer); 1432| 739| (yyval.re_node)->end = (int) (yyvsp[-1].integer); 1433| 739| } 1434| 0|#line 1435 "hex_grammar.c" 1435| 0| break; 1436| | 1437| 156| case 15: /* range: '[' _NUMBER_ '-' ']' */ ------------------ | Branch (1437:3): [True: 156, False: 331k] ------------------ 1438| 156|#line 260 "hex_grammar.y" 1439| 156| { 1440| 156| if (lex_env->inside_or) ------------------ | Branch (1440:13): [True: 15, False: 141] ------------------ 1441| 15| { 1442| 15| yyerror(yyscanner, lex_env, ------------------ | | 48| 15|#define yyerror hex_yyerror ------------------ 1443| 15| "unbounded jumps not allowed inside alternation (|)"); 1444| 15| YYABORT; ------------------ | | 744| 15|#define YYABORT goto yyabortlab ------------------ 1445| 15| } 1446| | 1447| 141| if ((yyvsp[-2].integer) < 0) ------------------ | Branch (1447:13): [True: 0, False: 141] ------------------ 1448| 0| { 1449| 0| yyerror(yyscanner, lex_env, "invalid negative jump length"); ------------------ | | 48| 0|#define yyerror hex_yyerror ------------------ 1450| 0| YYABORT; ------------------ | | 744| 0|#define YYABORT goto yyabortlab ------------------ 1451| 0| } 1452| | 1453| 141| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 141|#define RE_NODE_RANGE_ANY 21 ------------------ 1454| | 1455| 141| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 141| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 141] | | ------------------ | | 102| 141| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1456| | 1457| 141| (yyval.re_node)->start = (int) (yyvsp[-2].integer); 1458| 141| (yyval.re_node)->end = INT_MAX; 1459| 141| } 1460| 0|#line 1461 "hex_grammar.c" 1461| 0| break; 1462| | 1463| 290| case 16: /* range: '[' '-' ']' */ ------------------ | Branch (1463:3): [True: 290, False: 331k] ------------------ 1464| 290|#line 282 "hex_grammar.y" 1465| 290| { 1466| 290| if (lex_env->inside_or) ------------------ | Branch (1466:13): [True: 3, False: 287] ------------------ 1467| 3| { 1468| 3| yyerror(yyscanner, lex_env, ------------------ | | 48| 3|#define yyerror hex_yyerror ------------------ 1469| 3| "unbounded jumps not allowed inside alternation (|)"); 1470| 3| YYABORT; ------------------ | | 744| 3|#define YYABORT goto yyabortlab ------------------ 1471| 3| } 1472| | 1473| 287| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 287|#define RE_NODE_RANGE_ANY 21 ------------------ 1474| | 1475| 287| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 287| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 287] | | ------------------ | | 102| 287| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1476| | 1477| 287| (yyval.re_node)->start = 0; 1478| 287| (yyval.re_node)->end = INT_MAX; 1479| 287| } 1480| 0|#line 1481 "hex_grammar.c" 1481| 0| break; 1482| | 1483| 901| case 17: /* alternatives: tokens */ ------------------ | Branch (1483:3): [True: 901, False: 330k] ------------------ 1484| 901|#line 302 "hex_grammar.y" 1485| 901| { 1486| 901| (yyval.re_node) = (yyvsp[0].re_node); 1487| 901| } 1488| 901|#line 1489 "hex_grammar.c" 1489| 901| break; 1490| | 1491| 451| case 18: /* alternatives: alternatives '|' tokens */ ------------------ | Branch (1491:3): [True: 451, False: 331k] ------------------ 1492| 451|#line 306 "hex_grammar.y" 1493| 451| { 1494| 451| mark_as_not_fast_regexp(); ------------------ | | 98| 451| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 53| 451|#define yyget_extra hex_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 451|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1495| | 1496| 451| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 451|#define RE_NODE_ALT 5 ------------------ 1497| | 1498| 451| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 108| 451| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 451] | | ------------------ | | 109| 451| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1499| 451| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 108| 451| if (x) \ | | ------------------ | | | Branch (108:9): [True: 0, False: 451] | | ------------------ | | 109| 451| { \ | | 110| 0| yr_re_node_destroy(node); \ | | 111| 0| } \ ------------------ 1500| | 1501| 451| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 451| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 451] | | ------------------ | | 102| 451| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1502| | 1503| 451| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1504| 451| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1505| 451| } 1506| 0|#line 1507 "hex_grammar.c" 1507| 0| break; 1508| | 1509| 43.4k| case 19: /* byte: _BYTE_ */ ------------------ | Branch (1509:3): [True: 43.4k, False: 288k] ------------------ 1510| 43.4k|#line 323 "hex_grammar.y" 1511| 43.4k| { 1512| 43.4k| (yyval.re_node) = yr_re_node_create(RE_NODE_LITERAL); ------------------ | | 41| 43.4k|#define RE_NODE_LITERAL 1 ------------------ 1513| | 1514| 43.4k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 43.4k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 43.4k] | | ------------------ | | 102| 43.4k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1515| | 1516| 43.4k| (yyval.re_node)->value = (int) (yyvsp[0].integer); 1517| 43.4k| (yyval.re_node)->mask = 0xFF; 1518| 43.4k| } 1519| 0|#line 1520 "hex_grammar.c" 1520| 0| break; 1521| | 1522| 139| case 20: /* byte: _NOT_BYTE_ */ ------------------ | Branch (1522:3): [True: 139, False: 331k] ------------------ 1523| 139|#line 332 "hex_grammar.y" 1524| 139| { 1525| 139| (yyval.re_node) = yr_re_node_create(RE_NODE_NOT_LITERAL); ------------------ | | 62| 139|#define RE_NODE_NOT_LITERAL 22 ------------------ 1526| | 1527| 139| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 139| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 139] | | ------------------ | | 102| 139| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1528| | 1529| 139| (yyval.re_node)->value = (int) (yyvsp[0].integer); 1530| 139| (yyval.re_node)->mask = 0xFF; 1531| 139| } 1532| 0|#line 1533 "hex_grammar.c" 1533| 0| break; 1534| | 1535| 3.06k| case 21: /* byte: _MASKED_BYTE_ */ ------------------ | Branch (1535:3): [True: 3.06k, False: 328k] ------------------ 1536| 3.06k|#line 341 "hex_grammar.y" 1537| 3.06k| { 1538| 3.06k| uint8_t mask = (uint8_t) ((yyvsp[0].integer) >> 8); 1539| | 1540| 3.06k| if (mask == 0x00) ------------------ | Branch (1540:13): [True: 684, False: 2.38k] ------------------ 1541| 684| { 1542| 684| (yyval.re_node) = yr_re_node_create(RE_NODE_ANY); ------------------ | | 43| 684|#define RE_NODE_ANY 3 ------------------ 1543| | 1544| 684| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 684| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 684] | | ------------------ | | 102| 684| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1545| | 1546| 684| (yyval.re_node)->value = 0x00; 1547| 684| (yyval.re_node)->mask = 0x00; 1548| 684| } 1549| 2.38k| else 1550| 2.38k| { 1551| 2.38k| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_LITERAL); ------------------ | | 42| 2.38k|#define RE_NODE_MASKED_LITERAL 2 ------------------ 1552| | 1553| 2.38k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 2.38k| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 2.38k] | | ------------------ | | 102| 2.38k| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1554| | 1555| 2.38k| (yyval.re_node)->value = (yyvsp[0].integer) & 0xFF; 1556| 2.38k| (yyval.re_node)->mask = mask; 1557| 2.38k| } 1558| 3.06k| } 1559| 3.06k|#line 1560 "hex_grammar.c" 1560| 3.06k| break; 1561| | 1562| 3.06k| case 22: /* byte: _MASKED_NOT_BYTE_ */ ------------------ | Branch (1562:3): [True: 552, False: 330k] ------------------ 1563| 552|#line 364 "hex_grammar.y" 1564| 552| { 1565| 552| uint8_t mask = (uint8_t) ((yyvsp[0].integer) >> 8); 1566| | 1567| 552| (yyval.re_node) = yr_re_node_create(RE_NODE_MASKED_NOT_LITERAL); ------------------ | | 63| 552|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ 1568| | 1569| 552| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 101| 552| if (x) \ | | ------------------ | | | Branch (101:9): [True: 0, False: 552] | | ------------------ | | 102| 552| { \ | | 103| 0| lex_env->last_error = error; \ | | 104| 0| YYABORT; \ | | ------------------ | | | | 744| 0|#define YYABORT goto yyabortlab | | ------------------ | | 105| 0| } \ ------------------ 1570| | 1571| 552| (yyval.re_node)->value = (yyvsp[0].integer) & 0xFF; 1572| 552| (yyval.re_node)->mask = mask; 1573| 552| } 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: 331k] ------------------ 1581| 331k| } 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| 331k| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1594| | 1595| 331k| YYPOPSTACK (yylen); ------------------ | | 1045| 331k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1596| 331k| yylen = 0; 1597| | 1598| 331k| *++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| 331k| { 1604| 331k| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 561| 331k|#define YYNTOKENS 16 ------------------ 1605| 331k| const int yyi = yypgoto[yylhs] + *yyssp; 1606| 331k| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 558| 475k|#define YYLAST 35 ------------------ | Branch (1606:16): [True: 143k, False: 187k] | Branch (1606:28): [True: 143k, False: 452] | Branch (1606:45): [True: 92.9k, False: 50.3k] ------------------ 1607| 331k| ? yytable[yyi] 1608| 331k| : yydefgoto[yylhs]); 1609| 331k| } 1610| | 1611| 331k| goto yynewstate; 1612| | 1613| | 1614| |/*--------------------------------------. 1615| || yyerrlab -- here on detecting error. | 1616| |`--------------------------------------*/ 1617| 207|yyerrlab: 1618| | /* Make sure we have latest lookahead translation. See comments at 1619| | user semantic actions for why this is necessary. */ 1620| 207| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 50| 207|#define yychar hex_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 66| 207|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 576| 414| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 207|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 207, False: 0] | | | Branch (576:18): [True: 207, False: 0] | | ------------------ | | 577| 414| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 207|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 414| : YYSYMBOL_YYUNDEF) ------------------ | Branch (1620:13): [True: 0, False: 207] ------------------ 1621| | /* If not already recovering from an error, report this error. */ 1622| 207| if (!yyerrstatus) ------------------ | Branch (1622:7): [True: 207, False: 0] ------------------ 1623| 207| { 1624| 207| ++yynerrs; ------------------ | | 52| 207|#define yynerrs hex_yynerrs ------------------ 1625| 207| yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 48| 207|#define yyerror hex_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 360| 207|# define YY_(Msgid) Msgid ------------------ 1626| 207| } 1627| | 1628| 207| if (yyerrstatus == 3) ------------------ | Branch (1628:7): [True: 0, False: 207] ------------------ 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| 207| goto yyerrlab1; 1650| | 1651| | 1652| |/*---------------------------------------------------. 1653| || yyerrorlab -- error raised explicitly by YYERROR. | 1654| |`---------------------------------------------------*/ 1655| 207|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| 207|yyerrlab1: 1675| 207| yyerrstatus = 3; /* Each real token shifted decrements this. */ 1676| | 1677| | /* Pop stack until we find a state that shifts the error token. */ 1678| 207| for (;;) 1679| 149k| { 1680| 149k| yyn = yypact[yystate]; 1681| 149k| if (!yypact_value_is_default (yyn)) ------------------ | | 652| 149k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 649| 149k|#define YYPACT_NINF (-13) | | ------------------ ------------------ | Branch (1681:11): [True: 75.7k, False: 74.1k] ------------------ 1682| 75.7k| { 1683| 75.7k| yyn += YYSYMBOL_YYerror; 1684| 75.7k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 558| 150k|#define YYLAST 35 ------------------ | Branch (1684:15): [True: 75.0k, False: 782] | Branch (1684:27): [True: 75.0k, False: 0] | Branch (1684:44): [True: 0, False: 75.0k] ------------------ 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| 75.7k| } 1691| | 1692| | /* Pop the current state because it cannot handle the error token. */ 1693| 149k| if (yyssp == yyss) ------------------ | Branch (1693:11): [True: 207, False: 149k] ------------------ 1694| 207| YYABORT; ------------------ | | 744| 207|#define YYABORT goto yyabortlab ------------------ 1695| | 1696| | 1697| 149k| yydestruct ("Error: popping", 1698| 149k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, lex_env); ------------------ | | 624| 149k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 121| 149k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1699| 149k| YYPOPSTACK (1); ------------------ | | 1045| 149k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1700| 149k| yystate = *yyssp; 1701| 149k| YY_STACK_PRINT (yyss, yyssp); 1702| 149k| } 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| 824|yyacceptlab: 1720| 824| yyresult = 0; 1721| 824| goto yyreturnlab; 1722| | 1723| | 1724| |/*-----------------------------------. 1725| || yyabortlab -- YYABORT comes here. | 1726| |`-----------------------------------*/ 1727| 242|yyabortlab: 1728| 242| yyresult = 1; 1729| 242| goto yyreturnlab; 1730| | 1731| | 1732| |/*-----------------------------------------------------------. 1733| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 1734| |`-----------------------------------------------------------*/ 1735| 10|yyexhaustedlab: 1736| 10| yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 48| 10|#define yyerror hex_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("memory exhausted")); ------------------ | | 360| 10|# define YY_(Msgid) Msgid ------------------ 1737| 10| yyresult = 2; 1738| 10| goto yyreturnlab; 1739| | 1740| | 1741| |/*----------------------------------------------------------. 1742| || yyreturnlab -- parsing is finished, clean up and return. | 1743| |`----------------------------------------------------------*/ 1744| 1.07k|yyreturnlab: 1745| 1.07k| if (yychar != YYEMPTY) ------------------ | | 50| 1.07k|#define yychar hex_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 66| 1.07k|#define YYEMPTY -2 ------------------ | Branch (1745:7): [True: 207, False: 869] ------------------ 1746| 207| { 1747| | /* Make sure we have latest lookahead translation. See comments at 1748| | user semantic actions for why this is necessary. */ 1749| 207| yytoken = YYTRANSLATE (yychar); ------------------ | | 576| 207| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 570| 207|#define YYMAXUTOK 262 | | ------------------ | | | Branch (576:4): [True: 207, False: 0] | | | Branch (576:18): [True: 207, False: 0] | | ------------------ | | 577| 207| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 121| 207|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 578| 207| : YYSYMBOL_YYUNDEF) ------------------ 1750| 207| yydestruct ("Cleanup: discarding lookahead", 1751| 207| yytoken, &yylval, yyscanner, lex_env); 1752| 207| } 1753| | /* Do not reclaim the symbols of the rule whose action triggered 1754| | this YYABORT or YYACCEPT. */ 1755| 1.07k| YYPOPSTACK (yylen); ------------------ | | 1045| 1.07k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1756| 1.07k| YY_STACK_PRINT (yyss, yyssp); 1757| 122k| while (yyssp != yyss) ------------------ | Branch (1757:10): [True: 121k, False: 1.07k] ------------------ 1758| 121k| { 1759| 121k| yydestruct ("Cleanup: popping", 1760| 121k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, lex_env); ------------------ | | 624| 121k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 121| 121k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1761| 121k| YYPOPSTACK (1); ------------------ | | 1045| 121k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1762| 121k| } 1763| 1.07k|#ifndef yyoverflow 1764| 1.07k| if (yyss != yyssa) ------------------ | Branch (1764:7): [True: 111, False: 965] ------------------ 1765| 111| YYSTACK_FREE (yyss); ------------------ | | 468| 111|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 95| 111|#define YYFREE yr_free | | ------------------ ------------------ 1766| 1.07k|#endif 1767| | 1768| 1.07k| return yyresult; 1769| 207|} hex_grammar.c:yydestruct: 930| 271k|{ 931| 271k| YY_USE (yyvaluep); ------------------ | | 383| 271k|# define YY_USE(E) ((void) (E)) ------------------ 932| 271k| YY_USE (yyscanner); ------------------ | | 383| 271k|# define YY_USE(E) ((void) (E)) ------------------ 933| 271k| YY_USE (lex_env); ------------------ | | 383| 271k|# define YY_USE(E) ((void) (E)) ------------------ 934| 271k| if (!yymsg) ------------------ | Branch (934:7): [True: 0, False: 271k] ------------------ 935| 0| yymsg = "Deleting"; 936| 271k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 937| | 938| 271k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 939| 271k| switch (yykind) 940| 271k| { 941| 32| case YYSYMBOL_tokens: /* tokens */ ------------------ | Branch (941:5): [True: 32, False: 271k] ------------------ 942| 32|#line 96 "hex_grammar.y" 943| 32| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 944| 32|#line 945 "hex_grammar.c" 945| 32| break; 946| | 947| 294| case YYSYMBOL_token_sequence: /* token_sequence */ ------------------ | Branch (947:5): [True: 294, False: 271k] ------------------ 948| 294|#line 97 "hex_grammar.y" 949| 294| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 950| 294|#line 951 "hex_grammar.c" 951| 294| break; 952| | 953| 0| case YYSYMBOL_token_or_range: /* token_or_range */ ------------------ | Branch (953:5): [True: 0, False: 271k] ------------------ 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| 544| case YYSYMBOL_token: /* token */ ------------------ | Branch (959:5): [True: 544, False: 271k] ------------------ 960| 544|#line 99 "hex_grammar.y" 961| 544| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 962| 544|#line 963 "hex_grammar.c" 963| 544| break; 964| | 965| 0| case YYSYMBOL_range: /* range */ ------------------ | Branch (965:5): [True: 0, False: 271k] ------------------ 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| 197| case YYSYMBOL_alternatives: /* alternatives */ ------------------ | Branch (971:5): [True: 197, False: 271k] ------------------ 972| 197|#line 101 "hex_grammar.y" 973| 197| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 974| 197|#line 975 "hex_grammar.c" 975| 197| break; 976| | 977| 0| case YYSYMBOL_byte: /* byte */ ------------------ | Branch (977:5): [True: 0, False: 271k] ------------------ 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| 270k| default: ------------------ | Branch (983:7): [True: 270k, False: 1.06k] ------------------ 984| 270k| break; 985| 271k| } 986| 271k| YY_IGNORE_MAYBE_UNINITIALIZED_END 987| 271k|} hex_yylex: 1006| 196k|{ 1007| 196k| yy_state_type yy_current_state; 1008| 196k| char *yy_cp, *yy_bp; 1009| 196k| int yy_act; 1010| 196k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1011| | 1012| 196k| yylval = yylval_param; ------------------ | | 825| 196k| # define yylval yyg->yylval_r ------------------ 1013| | 1014| 196k| if ( !yyg->yy_init ) ------------------ | Branch (1014:7): [True: 1.07k, False: 195k] ------------------ 1015| 1.07k| { 1016| 1.07k| yyg->yy_init = 1; 1017| | 1018| |#ifdef YY_USER_INIT 1019| | YY_USER_INIT; 1020| |#endif 1021| | 1022| 1.07k| if ( ! yyg->yy_start ) ------------------ | Branch (1022:8): [True: 1.07k, False: 0] ------------------ 1023| 1.07k| yyg->yy_start = 1; /* first start state */ 1024| | 1025| 1.07k| if ( ! yyin ) ------------------ | | 344| 1.07k|#define yyin yyg->yyin_r ------------------ | Branch (1025:8): [True: 1.07k, False: 0] ------------------ 1026| 1.07k| yyin = stdin; ------------------ | | 344| 1.07k|#define yyin yyg->yyin_r ------------------ 1027| | 1028| 1.07k| if ( ! yyout ) ------------------ | | 345| 1.07k|#define yyout yyg->yyout_r ------------------ | Branch (1028:8): [True: 1.07k, False: 0] ------------------ 1029| 1.07k| yyout = stdout; ------------------ | | 345| 1.07k|#define yyout yyg->yyout_r ------------------ 1030| | 1031| 1.07k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : NULL) ------------------ | Branch (1031:8): [True: 0, False: 1.07k] ------------------ 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.07k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.07k|#define yy_load_buffer_state hex_yy_load_buffer_state ------------------ 1038| 1.07k| } 1039| | 1040| 196k| { 1041| 196k|#line 95 "hex_lexer.l" 1042| | 1043| | 1044| | 1045| 196k|#line 1046 "hex_lexer.c" 1046| | 1047| 456k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1047:23): [Folded - Ignored] ------------------ 1048| 456k| { 1049| 456k| yy_cp = yyg->yy_c_buf_p; 1050| | 1051| | /* Support of yytext. */ 1052| 456k| *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| 456k| yy_bp = yy_cp; 1058| | 1059| 456k| yy_current_state = yyg->yy_start; 1060| 456k|yy_match: 1061| 456k| do 1062| 968k| { 1063| 968k| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 968k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1064| 968k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1064:9): [True: 511k, False: 457k] ------------------ 1065| 511k| { 1066| 511k| yyg->yy_last_accepting_state = yy_current_state; 1067| 511k| yyg->yy_last_accepting_cpos = yy_cp; 1068| 511k| } 1069| 1.73M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1069:12): [True: 765k, False: 968k] ------------------ 1070| 765k| { 1071| 765k| yy_current_state = (int) yy_def[yy_current_state]; 1072| 765k| if ( yy_current_state >= 40 ) ------------------ | Branch (1072:10): [True: 308k, False: 456k] ------------------ 1073| 308k| yy_c = yy_meta[yy_c]; 1074| 765k| } 1075| 968k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1076| 968k| ++yy_cp; 1077| 968k| } 1078| 968k| while ( yy_current_state != 39 ); ------------------ | Branch (1078:11): [True: 511k, False: 456k] ------------------ 1079| 456k| yy_cp = yyg->yy_last_accepting_cpos; 1080| 456k| yy_current_state = yyg->yy_last_accepting_state; 1081| | 1082| 457k|yy_find_action: 1083| 457k| yy_act = yy_accept[yy_current_state]; 1084| | 1085| 457k| YY_DO_BEFORE_ACTION; ------------------ | | 578| 457k| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 457k|#define yytext_ptr yytext_r | | ------------------ | | 579| 457k| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 457k|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 457k| yyg->yy_hold_char = *yy_cp; \ | | 581| 457k| *yy_cp = '\0'; \ | | 582| 457k| yyg->yy_c_buf_p = yy_cp; ------------------ 1086| | 1087| 457k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 915k|#define YY_END_OF_BUFFER 24 ------------------ | Branch (1087:8): [True: 455k, False: 1.79k] | Branch (1087:38): [True: 259k, False: 195k] ------------------ 1088| 259k| { 1089| 259k| int yyl; 1090| 519k| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 519k|#define yyleng yyg->yyleng_r ------------------ | Branch (1090:19): [True: 259k, False: 259k] ------------------ 1091| 259k| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 259k|#define yytext yyg->yytext_r ------------------ | Branch (1091:10): [True: 20.0k, False: 239k] ------------------ 1092| | 1093| 20.0k| do{ yylineno++; ------------------ | | 349| 20.0k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 20.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1094| 20.0k| yycolumn=0; ------------------ | | 350| 20.0k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 20.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1095| 20.0k| }while(0) ------------------ | Branch (1095:12): [Folded - Ignored] ------------------ 1096| 259k|; 1097| 259k| } 1098| | 1099| 458k|do_action: /* This label is used only to access EOF actions. */ 1100| | 1101| 458k| switch ( yy_act ) 1102| 458k| { /* beginning of action switch */ 1103| 0| case 0: /* must back up */ ------------------ | Branch (1103:4): [True: 0, False: 458k] ------------------ 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| 43.4k|case 1: ------------------ | Branch (1110:1): [True: 43.4k, False: 414k] ------------------ 1111| 43.4k|YY_RULE_SETUP 1112| 43.4k|#line 98 "hex_lexer.l" 1113| 43.4k|{ 1114| | 1115| 43.4k| yylval->integer = xtoi(yytext); ------------------ | | 825| 43.4k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext); ------------------ | | 348| 43.4k|#define yytext yyg->yytext_r ------------------ 1116| 43.4k| return _BYTE_; ------------------ | | 70| 43.4k|#define _BYTE_ 258 ------------------ 1117| 0|} 1118| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1119| 1.05k|case 2: ------------------ | Branch (1119:1): [True: 1.05k, False: 457k] ------------------ 1120| 1.05k|YY_RULE_SETUP 1121| 1.05k|#line 104 "hex_lexer.l" 1122| 1.05k|{ 1123| | 1124| 1.05k| yytext[1] = '0'; // replace ? by 0 ------------------ | | 348| 1.05k|#define yytext yyg->yytext_r ------------------ 1125| 1.05k| yylval->integer = xtoi(yytext) | 0xF000 ; ------------------ | | 825| 1.05k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext) | 0xF000 ; ------------------ | | 348| 1.05k|#define yytext yyg->yytext_r ------------------ 1126| 1.05k| return _MASKED_BYTE_; ------------------ | | 71| 1.05k|#define _MASKED_BYTE_ 259 ------------------ 1127| 0|} 1128| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1129| 139|case 3: ------------------ | Branch (1129:1): [True: 139, False: 458k] ------------------ 1130| 139|YY_RULE_SETUP 1131| 139|#line 111 "hex_lexer.l" 1132| 139|{ 1133| | 1134| 139| yylval->integer = xtoi(&(yytext[1])); ------------------ | | 825| 139| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])); ------------------ | | 348| 139|#define yytext yyg->yytext_r ------------------ 1135| 139| return _NOT_BYTE_; ------------------ | | 72| 139|#define _NOT_BYTE_ 260 ------------------ 1136| 0|} 1137| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1138| 1.32k|case 4: ------------------ | Branch (1138:1): [True: 1.32k, False: 457k] ------------------ 1139| 1.32k|YY_RULE_SETUP 1140| 1.32k|#line 117 "hex_lexer.l" 1141| 1.32k|{ 1142| | 1143| 1.32k| yytext[0] = '0'; // replace ? by 0 ------------------ | | 348| 1.32k|#define yytext yyg->yytext_r ------------------ 1144| 1.32k| yylval->integer = xtoi(yytext) | 0x0F00 ; ------------------ | | 825| 1.32k| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(yytext) | 0x0F00 ; ------------------ | | 348| 1.32k|#define yytext yyg->yytext_r ------------------ 1145| 1.32k| return _MASKED_BYTE_; ------------------ | | 71| 1.32k|#define _MASKED_BYTE_ 259 ------------------ 1146| 0|} 1147| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1148| 684|case 5: ------------------ | Branch (1148:1): [True: 684, False: 457k] ------------------ 1149| 684|YY_RULE_SETUP 1150| 684|#line 124 "hex_lexer.l" 1151| 684|{ 1152| | 1153| 684| yylval->integer = 0x0000; ------------------ | | 825| 684| # define yylval yyg->yylval_r ------------------ 1154| 684| return _MASKED_BYTE_; ------------------ | | 71| 684|#define _MASKED_BYTE_ 259 ------------------ 1155| 0|} 1156| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1157| 185|case 6: ------------------ | Branch (1157:1): [True: 185, False: 458k] ------------------ 1158| 185|YY_RULE_SETUP 1159| 185|#line 130 "hex_lexer.l" 1160| 185|{ 1161| | 1162| 185| yytext[2] = '0'; // replace ? by 0 ------------------ | | 348| 185|#define yytext yyg->yytext_r ------------------ 1163| 185| yylval->integer = xtoi(&(yytext[1])) | 0xF000 ; ------------------ | | 825| 185| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])) | 0xF000 ; ------------------ | | 348| 185|#define yytext yyg->yytext_r ------------------ 1164| 185| return _MASKED_NOT_BYTE_; ------------------ | | 73| 185|#define _MASKED_NOT_BYTE_ 261 ------------------ 1165| 0|} 1166| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1167| 367|case 7: ------------------ | Branch (1167:1): [True: 367, False: 457k] ------------------ 1168| 367|YY_RULE_SETUP 1169| 367|#line 137 "hex_lexer.l" 1170| 367|{ 1171| | 1172| 367| yytext[1] = '0'; // replace ? by 0 ------------------ | | 348| 367|#define yytext yyg->yytext_r ------------------ 1173| 367| yylval->integer = xtoi(&(yytext[1])) | 0x0F00 ; ------------------ | | 825| 367| # define yylval yyg->yylval_r ------------------ yylval->integer = xtoi(&(yytext[1])) | 0x0F00 ; ------------------ | | 348| 367|#define yytext yyg->yytext_r ------------------ 1174| 367| return _MASKED_NOT_BYTE_; ------------------ | | 73| 367|#define _MASKED_NOT_BYTE_ 261 ------------------ 1175| 0|} 1176| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1177| 24|case 8: ------------------ | Branch (1177:1): [True: 24, False: 458k] ------------------ 1178| 24|YY_RULE_SETUP 1179| 24|#line 144 "hex_lexer.l" 1180| 24|{ 1181| | 1182| 24| yyerror(yyscanner, lex_env, "uneven number of digits in hex string"); ------------------ | | 48| 24|#define yyerror hex_yyerror ------------------ 1183| 24| yyterminate(); ------------------ | | 960| 24|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 24|#define YY_NULL 0 | | ------------------ ------------------ 1184| 0|} 1185| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1186| 1|case 9: ------------------ | Branch (1186:1): [True: 1, False: 458k] ------------------ 1187| 1|YY_RULE_SETUP 1188| 1|#line 150 "hex_lexer.l" 1189| 1|{ 1190| | 1191| 1| yyerror(yyscanner, lex_env, "invalid not operator (~) in hex string"); ------------------ | | 48| 1|#define yyerror hex_yyerror ------------------ 1192| 1| yyterminate(); ------------------ | | 960| 1|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1|#define YY_NULL 0 | | ------------------ ------------------ 1193| 0|} 1194| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1195| 2.77k|case 10: ------------------ | Branch (1195:1): [True: 2.77k, False: 455k] ------------------ 1196| 2.77k|YY_RULE_SETUP 1197| 2.77k|#line 157 "hex_lexer.l" 1198| 2.77k|{ 1199| | 1200| 2.77k| BEGIN(range); ------------------ | | 357| 2.77k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(range); ------------------ | | 771| 2.77k|#define range 2 ------------------ 1201| 2.77k| return yytext[0]; ------------------ | | 348| 2.77k|#define yytext yyg->yytext_r ------------------ 1202| 0|} 1203| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1204| 149|case 11: ------------------ | Branch (1204:1): [True: 149, False: 458k] ------------------ 1205| 149|YY_RULE_SETUP 1206| 149|#line 163 "hex_lexer.l" 1207| 149|{ 1208| | 1209| 149| BEGIN(comment); ------------------ | | 357| 149|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(comment); ------------------ | | 770| 149|#define comment 1 ------------------ 1210| 149|} 1211| 149| YY_BREAK ------------------ | | 997| 149|#define YY_BREAK /*LINTED*/break; ------------------ 1212| 149|case 12: ------------------ | Branch (1212:1): [True: 149, False: 458k] ------------------ 1213| 149|YY_RULE_SETUP 1214| 149|#line 168 "hex_lexer.l" 1215| 149|{ 1216| | 1217| 149| BEGIN(INITIAL); ------------------ | | 357| 149|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 769| 149|#define INITIAL 0 ------------------ 1218| 149|} 1219| 149| YY_BREAK ------------------ | | 997| 149|#define YY_BREAK /*LINTED*/break; ------------------ 1220| 258k|case 13: ------------------ | Branch (1220:1): [True: 258k, False: 199k] ------------------ 1221| |/* rule 13 can match eol */ 1222| 258k|YY_RULE_SETUP 1223| 258k|#line 173 "hex_lexer.l" 1224| |// skip comments 1225| 258k| YY_BREAK ------------------ | | 997| 258k|#define YY_BREAK /*LINTED*/break; ------------------ 1226| 129|case 14: ------------------ | Branch (1226:1): [True: 129, False: 458k] ------------------ 1227| 129|YY_RULE_SETUP 1228| 129|#line 175 "hex_lexer.l" 1229| |// skip single-line comments 1230| 129| YY_BREAK ------------------ | | 997| 129|#define YY_BREAK /*LINTED*/break; ------------------ 1231| 1.19k|case 15: ------------------ | Branch (1231:1): [True: 1.19k, False: 457k] ------------------ 1232| 1.19k|YY_RULE_SETUP 1233| 1.19k|#line 177 "hex_lexer.l" 1234| 1.19k|{ 1235| | 1236| 1.19k| return yytext[0]; ------------------ | | 348| 1.19k|#define yytext yyg->yytext_r ------------------ 1237| 0|} 1238| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1239| 3.23k|case 16: ------------------ | Branch (1239:1): [True: 3.23k, False: 455k] ------------------ 1240| 3.23k|YY_RULE_SETUP 1241| 3.23k|#line 182 "hex_lexer.l" 1242| 3.23k|{ 1243| | 1244| 3.23k| yylval->integer = atoi(yytext); ------------------ | | 825| 3.23k| # define yylval yyg->yylval_r ------------------ yylval->integer = atoi(yytext); ------------------ | | 348| 3.23k|#define yytext yyg->yytext_r ------------------ 1245| 3.23k| return _NUMBER_; ------------------ | | 74| 3.23k|#define _NUMBER_ 262 ------------------ 1246| 0|} 1247| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1248| 2.77k|case 17: ------------------ | Branch (1248:1): [True: 2.77k, False: 455k] ------------------ 1249| 2.77k|YY_RULE_SETUP 1250| 2.77k|#line 188 "hex_lexer.l" 1251| 2.77k|{ 1252| | 1253| 2.77k| BEGIN(INITIAL); ------------------ | | 357| 2.77k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 769| 2.77k|#define INITIAL 0 ------------------ 1254| 2.77k| return yytext[0]; ------------------ | | 348| 2.77k|#define yytext yyg->yytext_r ------------------ 1255| 0|} 1256| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1257| 352|case 18: ------------------ | Branch (1257:1): [True: 352, False: 457k] ------------------ 1258| |/* rule 18 can match eol */ 1259| 352|YY_RULE_SETUP 1260| 352|#line 194 "hex_lexer.l" 1261| |// skip whitespaces 1262| 352| YY_BREAK ------------------ | | 997| 352|#define YY_BREAK /*LINTED*/break; ------------------ 1263| 4|case 19: ------------------ | Branch (1263:1): [True: 4, False: 458k] ------------------ 1264| 4|YY_RULE_SETUP 1265| 4|#line 196 "hex_lexer.l" 1266| 4|{ 1267| | 1268| 4| yyerror(yyscanner, lex_env, "invalid character in hex string jump"); ------------------ | | 48| 4|#define yyerror hex_yyerror ------------------ 1269| 4| yyterminate(); ------------------ | | 960| 4|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 4|#define YY_NULL 0 | | ------------------ ------------------ 1270| 0|} 1271| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1272| 488|case 20: ------------------ | Branch (1272:1): [True: 488, False: 457k] ------------------ 1273| |/* rule 20 can match eol */ 1274| 488|YY_RULE_SETUP 1275| 488|#line 202 "hex_lexer.l" 1276| |// skip whitespaces 1277| 488| YY_BREAK ------------------ | | 997| 488|#define YY_BREAK /*LINTED*/break; ------------------ 1278| 138k|case 21: ------------------ | Branch (1278:1): [True: 138k, False: 320k] ------------------ 1279| 138k|YY_RULE_SETUP 1280| 138k|#line 204 "hex_lexer.l" 1281| 138k|{ // pass valid characters to the parser 1282| | 1283| 138k| return yytext[0]; ------------------ | | 348| 138k|#define yytext yyg->yytext_r ------------------ 1284| 0|} 1285| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1286| 2|case 22: ------------------ | Branch (1286:1): [True: 2, False: 458k] ------------------ 1287| 2|YY_RULE_SETUP 1288| 2|#line 209 "hex_lexer.l" 1289| 2|{ // reject all other characters 1290| | 1291| 2| yyerror(yyscanner, lex_env, "invalid character in hex string"); ------------------ | | 48| 2|#define yyerror hex_yyerror ------------------ 1292| 2| yyterminate(); ------------------ | | 960| 2|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 2|#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: 458k] ------------------ 1296| 0|YY_RULE_SETUP 1297| 0|#line 215 "hex_lexer.l" 1298| 0|ECHO; ------------------ | | 916| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 348| 0|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 347| 0|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 345| 0|#define yyout yyg->yyout_r | | ------------------ | | | Branch (916:23): [True: 0, False: 0] | | | Branch (916:80): [Folded - Ignored] | | ------------------ ------------------ 1299| 0| YY_BREAK ------------------ | | 997| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1300| 0|#line 1301 "hex_lexer.c" 1301| 824|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 824|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 824|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1301:1): [True: 824, False: 457k] ------------------ 1302| 824|case YY_STATE_EOF(comment): ------------------ | | 365| 824|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 824|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1302:1): [True: 0, False: 458k] ------------------ 1303| 824|case YY_STATE_EOF(range): ------------------ | | 365| 824|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 824|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ | Branch (1303:1): [True: 0, False: 458k] ------------------ 1304| 824| yyterminate(); ------------------ | | 960| 824|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 824|#define YY_NULL 0 | | ------------------ ------------------ 1305| | 1306| 1.79k| case YY_END_OF_BUFFER: ------------------ | | 584| 1.79k|#define YY_END_OF_BUFFER 24 ------------------ | Branch (1306:2): [True: 1.79k, False: 456k] ------------------ 1307| 1.79k| { 1308| | /* Amount of text matched not including the EOB char. */ 1309| 1.79k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 1.79k|#define yytext_ptr yytext_r ------------------ 1310| | 1311| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1312| 1.79k| *yy_cp = yyg->yy_hold_char; 1313| 1.79k| YY_RESTORE_YY_MORE_OFFSET 1314| | 1315| 1.79k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 1.79k|#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| 1.79k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1315:8): [True: 971, False: 824] ------------------ 1316| 971| { 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| 971| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 971|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1327| 971| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 971|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 971|#define yyin yyg->yyin_r ------------------ 1328| 971| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 971|#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| 971|#define YY_BUFFER_NORMAL 1 ------------------ 1329| 971| } 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| 1.79k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 1.79k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1338:8): [True: 0, False: 1.79k] ------------------ 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| 1.79k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1375:17): [True: 0, False: 1.79k] ------------------ 1376| 1.79k| { 1377| 824| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 824|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1377:4): [True: 824, False: 971] ------------------ 1378| 824| { 1379| 824| yyg->yy_did_buffer_switch_on_eof = 0; 1380| | 1381| 824| if ( yywrap( yyscanner ) ) ------------------ | | 206| 824|#define yywrap hex_yywrap | | ------------------ | | | | 561| 824|#define hex_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:31): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1382| 824| { 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| 824| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 824|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 824|#define YY_MORE_ADJ 0 ------------------ 1393| | 1394| 824| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 824|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 824|#define YY_END_OF_BUFFER 24 | | ------------------ ------------------ 1395| 824| goto do_action; 1396| 824| } 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| 824| } 1405| | 1406| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1406:4): [True: 0, False: 1.79k] ------------------ 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| 971| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 971|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1416:4): [True: 971, False: 824] ------------------ 1417| 971| yyg->yy_c_buf_p = 1418| 971| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 971|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1419| | 1420| 971| yy_current_state = yy_get_previous_state( yyscanner ); 1421| | 1422| 971| yy_cp = yyg->yy_c_buf_p; 1423| 971| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 971|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 691| 971|#define YY_MORE_ADJ 0 ------------------ 1424| 971| goto yy_find_action; 1425| 1.79k| } 1426| 0| break; 1427| 1.79k| } 1428| | 1429| 0| default: ------------------ | Branch (1429:2): [True: 0, False: 458k] ------------------ 1430| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1431| 458k| "fatal flex scanner internal error--no action found" ); 1432| 458k| } /* end of action switch */ 1433| 458k| } /* end of scanning one token */ 1434| 196k| } /* end of user's declarations */ 1435| 196k|} /* end of yylex */ hex_yy_switch_to_buffer: 1751| 1.07k|{ 1752| 1.07k| 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.07k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 1.07k|#define yyensure_buffer_stack hex_yyensure_buffer_stack ------------------ 1760| 1.07k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : NULL) ------------------ | Branch (1760:7): [True: 0, False: 1.07k] ------------------ 1761| 0| return; 1762| | 1763| 1.07k| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1.07k] | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : 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.07k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 1.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1772| 1.07k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.07k|#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.07k| yyg->yy_did_buffer_switch_on_eof = 1; 1780| 1.07k|} hex_yy_delete_buffer: 1826| 1.07k|{ 1827| 1.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1828| | 1829| 1.07k| if ( ! b ) ------------------ | Branch (1829:7): [True: 0, False: 1.07k] ------------------ 1830| 0| return; 1831| | 1832| 1.07k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : NULL) ------------------ | Branch (1832:7): [True: 1.07k, False: 0] ------------------ 1833| 1.07k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 1.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1834| | 1835| 1.07k| if ( b->yy_is_our_buffer ) ------------------ | Branch (1835:7): [True: 1.07k, False: 0] ------------------ 1836| 1.07k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 1.07k|#define yyfree hex_yyfree ------------------ 1837| | 1838| 1.07k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 1.07k|#define yyfree hex_yyfree ------------------ 1839| 1.07k|} hex_yypop_buffer_state: 1936| 1.07k|{ 1937| 1.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1938| 1.07k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : NULL) ------------------ | Branch (1938:6): [True: 1.07k, False: 0] ------------------ 1939| 1.07k| 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.07k|{ 2007| 1.07k| YY_BUFFER_STATE b; 2008| | 2009| 1.07k| if ( size < 2 || ------------------ | Branch (2009:7): [True: 0, False: 1.07k] ------------------ 2010| 1.07k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 2.15k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2010:7): [True: 0, False: 1.07k] ------------------ 2011| 1.07k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 1.07k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2011:7): [True: 0, False: 1.07k] ------------------ 2012| | /* They forgot to leave room for the EOB's. */ 2013| 0| return NULL; 2014| | 2015| 1.07k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 1.07k|#define yyalloc hex_yyalloc ------------------ 2016| 1.07k| if ( ! b ) ------------------ | Branch (2016:7): [True: 0, False: 1.07k] ------------------ 2017| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 2018| | 2019| 1.07k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2020| 1.07k| b->yy_buf_pos = b->yy_ch_buf = base; 2021| 1.07k| b->yy_is_our_buffer = 0; 2022| 1.07k| b->yy_input_file = NULL; 2023| 1.07k| b->yy_n_chars = b->yy_buf_size; 2024| 1.07k| b->yy_is_interactive = 0; 2025| 1.07k| b->yy_at_bol = 1; 2026| 1.07k| b->yy_fill_buffer = 0; 2027| 1.07k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 1.07k|#define YY_BUFFER_NEW 0 ------------------ 2028| | 2029| 1.07k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 1.07k|#define yy_switch_to_buffer hex_yy_switch_to_buffer ------------------ 2030| | 2031| 1.07k| return b; 2032| 1.07k|} hex_yy_scan_string: 2043| 1.07k|{ 2044| | 2045| 1.07k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 1.07k|#define yy_scan_bytes hex_yy_scan_bytes ------------------ 2046| 1.07k|} hex_yy_scan_bytes: 2056| 1.07k|{ 2057| 1.07k| YY_BUFFER_STATE b; 2058| 1.07k| char *buf; 2059| 1.07k| yy_size_t n; 2060| 1.07k| int i; 2061| | 2062| | /* Get memory for full buffer, including space for trailing EOB's. */ 2063| 1.07k| n = (yy_size_t) (_yybytes_len + 2); 2064| 1.07k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 1.07k|#define yyalloc hex_yyalloc ------------------ 2065| 1.07k| if ( ! buf ) ------------------ | Branch (2065:7): [True: 0, False: 1.07k] ------------------ 2066| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 2067| | 2068| 513k| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2068:15): [True: 512k, False: 1.07k] ------------------ 2069| 512k| buf[i] = yybytes[i]; 2070| | 2071| 1.07k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 1.07k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2072| | 2073| 1.07k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 1.07k|#define yy_scan_buffer hex_yy_scan_buffer ------------------ 2074| 1.07k| if ( ! b ) ------------------ | Branch (2074:7): [True: 0, False: 1.07k] ------------------ 2075| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 80| 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.07k| b->yy_is_our_buffer = 1; 2081| | 2082| 1.07k| return b; 2083| 1.07k|} hex_yyget_extra: 2120| 1.27k|{ 2121| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2122| 1.27k| return yyextra; ------------------ | | 346| 1.27k|#define yyextra yyg->yyextra_r ------------------ 2123| 1.27k|} hex_yyset_extra: 2193| 1.07k|{ 2194| 1.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2195| 1.07k| yyextra = user_defined ; ------------------ | | 346| 1.07k|#define yyextra yyg->yyextra_r ------------------ 2196| 1.07k|} hex_yylex_init: 2279| 1.07k|{ 2280| 1.07k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2280:9): [True: 0, False: 1.07k] ------------------ 2281| 0| errno = EINVAL; 2282| 0| return 1; 2283| 0| } 2284| | 2285| 1.07k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 1.07k|#define yyalloc hex_yyalloc ------------------ 2286| | 2287| 1.07k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2287:9): [True: 0, False: 1.07k] ------------------ 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.07k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2294| | 2295| 1.07k| return yy_init_globals ( *ptr_yy_globals ); 2296| 1.07k|} hex_yylex_destroy: 2367| 1.07k|{ 2368| 1.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2369| | 2370| | /* Pop the buffer stack, destroying each element. */ 2371| 2.15k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 2.15k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 1.07k, False: 1.07k] | | | Branch (509:29): [True: 2.15k, False: 0] | | ------------------ | | 510| 2.15k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 2.15k| : NULL) ------------------ 2372| 1.07k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 1.07k|#define yy_delete_buffer hex_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 1.07k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.07k, False: 0] | | ------------------ | | 510| 1.07k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.07k| : NULL) ------------------ 2373| 1.07k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 1.07k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2374| 1.07k| yypop_buffer_state(yyscanner); ------------------ | | 80| 1.07k|#define yypop_buffer_state hex_yypop_buffer_state ------------------ 2375| 1.07k| } 2376| | 2377| | /* Destroy the stack itself. */ 2378| 1.07k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 1.07k|#define yyfree hex_yyfree ------------------ 2379| 1.07k| yyg->yy_buffer_stack = NULL; 2380| | 2381| | /* Destroy the start condition stack. */ 2382| 1.07k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 1.07k|#define yyfree hex_yyfree ------------------ 2383| 1.07k| 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.07k| yy_init_globals( yyscanner); 2388| | 2389| | /* Destroy the main struct (reentrant only). */ 2390| 1.07k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 1.07k|#define yyfree hex_yyfree ------------------ 2391| 1.07k| yyscanner = NULL; 2392| 1.07k| return 0; 2393| 1.07k|} hex_yyalloc: 2423| 4.30k|{ 2424| 4.30k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2425| 4.30k| (void)yyg; 2426| 4.30k| return malloc(size); 2427| 4.30k|} hex_yyfree: 2445| 5.38k|{ 2446| 5.38k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2447| 5.38k| (void)yyg; 2448| 5.38k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2449| 5.38k|} hex_yyerror: 2477| 283|{ 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| 283| if (lex_env->last_error == ERROR_SUCCESS) ------------------ | | 40| 283|#define ERROR_SUCCESS 0 ------------------ | Branch (2483:7): [True: 252, False: 31] ------------------ 2484| 252| { 2485| 252| lex_env->last_error = ERROR_INVALID_HEX_STRING; ------------------ | | 55| 252|#define ERROR_INVALID_HEX_STRING 10 ------------------ 2486| | 2487| 252| strlcpy( 2488| 252| lex_env->last_error_message, 2489| 252| error_message, 2490| 252| sizeof(lex_env->last_error_message)); 2491| 252| } 2492| 283|} yr_parse_hex_string: 2499| 1.07k|{ 2500| 1.07k| yyscan_t yyscanner; 2501| 1.07k| jmp_buf recovery_trampoline; 2502| 1.07k| HEX_LEX_ENVIRONMENT lex_env; 2503| | 2504| 1.07k| lex_env.last_error = ERROR_SUCCESS; ------------------ | | 40| 1.07k|#define ERROR_SUCCESS 0 ------------------ 2505| 1.07k| lex_env.inside_or = 0; 2506| | 2507| 1.07k| yr_thread_storage_set_value( 2508| 1.07k| &yr_yyfatal_trampoline_tls, 2509| 1.07k| &recovery_trampoline); 2510| | 2511| 1.07k| if (setjmp(recovery_trampoline) != 0) ------------------ | Branch (2511:7): [True: 0, False: 1.07k] ------------------ 2512| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 2513| | 2514| 1.07k| FAIL_ON_ERROR(yr_re_ast_create(re_ast)); ------------------ | | 131| 1.07k| { \ | | 132| 1.07k| int __error = (x); \ | | 133| 1.07k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.07k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.07k] | | ------------------ | | 134| 1.07k| return __error; \ | | 135| 1.07k| } ------------------ 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.07k| (*re_ast)->flags |= RE_FLAGS_FAST_REGEXP; ------------------ | | 94| 1.07k|#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.07k| (*re_ast)->flags |= RE_FLAGS_DOT_ALL; ------------------ | | 100| 1.07k|#define RE_FLAGS_DOT_ALL 0x80 ------------------ 2530| | 2531| 1.07k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 1.07k|#define yylex_init hex_yylex_init ------------------ | Branch (2531:7): [True: 0, False: 1.07k] ------------------ 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.07k| yyset_extra(*re_ast, yyscanner); ------------------ | | 140| 1.07k|#define yyset_extra hex_yyset_extra ------------------ 2539| 1.07k| yy_scan_string(hex_string, yyscanner); ------------------ | | 38| 1.07k|#define yy_scan_string hex_yy_scan_string ------------------ 2540| 1.07k| yyparse(yyscanner, &lex_env); ------------------ | | 46| 1.07k|#define yyparse hex_yyparse ------------------ 2541| 1.07k| yylex_destroy(yyscanner); ------------------ | | 116| 1.07k|#define yylex_destroy hex_yylex_destroy ------------------ 2542| | 2543| 1.07k| if (lex_env.last_error != ERROR_SUCCESS) ------------------ | | 40| 1.07k|#define ERROR_SUCCESS 0 ------------------ | Branch (2543:7): [True: 252, False: 824] ------------------ 2544| 252| { 2545| 252| strlcpy(error->message, lex_env.last_error_message, sizeof(error->message)); 2546| 252| return lex_env.last_error; 2547| 252| } 2548| | 2549| 824| return ERROR_SUCCESS; ------------------ | | 40| 824|#define ERROR_SUCCESS 0 ------------------ 2550| 1.07k|} hex_lexer.c:yy_get_next_buffer: 1445| 1.79k|{ 1446| 1.79k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1447| 1.79k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 1.79k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1448| 1.79k| char *source = yyg->yytext_ptr; ------------------ | | 567| 1.79k|#define yytext_ptr yytext_r ------------------ 1449| 1.79k| int number_to_move, i; 1450| 1.79k| int ret_val; 1451| | 1452| 1.79k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 1.79k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1452:7): [True: 0, False: 1.79k] ------------------ 1453| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1454| 1.79k| "fatal flex scanner internal error--end of buffer missed" ); 1455| | 1456| 1.79k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 1.79k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1456:7): [True: 1.79k, False: 0] ------------------ 1457| 1.79k| { /* Don't try to fill the buffer, so this is an EOF. */ 1458| 1.79k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 1.79k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 691| 1.79k|#define YY_MORE_ADJ 0 ------------------ | Branch (1458:8): [True: 824, False: 971] ------------------ 1459| 824| { 1460| | /* We matched a single character, the EOB, so 1461| | * treat this as a final EOF. 1462| | */ 1463| 824| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 824|#define EOB_ACT_END_OF_FILE 1 ------------------ 1464| 824| } 1465| | 1466| 971| else 1467| 971| { 1468| | /* We matched some text prior to the EOB, first 1469| | * process it. 1470| | */ 1471| 971| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 971|#define EOB_ACT_LAST_MATCH 2 ------------------ 1472| 971| } 1473| 1.79k| } 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( ------------------ | | 80| 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" ); \ | | ------------------ | | | | 80| 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" ); \ | | ------------------ | | | | 80| 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()" ); ------------------ | | 80| 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| 1.79k|} hex_lexer.c:yy_get_previous_state: 1584| 971|{ 1585| 971| yy_state_type yy_current_state; 1586| 971| char *yy_cp; 1587| 971| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1588| | 1589| 971| yy_current_state = yyg->yy_start; 1590| | 1591| 1.94k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 971|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 691| 971|#define YY_MORE_ADJ 0 ------------------ | Branch (1591:47): [True: 971, False: 971] ------------------ 1592| 971| { 1593| 971| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 971|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1593:19): [True: 971, False: 0] ------------------ 1594| 971| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1594:8): [True: 0, False: 971] ------------------ 1595| 0| { 1596| 0| yyg->yy_last_accepting_state = yy_current_state; 1597| 0| yyg->yy_last_accepting_cpos = yy_cp; 1598| 0| } 1599| 972| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1599:11): [True: 1, False: 971] ------------------ 1600| 1| { 1601| 1| yy_current_state = (int) yy_def[yy_current_state]; 1602| 1| if ( yy_current_state >= 40 ) ------------------ | Branch (1602:9): [True: 1, False: 0] ------------------ 1603| 1| yy_c = yy_meta[yy_c]; 1604| 1| } 1605| 971| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1606| 971| } 1607| | 1608| 971| return yy_current_state; 1609| 971|} hex_lexer.c:hex_yy_load_buffer_state: 1783| 2.15k|{ 1784| 2.15k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1785| 2.15k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1786| 2.15k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 2.15k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1787| 2.15k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 2.15k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 2.15k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1788| 2.15k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 1789| 2.15k|} hex_lexer.c:hex_yyensure_buffer_stack: 1956| 1.07k|{ 1957| 1.07k| yy_size_t num_to_alloc; 1958| 1.07k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1959| | 1960| 1.07k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (1960:6): [True: 1.07k, 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.07k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 1967| 1.07k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 1.07k|#define yyalloc hex_yyalloc ------------------ 1968| 1.07k| (num_to_alloc * sizeof(struct yy_buffer_state*) 1969| 1.07k| , yyscanner); 1970| 1.07k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (1970:8): [True: 0, False: 1.07k] ------------------ 1971| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) hex_yyfatal(yyscanner, msg) ------------------ 1972| | 1973| 1.07k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 1974| | 1975| 1.07k| yyg->yy_buffer_stack_max = num_to_alloc; 1976| 1.07k| yyg->yy_buffer_stack_top = 0; 1977| 1.07k| return; 1978| 1.07k| } 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()" ); ------------------ | | 80| 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.15k|{ 2334| 2.15k| 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.15k| yyg->yy_buffer_stack = NULL; 2340| 2.15k| yyg->yy_buffer_stack_top = 0; 2341| 2.15k| yyg->yy_buffer_stack_max = 0; 2342| 2.15k| yyg->yy_c_buf_p = NULL; 2343| 2.15k| yyg->yy_init = 0; 2344| 2.15k| yyg->yy_start = 0; 2345| | 2346| 2.15k| yyg->yy_start_stack_ptr = 0; 2347| 2.15k| yyg->yy_start_stack_depth = 0; 2348| 2.15k| 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.15k| yyin = NULL; ------------------ | | 344| 2.15k|#define yyin yyg->yyin_r ------------------ 2356| 2.15k| yyout = NULL; ------------------ | | 345| 2.15k|#define yyout yyg->yyout_r ------------------ 2357| 2.15k|#endif 2358| | 2359| | /* For future reference: Set errno on error, since we are called by 2360| | * yylex_init() 2361| | */ 2362| 2.15k| return 0; 2363| 2.15k|} yara_yylex: 1278| 351k|{ 1279| 351k| yy_state_type yy_current_state; 1280| 351k| char *yy_cp, *yy_bp; 1281| 351k| int yy_act; 1282| 351k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1283| | 1284| 351k| yylval = yylval_param; ------------------ | | 1097| 351k| # define yylval yyg->yylval_r ------------------ 1285| | 1286| 351k| if ( !yyg->yy_init ) ------------------ | Branch (1286:7): [True: 1.27k, False: 350k] ------------------ 1287| 1.27k| { 1288| 1.27k| yyg->yy_init = 1; 1289| | 1290| |#ifdef YY_USER_INIT 1291| | YY_USER_INIT; 1292| |#endif 1293| | 1294| 1.27k| if ( ! yyg->yy_start ) ------------------ | Branch (1294:8): [True: 1.27k, False: 0] ------------------ 1295| 1.27k| yyg->yy_start = 1; /* first start state */ 1296| | 1297| 1.27k| if ( ! yyin ) ------------------ | | 344| 1.27k|#define yyin yyg->yyin_r ------------------ | Branch (1297:8): [True: 1.27k, False: 0] ------------------ 1298| 1.27k| yyin = stdin; ------------------ | | 344| 1.27k|#define yyin yyg->yyin_r ------------------ 1299| | 1300| 1.27k| if ( ! yyout ) ------------------ | | 345| 1.27k|#define yyout yyg->yyout_r ------------------ | Branch (1300:8): [True: 1.27k, False: 0] ------------------ 1301| 1.27k| yyout = stdout; ------------------ | | 345| 1.27k|#define yyout yyg->yyout_r ------------------ 1302| | 1303| 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 (1303:8): [True: 0, False: 1.27k] ------------------ 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.27k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.27k|#define yy_load_buffer_state yara_yy_load_buffer_state ------------------ 1310| 1.27k| } 1311| | 1312| 351k| { 1313| 351k|#line 163 "lexer.l" 1314| | 1315| | 1316| 351k|#line 1316 "lexer.c" 1317| | 1318| 467k| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1318:23): [Folded - Ignored] ------------------ 1319| 467k| { 1320| 467k| yy_cp = yyg->yy_c_buf_p; 1321| | 1322| | /* Support of yytext. */ 1323| 467k| *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| 467k| yy_bp = yy_cp; 1329| | 1330| 467k| yy_current_state = yyg->yy_start; 1331| 467k|yy_match: 1332| 467k| do 1333| 3.65M| { 1334| 3.65M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 3.65M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1335| 3.65M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1335:9): [True: 2.67M, False: 989k] ------------------ 1336| 2.67M| { 1337| 2.67M| yyg->yy_last_accepting_state = yy_current_state; 1338| 2.67M| yyg->yy_last_accepting_cpos = yy_cp; 1339| 2.67M| } 1340| 6.85M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1340:12): [True: 3.19M, False: 3.65M] ------------------ 1341| 3.19M| { 1342| 3.19M| yy_current_state = (int) yy_def[yy_current_state]; 1343| 3.19M| if ( yy_current_state >= 295 ) ------------------ | Branch (1343:10): [True: 2.70M, False: 482k] ------------------ 1344| 2.70M| yy_c = yy_meta[yy_c]; 1345| 3.19M| } 1346| 3.65M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1347| 3.65M| ++yy_cp; 1348| 3.65M| } 1349| 3.65M| while ( yy_current_state != 294 ); ------------------ | Branch (1349:11): [True: 3.19M, False: 467k] ------------------ 1350| 467k| yy_cp = yyg->yy_last_accepting_cpos; 1351| 467k| yy_current_state = yyg->yy_last_accepting_state; 1352| | 1353| 468k|yy_find_action: 1354| 468k| yy_act = yy_accept[yy_current_state]; 1355| | 1356| 468k| YY_DO_BEFORE_ACTION; ------------------ | | 578| 468k| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 468k|#define yytext_ptr yytext_r | | ------------------ | | 579| 468k| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 468k|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 468k| yyg->yy_hold_char = *yy_cp; \ | | 581| 468k| *yy_cp = '\0'; \ | | 582| 468k| yyg->yy_c_buf_p = yy_cp; ------------------ 1357| | 1358| 468k| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 937k|#define YY_END_OF_BUFFER 87 ------------------ | Branch (1358:8): [True: 466k, False: 2.31k] | Branch (1358:38): [True: 39.2k, False: 427k] ------------------ 1359| 39.2k| { 1360| 39.2k| int yyl; 1361| 693k| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 693k|#define yyleng yyg->yyleng_r ------------------ | Branch (1361:19): [True: 654k, False: 39.2k] ------------------ 1362| 654k| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 654k|#define yytext yyg->yytext_r ------------------ | Branch (1362:10): [True: 28.3k, False: 626k] ------------------ 1363| | 1364| 28.3k| do{ yylineno++; ------------------ | | 349| 28.3k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 28.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1365| 28.3k| yycolumn=0; ------------------ | | 350| 28.3k|#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) | | ------------------ | | | | 515| 28.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 1366| 28.3k| }while(0) ------------------ | Branch (1366:12): [Folded - Ignored] ------------------ 1367| 39.2k|; 1368| 39.2k| } 1369| | 1370| 469k|do_action: /* This label is used only to access EOF actions. */ 1371| | 1372| 469k| switch ( yy_act ) 1373| 469k| { /* beginning of action switch */ 1374| 18| case 0: /* must back up */ ------------------ | Branch (1374:4): [True: 18, False: 469k] ------------------ 1375| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1376| 18| *yy_cp = yyg->yy_hold_char; 1377| 18| yy_cp = yyg->yy_last_accepting_cpos; 1378| 18| yy_current_state = yyg->yy_last_accepting_state; 1379| 18| goto yy_find_action; 1380| | 1381| 284|case 1: ------------------ | Branch (1381:1): [True: 284, False: 469k] ------------------ 1382| 284|YY_RULE_SETUP 1383| 284|#line 165 "lexer.l" 1384| 284|{ return _DOT_DOT_; } ------------------ | | 127| 284|#define _DOT_DOT_ 259 ------------------ 1385| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1386| 1.73k|case 2: ------------------ | Branch (1386:1): [True: 1.73k, False: 468k] ------------------ 1387| 1.73k|YY_RULE_SETUP 1388| 1.73k|#line 166 "lexer.l" 1389| 1.73k|{ return _LT_; } ------------------ | | 180| 1.73k|#define _LT_ 312 ------------------ 1390| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1391| 1.84k|case 3: ------------------ | Branch (1391:1): [True: 1.84k, False: 467k] ------------------ 1392| 1.84k|YY_RULE_SETUP 1393| 1.84k|#line 167 "lexer.l" 1394| 1.84k|{ return _GT_; } ------------------ | | 182| 1.84k|#define _GT_ 314 ------------------ 1395| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1396| 481|case 4: ------------------ | Branch (1396:1): [True: 481, False: 469k] ------------------ 1397| 481|YY_RULE_SETUP 1398| 481|#line 168 "lexer.l" 1399| 481|{ return _LE_; } ------------------ | | 181| 481|#define _LE_ 313 ------------------ 1400| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1401| 566|case 5: ------------------ | Branch (1401:1): [True: 566, False: 469k] ------------------ 1402| 566|YY_RULE_SETUP 1403| 566|#line 169 "lexer.l" 1404| 566|{ return _GE_; } ------------------ | | 183| 566|#define _GE_ 315 ------------------ 1405| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1406| 462|case 6: ------------------ | Branch (1406:1): [True: 462, False: 469k] ------------------ 1407| 462|YY_RULE_SETUP 1408| 462|#line 170 "lexer.l" 1409| 462|{ return _EQ_; } ------------------ | | 178| 462|#define _EQ_ 310 ------------------ 1410| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1411| 329|case 7: ------------------ | Branch (1411:1): [True: 329, False: 469k] ------------------ 1412| 329|YY_RULE_SETUP 1413| 329|#line 171 "lexer.l" 1414| 329|{ return _NEQ_; } ------------------ | | 179| 329|#define _NEQ_ 311 ------------------ 1415| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1416| 1.51k|case 8: ------------------ | Branch (1416:1): [True: 1.51k, False: 468k] ------------------ 1417| 1.51k|YY_RULE_SETUP 1418| 1.51k|#line 172 "lexer.l" 1419| 1.51k|{ return _SHIFT_LEFT_; } ------------------ | | 184| 1.51k|#define _SHIFT_LEFT_ 316 ------------------ 1420| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1421| 1.58k|case 9: ------------------ | Branch (1421:1): [True: 1.58k, False: 468k] ------------------ 1422| 1.58k|YY_RULE_SETUP 1423| 1.58k|#line 173 "lexer.l" 1424| 1.58k|{ return _SHIFT_RIGHT_; } ------------------ | | 185| 1.58k|#define _SHIFT_RIGHT_ 317 ------------------ 1425| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1426| 822|case 10: ------------------ | Branch (1426:1): [True: 822, False: 468k] ------------------ 1427| 822|YY_RULE_SETUP 1428| 822|#line 174 "lexer.l" 1429| 822|{ return _PRIVATE_; } ------------------ | | 129| 822|#define _PRIVATE_ 261 ------------------ 1430| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1431| 892|case 11: ------------------ | Branch (1431:1): [True: 892, False: 468k] ------------------ 1432| 892|YY_RULE_SETUP 1433| 892|#line 175 "lexer.l" 1434| 892|{ return _GLOBAL_; } ------------------ | | 130| 892|#define _GLOBAL_ 262 ------------------ 1435| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1436| 8.98k|case 12: ------------------ | Branch (1436:1): [True: 8.98k, False: 460k] ------------------ 1437| 8.98k|YY_RULE_SETUP 1438| 8.98k|#line 176 "lexer.l" 1439| 8.98k|{ return _RULE_; } ------------------ | | 128| 8.98k|#define _RULE_ 260 ------------------ 1440| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1441| 154|case 13: ------------------ | Branch (1441:1): [True: 154, False: 469k] ------------------ 1442| 154|YY_RULE_SETUP 1443| 154|#line 177 "lexer.l" 1444| 154|{ return _META_; } ------------------ | | 131| 154|#define _META_ 263 ------------------ 1445| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1446| 1.36k|case 14: ------------------ | Branch (1446:1): [True: 1.36k, False: 468k] ------------------ 1447| 1.36k|YY_RULE_SETUP 1448| 1.36k|#line 178 "lexer.l" 1449| 1.36k|{ return _STRINGS_; } ------------------ | | 132| 1.36k|#define _STRINGS_ 264 ------------------ 1450| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1451| 1.03k|case 15: ------------------ | Branch (1451:1): [True: 1.03k, False: 468k] ------------------ 1452| 1.03k|YY_RULE_SETUP 1453| 1.03k|#line 179 "lexer.l" 1454| 1.03k|{ return _ASCII_; } ------------------ | | 146| 1.03k|#define _ASCII_ 278 ------------------ 1455| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1456| 1.56k|case 16: ------------------ | Branch (1456:1): [True: 1.56k, False: 468k] ------------------ 1457| 1.56k|YY_RULE_SETUP 1458| 1.56k|#line 180 "lexer.l" 1459| 1.56k|{ return _WIDE_; } ------------------ | | 147| 1.56k|#define _WIDE_ 279 ------------------ 1460| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1461| 1.12k|case 17: ------------------ | Branch (1461:1): [True: 1.12k, False: 468k] ------------------ 1462| 1.12k|YY_RULE_SETUP 1463| 1.12k|#line 181 "lexer.l" 1464| 1.12k|{ return _XOR_; } ------------------ | | 148| 1.12k|#define _XOR_ 280 ------------------ 1465| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1466| 1.58k|case 18: ------------------ | Branch (1466:1): [True: 1.58k, False: 468k] ------------------ 1467| 1.58k|YY_RULE_SETUP 1468| 1.58k|#line 182 "lexer.l" 1469| 1.58k|{ return _BASE64_; } ------------------ | | 149| 1.58k|#define _BASE64_ 281 ------------------ 1470| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1471| 1.61k|case 19: ------------------ | Branch (1471:1): [True: 1.61k, False: 468k] ------------------ 1472| 1.61k|YY_RULE_SETUP 1473| 1.61k|#line 183 "lexer.l" 1474| 1.61k|{ return _BASE64_WIDE_; } ------------------ | | 150| 1.61k|#define _BASE64_WIDE_ 282 ------------------ 1475| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 361|case 20: ------------------ | Branch (1476:1): [True: 361, False: 469k] ------------------ 1477| 361|YY_RULE_SETUP 1478| 361|#line 184 "lexer.l" 1479| 361|{ return _FULLWORD_; } ------------------ | | 152| 361|#define _FULLWORD_ 284 ------------------ 1480| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1481| 482|case 21: ------------------ | Branch (1481:1): [True: 482, False: 469k] ------------------ 1482| 482|YY_RULE_SETUP 1483| 482|#line 185 "lexer.l" 1484| 482|{ return _NOCASE_; } ------------------ | | 151| 482|#define _NOCASE_ 283 ------------------ 1485| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1486| 2.76k|case 22: ------------------ | Branch (1486:1): [True: 2.76k, False: 467k] ------------------ 1487| 2.76k|YY_RULE_SETUP 1488| 2.76k|#line 186 "lexer.l" 1489| 2.76k|{ return _CONDITION_; } ------------------ | | 133| 2.76k|#define _CONDITION_ 265 ------------------ 1490| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1491| 261|case 23: ------------------ | Branch (1491:1): [True: 261, False: 469k] ------------------ 1492| 261|YY_RULE_SETUP 1493| 261|#line 187 "lexer.l" 1494| 261|{ return _TRUE_; } ------------------ | | 172| 261|#define _TRUE_ 304 ------------------ 1495| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1496| 802|case 24: ------------------ | Branch (1496:1): [True: 802, False: 468k] ------------------ 1497| 802|YY_RULE_SETUP 1498| 802|#line 188 "lexer.l" 1499| 802|{ return _FALSE_; } ------------------ | | 173| 802|#define _FALSE_ 305 ------------------ 1500| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1501| 458|case 25: ------------------ | Branch (1501:1): [True: 458, False: 469k] ------------------ 1502| 458|YY_RULE_SETUP 1503| 458|#line 189 "lexer.l" 1504| 458|{ return _NOT_; } ------------------ | | 176| 458|#define _NOT_ 308 ------------------ 1505| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1506| 374|case 26: ------------------ | Branch (1506:1): [True: 374, False: 469k] ------------------ 1507| 374|YY_RULE_SETUP 1508| 374|#line 190 "lexer.l" 1509| 374|{ return _AND_; } ------------------ | | 175| 374|#define _AND_ 307 ------------------ 1510| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1511| 4.50k|case 27: ------------------ | Branch (1511:1): [True: 4.50k, False: 465k] ------------------ 1512| 4.50k|YY_RULE_SETUP 1513| 4.50k|#line 191 "lexer.l" 1514| 4.50k|{ return _OR_; } ------------------ | | 174| 4.50k|#define _OR_ 306 ------------------ 1515| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1516| 3.55k|case 28: ------------------ | Branch (1516:1): [True: 3.55k, False: 466k] ------------------ 1517| 3.55k|YY_RULE_SETUP 1518| 3.55k|#line 192 "lexer.l" 1519| 3.55k|{ return _AT_; } ------------------ | | 153| 3.55k|#define _AT_ 285 ------------------ 1520| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1521| 1.56k|case 29: ------------------ | Branch (1521:1): [True: 1.56k, False: 468k] ------------------ 1522| 1.56k|YY_RULE_SETUP 1523| 1.56k|#line 193 "lexer.l" 1524| 1.56k|{ return _IN_; } ------------------ | | 159| 1.56k|#define _IN_ 291 ------------------ 1525| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1526| 3.59k|case 30: ------------------ | Branch (1526:1): [True: 3.59k, False: 466k] ------------------ 1527| 3.59k|YY_RULE_SETUP 1528| 3.59k|#line 194 "lexer.l" 1529| 3.59k|{ return _OF_; } ------------------ | | 160| 3.59k|#define _OF_ 292 ------------------ 1530| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1531| 216|case 31: ------------------ | Branch (1531:1): [True: 216, False: 469k] ------------------ 1532| 216|YY_RULE_SETUP 1533| 216|#line 195 "lexer.l" 1534| 216|{ return _THEM_; } ------------------ | | 162| 216|#define _THEM_ 294 ------------------ 1535| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1536| 1.87k|case 32: ------------------ | Branch (1536:1): [True: 1.87k, False: 467k] ------------------ 1537| 1.87k|YY_RULE_SETUP 1538| 1.87k|#line 196 "lexer.l" 1539| 1.87k|{ return _FOR_; } ------------------ | | 161| 1.87k|#define _FOR_ 293 ------------------ 1540| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1541| 1.66k|case 33: ------------------ | Branch (1541:1): [True: 1.66k, False: 468k] ------------------ 1542| 1.66k|YY_RULE_SETUP 1543| 1.66k|#line 197 "lexer.l" 1544| 1.66k|{ return _ALL_; } ------------------ | | 156| 1.66k|#define _ALL_ 288 ------------------ 1545| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1546| 2.00k|case 34: ------------------ | Branch (1546:1): [True: 2.00k, False: 467k] ------------------ 1547| 2.00k|YY_RULE_SETUP 1548| 2.00k|#line 198 "lexer.l" 1549| 2.00k|{ return _ANY_; } ------------------ | | 157| 2.00k|#define _ANY_ 289 ------------------ 1550| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1551| 129|case 35: ------------------ | Branch (1551:1): [True: 129, False: 469k] ------------------ 1552| 129|YY_RULE_SETUP 1553| 129|#line 199 "lexer.l" 1554| 129|{ return _NONE_; } ------------------ | | 158| 129|#define _NONE_ 290 ------------------ 1555| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1556| 305|case 36: ------------------ | Branch (1556:1): [True: 305, False: 469k] ------------------ 1557| 305|YY_RULE_SETUP 1558| 305|#line 200 "lexer.l" 1559| 305|{ return _ENTRYPOINT_; } ------------------ | | 155| 305|#define _ENTRYPOINT_ 287 ------------------ 1560| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1561| 408|case 37: ------------------ | Branch (1561:1): [True: 408, False: 469k] ------------------ 1562| 408|YY_RULE_SETUP 1563| 408|#line 201 "lexer.l" 1564| 408|{ return _FILESIZE_; } ------------------ | | 154| 408|#define _FILESIZE_ 286 ------------------ 1565| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1566| 196|case 38: ------------------ | Branch (1566:1): [True: 196, False: 469k] ------------------ 1567| 196|YY_RULE_SETUP 1568| 196|#line 202 "lexer.l" 1569| 196|{ return _MATCHES_; } ------------------ | | 163| 196|#define _MATCHES_ 295 ------------------ 1570| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1571| 194|case 39: ------------------ | Branch (1571:1): [True: 194, False: 469k] ------------------ 1572| 194|YY_RULE_SETUP 1573| 194|#line 203 "lexer.l" 1574| 194|{ return _CONTAINS_; } ------------------ | | 164| 194|#define _CONTAINS_ 296 ------------------ 1575| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1576| 168|case 40: ------------------ | Branch (1576:1): [True: 168, False: 469k] ------------------ 1577| 168|YY_RULE_SETUP 1578| 168|#line 204 "lexer.l" 1579| 168|{ return _STARTSWITH_; } ------------------ | | 165| 168|#define _STARTSWITH_ 297 ------------------ 1580| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1581| 192|case 41: ------------------ | Branch (1581:1): [True: 192, False: 469k] ------------------ 1582| 192|YY_RULE_SETUP 1583| 192|#line 205 "lexer.l" 1584| 192|{ return _ENDSWITH_; } ------------------ | | 166| 192|#define _ENDSWITH_ 298 ------------------ 1585| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1586| 185|case 42: ------------------ | Branch (1586:1): [True: 185, False: 469k] ------------------ 1587| 185|YY_RULE_SETUP 1588| 185|#line 206 "lexer.l" 1589| 185|{ return _ICONTAINS_; } ------------------ | | 167| 185|#define _ICONTAINS_ 299 ------------------ 1590| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1591| 160|case 43: ------------------ | Branch (1591:1): [True: 160, False: 469k] ------------------ 1592| 160|YY_RULE_SETUP 1593| 160|#line 207 "lexer.l" 1594| 160|{ return _ISTARTSWITH_; } ------------------ | | 168| 160|#define _ISTARTSWITH_ 300 ------------------ 1595| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1596| 221|case 44: ------------------ | Branch (1596:1): [True: 221, False: 469k] ------------------ 1597| 221|YY_RULE_SETUP 1598| 221|#line 208 "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: 469k] ------------------ 1602| 0|YY_RULE_SETUP 1603| 0|#line 209 "lexer.l" 1604| 0|{ return _IEQUALS_; } ------------------ | | 170| 0|#define _IEQUALS_ 302 ------------------ 1605| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1606| 9.29k|case 46: ------------------ | Branch (1606:1): [True: 9.29k, False: 460k] ------------------ 1607| 9.29k|YY_RULE_SETUP 1608| 9.29k|#line 210 "lexer.l" 1609| 9.29k|{ return _IMPORT_; } ------------------ | | 171| 9.29k|#define _IMPORT_ 303 ------------------ 1610| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1611| 160|case 47: ------------------ | Branch (1611:1): [True: 160, False: 469k] ------------------ 1612| 160|YY_RULE_SETUP 1613| 160|#line 211 "lexer.l" 1614| 160|{ return _DEFINED_; } ------------------ | | 177| 160|#define _DEFINED_ 309 ------------------ 1615| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1616| 130|case 48: ------------------ | Branch (1616:1): [True: 130, False: 469k] ------------------ 1617| 130|YY_RULE_SETUP 1618| 130|#line 214 "lexer.l" 1619| 130|{ BEGIN(comment); } ------------------ | | 357| 130|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(comment); } ------------------ | | 1043| 130|#define comment 4 ------------------ 1620| 130| YY_BREAK ------------------ | | 1269| 130|#define YY_BREAK /*LINTED*/break; ------------------ 1621| 128|case 49: ------------------ | Branch (1621:1): [True: 128, False: 469k] ------------------ 1622| 128|YY_RULE_SETUP 1623| 128|#line 215 "lexer.l" 1624| 128|{ BEGIN(INITIAL); } ------------------ | | 357| 128|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(INITIAL); } ------------------ | | 1039| 128|#define INITIAL 0 ------------------ 1625| 128| YY_BREAK ------------------ | | 1269| 128|#define YY_BREAK /*LINTED*/break; ------------------ 1626| 526|case 50: ------------------ | Branch (1626:1): [True: 526, False: 469k] ------------------ 1627| |/* rule 50 can match eol */ 1628| 526|YY_RULE_SETUP 1629| 526|#line 216 "lexer.l" 1630| 526|{ /* skip comments */ } 1631| 526| YY_BREAK ------------------ | | 1269| 526|#define YY_BREAK /*LINTED*/break; ------------------ 1632| 178|case 51: ------------------ | Branch (1632:1): [True: 178, False: 469k] ------------------ 1633| 178|YY_RULE_SETUP 1634| 178|#line 219 "lexer.l" 1635| 178|{ /* skip single-line comments */ } 1636| 178| YY_BREAK ------------------ | | 1269| 178|#define YY_BREAK /*LINTED*/break; ------------------ 1637| 581|case 52: ------------------ | Branch (1637:1): [True: 581, False: 469k] ------------------ 1638| 581|YY_RULE_SETUP 1639| 581|#line 222 "lexer.l" 1640| 581|{ 1641| 581| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 581|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 581|#define yyextra yyg->yyextra_r ------------------ 1642| 581| yyextra->lex_buf_len = 0; ------------------ | | 346| 581|#define yyextra yyg->yyextra_r ------------------ 1643| 581| BEGIN(include); ------------------ | | 357| 581|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(include); ------------------ | | 1042| 581|#define include 3 ------------------ 1644| 581| } 1645| 581| YY_BREAK ------------------ | | 1269| 581|#define YY_BREAK /*LINTED*/break; ------------------ 1646| 263|case 53: ------------------ | Branch (1646:1): [True: 263, False: 469k] ------------------ 1647| |/* rule 53 can match eol */ 1648| 263|YY_RULE_SETUP 1649| 263|#line 229 "lexer.l" 1650| 263|{ yytext_to_buffer; } ------------------ | | 991| 263| { \ | | 992| 263| char *yptr = yytext; \ | | ------------------ | | | | 348| 263|#define yytext yyg->yytext_r | | ------------------ | | 993| 263| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 263| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 2, False: 261] | | | | ------------------ | | | | 985| 263| { \ | | | | 986| 2| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 49| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 2| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 2|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 2|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 2| } | | ------------------ | | 994| 86.8k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 86.6k, False: 261] | | ------------------ | | 995| 86.6k| { \ | | 996| 86.6k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 86.6k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 86.6k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 86.6k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 86.6k| } \ | | 999| 261| } ------------------ 1651| 261| YY_BREAK ------------------ | | 1269| 261|#define YY_BREAK /*LINTED*/break; ------------------ 1652| 565|case 54: ------------------ | Branch (1652:1): [True: 565, False: 469k] ------------------ 1653| 565|YY_RULE_SETUP 1654| 565|#line 232 "lexer.l" 1655| 565|{ 1656| | 1657| 565| if (compiler->include_callback != NULL) ------------------ | Branch (1657:7): [True: 565, False: 0] ------------------ 1658| 565| { 1659| | #ifdef _MSC_VER 1660| | char* b = NULL; 1661| | #endif 1662| 565| char* s = NULL; 1663| 565| char* f; 1664| | 1665| 565| char buffer[1024]; 1666| 565| const char* included_rules; 1667| 565| char* current_file_name; 1668| 565| char* include_path; 1669| | 1670| 565| *yyextra->lex_buf_ptr = '\0'; // null-terminate included file path ------------------ | | 346| 565|#define yyextra yyg->yyextra_r ------------------ 1671| | 1672| 565| current_file_name = yr_compiler_get_current_file_name(compiler); 1673| | 1674| 565| if (current_file_name == NULL || ------------------ | Branch (1674:9): [True: 565, False: 0] ------------------ 1675| 565| compiler->include_callback != _yr_compiler_default_include_callback || ------------------ | Branch (1675:9): [True: 0, False: 0] ------------------ 1676| 565| is_absolute_path(yyextra->lex_buf)) ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ | Branch (1676:9): [True: 0, False: 0] ------------------ 1677| 565| { 1678| 565| include_path = yyextra->lex_buf; ------------------ | | 346| 565|#define yyextra yyg->yyextra_r ------------------ 1679| 565| } 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| 565| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1711| 565| compiler->arena, 1712| 565| YR_NAMESPACES_TABLE, ------------------ | | 57| 565|#define YR_NAMESPACES_TABLE 0 ------------------ 1713| 565| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1714| | 1715| 565| included_rules = compiler->include_callback( 1716| 565| include_path, 1717| 565| current_file_name, 1718| 565| ns->name, 1719| 565| compiler->incl_clbk_user_data); 1720| | 1721| 565| if (included_rules != NULL) ------------------ | Branch (1721:9): [True: 0, False: 565] ------------------ 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"); ------------------ | | 49| 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"); ------------------ | | 49| 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| 565| else 1755| 565| { 1756| 565| char* err_msg_fmt; 1757| 565| char err_msg[512]; 1758| | 1759| 565| if (compiler->include_callback == _yr_compiler_default_include_callback) ------------------ | Branch (1759:11): [True: 565, False: 0] ------------------ 1760| 565| { 1761| 565| err_msg_fmt = "can't open include file: %s"; 1762| 565| } 1763| 0| else 1764| 0| { 1765| 0| err_msg_fmt = "callback failed to provide include resource: %s"; 1766| 0| } 1767| | 1768| 565| snprintf( 1769| 565| err_msg, 1770| 565| sizeof(err_msg), 1771| 565| err_msg_fmt, 1772| 565| yyextra->lex_buf); ------------------ | | 346| 565|#define yyextra yyg->yyextra_r ------------------ 1773| | 1774| 565| yyerror(yyscanner, compiler, err_msg); ------------------ | | 49| 565|#define yyerror yara_yyerror ------------------ 1775| 565| } 1776| | 1777| 565| } 1778| 0| else // not allowing includes 1779| 0| { 1780| 0| yyerror(yyscanner, compiler, "includes are disabled"); ------------------ | | 49| 0|#define yyerror yara_yyerror ------------------ 1781| 0| } 1782| | 1783| 565| BEGIN(INITIAL); ------------------ | | 357| 565|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 565|#define INITIAL 0 ------------------ 1784| 565|} 1785| 565| YY_BREAK ------------------ | | 1269| 565|#define YY_BREAK /*LINTED*/break; ------------------ 1786| 914|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 914|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 914|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1786:1): [True: 914, False: 468k] ------------------ 1787| 1.03k|case YY_STATE_EOF(str): ------------------ | | 365| 1.03k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.03k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1787:1): [True: 124, False: 469k] ------------------ 1788| 1.11k|case YY_STATE_EOF(regexp): ------------------ | | 365| 1.11k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.11k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1788:1): [True: 74, False: 469k] ------------------ 1789| 1.12k|case YY_STATE_EOF(include): ------------------ | | 365| 1.12k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.12k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1789:1): [True: 14, False: 469k] ------------------ 1790| 1.12k|case YY_STATE_EOF(comment): ------------------ | | 365| 1.12k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.12k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1790:1): [True: 2, False: 469k] ------------------ 1791| 1.12k|#line 364 "lexer.l" 1792| 1.12k|{ 1793| | 1794| 1.12k| yypop_buffer_state(yyscanner); ------------------ | | 80| 1.12k|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 1795| | 1796| 1.12k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1.12k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.12k, False: 0] | | ------------------ | | 510| 1.12k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.12k| : NULL) ------------------ | Branch (1796:7): [True: 1.12k, False: 0] ------------------ 1797| 1.12k| yyterminate(); ------------------ | | 1232| 1.12k|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1.12k|#define YY_NULL 0 | | ------------------ ------------------ 1798| | 1799| 0| return _END_OF_INCLUDED_FILE_; ------------------ | | 126| 0|#define _END_OF_INCLUDED_FILE_ 258 ------------------ 1800| 1.12k|} 1801| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1802| 541|case 55: ------------------ | Branch (1802:1): [True: 541, False: 469k] ------------------ 1803| 541|YY_RULE_SETUP 1804| 541|#line 375 "lexer.l" 1805| 541|{ 1806| | 1807| 541| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 541| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 541|#define yytext yyg->yytext_r ------------------ 1808| | 1809| 541| if (yylval->c_string == NULL) ------------------ | | 1097| 541| # define yylval yyg->yylval_r ------------------ | Branch (1809:7): [True: 0, False: 541] ------------------ 1810| 541| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 541| return _STRING_IDENTIFIER_WITH_WILDCARD_; ------------------ | | 139| 541|#define _STRING_IDENTIFIER_WITH_WILDCARD_ 271 ------------------ 1813| 541|} 1814| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1815| 27.9k|case 56: ------------------ | Branch (1815:1): [True: 27.9k, False: 441k] ------------------ 1816| 27.9k|YY_RULE_SETUP 1817| 27.9k|#line 386 "lexer.l" 1818| 27.9k|{ 1819| | 1820| 27.9k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 27.9k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 27.9k|#define yytext yyg->yytext_r ------------------ 1821| | 1822| 27.9k| if (yylval->c_string == NULL) ------------------ | | 1097| 27.9k| # define yylval yyg->yylval_r ------------------ | Branch (1822:7): [True: 0, False: 27.9k] ------------------ 1823| 27.9k| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 27.9k| return _STRING_IDENTIFIER_; ------------------ | | 135| 27.9k|#define _STRING_IDENTIFIER_ 267 ------------------ 1826| 27.9k|} 1827| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1828| 1.54k|case 57: ------------------ | Branch (1828:1): [True: 1.54k, False: 468k] ------------------ 1829| 1.54k|YY_RULE_SETUP 1830| 1.54k|#line 397 "lexer.l" 1831| 1.54k|{ 1832| | 1833| 1.54k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 1.54k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 1.54k|#define yytext yyg->yytext_r ------------------ 1834| | 1835| 1.54k| if (yylval->c_string == NULL) ------------------ | | 1097| 1.54k| # define yylval yyg->yylval_r ------------------ | Branch (1835:7): [True: 0, False: 1.54k] ------------------ 1836| 0| { 1837| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 1.54k| else 1840| 1.54k| { 1841| 1.54k| yylval->c_string[0] = '$'; /* replace # by $*/ ------------------ | | 1097| 1.54k| # define yylval yyg->yylval_r ------------------ 1842| 1.54k| } 1843| | 1844| 1.54k| return _STRING_COUNT_; ------------------ | | 136| 1.54k|#define _STRING_COUNT_ 268 ------------------ 1845| 1.54k|} 1846| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1847| 2.18k|case 58: ------------------ | Branch (1847:1): [True: 2.18k, False: 467k] ------------------ 1848| 2.18k|YY_RULE_SETUP 1849| 2.18k|#line 414 "lexer.l" 1850| 2.18k|{ 1851| | 1852| 2.18k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 2.18k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 2.18k|#define yytext yyg->yytext_r ------------------ 1853| | 1854| 2.18k| if (yylval->c_string == NULL) ------------------ | | 1097| 2.18k| # define yylval yyg->yylval_r ------------------ | Branch (1854:7): [True: 0, False: 2.18k] ------------------ 1855| 0| { 1856| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 2.18k| else 1859| 2.18k| { 1860| 2.18k| yylval->c_string[0] = '$'; /* replace @ by $*/ ------------------ | | 1097| 2.18k| # define yylval yyg->yylval_r ------------------ 1861| 2.18k| } 1862| | 1863| 2.18k| return _STRING_OFFSET_; ------------------ | | 137| 2.18k|#define _STRING_OFFSET_ 269 ------------------ 1864| 2.18k|} 1865| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1866| 5.35k|case 59: ------------------ | Branch (1866:1): [True: 5.35k, False: 464k] ------------------ 1867| 5.35k|YY_RULE_SETUP 1868| 5.35k|#line 431 "lexer.l" 1869| 5.35k|{ 1870| | 1871| 5.35k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 5.35k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 5.35k|#define yytext yyg->yytext_r ------------------ 1872| | 1873| 5.35k| if (yylval->c_string == NULL) ------------------ | | 1097| 5.35k| # define yylval yyg->yylval_r ------------------ | Branch (1873:7): [True: 0, False: 5.35k] ------------------ 1874| 0| { 1875| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 5.35k| else 1878| 5.35k| { 1879| 5.35k| yylval->c_string[0] = '$'; /* replace ! by $*/ ------------------ | | 1097| 5.35k| # define yylval yyg->yylval_r ------------------ 1880| 5.35k| } 1881| | 1882| 5.35k| return _STRING_LENGTH_; ------------------ | | 138| 5.35k|#define _STRING_LENGTH_ 270 ------------------ 1883| 5.35k|} 1884| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1885| 928|case 60: ------------------ | Branch (1885:1): [True: 928, False: 468k] ------------------ 1886| 928|YY_RULE_SETUP 1887| 928|#line 448 "lexer.l" 1888| 928|{ 1889| | 1890| 928| char* text = yytext; ------------------ | | 348| 928|#define yytext yyg->yytext_r ------------------ 1891| | 1892| 928| if (*text == 'u') ------------------ | Branch (1892:7): [True: 163, False: 765] ------------------ 1893| 163| { 1894| 163| yylval->integer = 3; ------------------ | | 1097| 163| # define yylval yyg->yylval_r ------------------ 1895| 163| text++; 1896| 163| } 1897| 765| else 1898| 765| { 1899| 765| yylval->integer = 0; ------------------ | | 1097| 765| # define yylval yyg->yylval_r ------------------ 1900| 765| } 1901| | 1902| 928| if (strstr(text, "int8") == text) ------------------ | Branch (1902:7): [True: 645, False: 283] ------------------ 1903| 645| { 1904| 645| yylval->integer += 0; ------------------ | | 1097| 645| # define yylval yyg->yylval_r ------------------ 1905| 645| text += 4; 1906| 645| } 1907| 283| else if (strstr(text, "int16") == text) ------------------ | Branch (1907:12): [True: 137, False: 146] ------------------ 1908| 137| { 1909| 137| yylval->integer += 1; ------------------ | | 1097| 137| # define yylval yyg->yylval_r ------------------ 1910| 137| text += 5; 1911| 137| } 1912| 146| else if (strstr(text, "int32") == text) ------------------ | Branch (1912:12): [True: 146, False: 0] ------------------ 1913| 146| { 1914| 146| yylval->integer += 2; ------------------ | | 1097| 146| # define yylval yyg->yylval_r ------------------ 1915| 146| text += 5; 1916| 146| } 1917| | 1918| 928| if (strcmp(text, "be") == 0) ------------------ | Branch (1918:7): [True: 148, False: 780] ------------------ 1919| 148| { 1920| 148| yylval->integer += 6; ------------------ | | 1097| 148| # define yylval yyg->yylval_r ------------------ 1921| 148| } 1922| | 1923| 928| return _INTEGER_FUNCTION_; ------------------ | | 142| 928|#define _INTEGER_FUNCTION_ 274 ------------------ 1924| 5.35k|} 1925| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1926| 38.3k|case 61: ------------------ | Branch (1926:1): [True: 38.3k, False: 431k] ------------------ 1927| 38.3k|YY_RULE_SETUP 1928| 38.3k|#line 487 "lexer.l" 1929| 38.3k|{ 1930| | 1931| 38.3k| if (strlen(yytext) > 128) ------------------ | | 348| 38.3k|#define yytext yyg->yytext_r ------------------ | Branch (1931:7): [True: 7, False: 38.3k] ------------------ 1932| 38.3k| syntax_error("identifier too long"); ------------------ | | 978| 7| { \ | | 979| 7| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 7| strlcpy( \ | | | | 299| 7| compiler->last_error_extra_info, \ | | | | 300| 7| info, \ | | | | 301| 7| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 7| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 7| { \ | | | | 972| 7| compiler->last_error = error_code; \ | | | | 973| 7| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 7|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 7| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 7|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 7|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 7| } | | ------------------ | | 981| 0| } ------------------ 1933| | 1934| 38.3k| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 38.3k| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 38.3k|#define yytext yyg->yytext_r ------------------ 1935| | 1936| 38.3k| if (yylval->c_string == NULL) ------------------ | | 1097| 38.3k| # define yylval yyg->yylval_r ------------------ | Branch (1936:7): [True: 0, False: 38.3k] ------------------ 1937| 38.3k| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 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| 38.3k| return _IDENTIFIER_; ------------------ | | 134| 38.3k|#define _IDENTIFIER_ 266 ------------------ 1940| 38.3k|} 1941| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1942| 24.3k|case 62: ------------------ | Branch (1942:1): [True: 24.3k, False: 445k] ------------------ 1943| 24.3k|YY_RULE_SETUP 1944| 24.3k|#line 501 "lexer.l" 1945| 24.3k|{ 1946| | 1947| 24.3k| char *endptr; 1948| | 1949| 24.3k| errno = 0; 1950| 24.3k| yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 1097| 24.3k| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 348| 24.3k|#define yytext yyg->yytext_r ------------------ 1951| | 1952| 24.3k| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 24.3k| # define yylval yyg->yylval_r ------------------ | Branch (1952:7): [True: 193, False: 24.1k] | Branch (1952:39): [True: 0, False: 193] ------------------ 1953| 0| { 1954| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1955| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1956| 0| } 1957| 24.3k| else if (strstr(yytext, "KB") != NULL) ------------------ | | 348| 24.3k|#define yytext yyg->yytext_r ------------------ | Branch (1957:12): [True: 134, False: 24.2k] ------------------ 1958| 134| { 1959| 134| if (yylval->integer > LLONG_MAX / 1024) ------------------ | | 1097| 134| # define yylval yyg->yylval_r ------------------ | Branch (1959:9): [True: 0, False: 134] ------------------ 1960| 0| { 1961| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1962| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 49| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1963| 0| } 1964| 134| else 1965| 134| { 1966| 134| yylval->integer *= 1024; ------------------ | | 1097| 134| # define yylval yyg->yylval_r ------------------ 1967| 134| } 1968| 134| } 1969| 24.2k| else if (strstr(yytext, "MB") != NULL) ------------------ | | 348| 24.2k|#define yytext yyg->yytext_r ------------------ | Branch (1969:12): [True: 285, False: 23.9k] ------------------ 1970| 285| { 1971| 285| if (yylval->integer > LLONG_MAX / 1048576) ------------------ | | 1097| 285| # define yylval yyg->yylval_r ------------------ | Branch (1971:9): [True: 0, False: 285] ------------------ 1972| 0| { 1973| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 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); \ | | ------------------ | | | | 49| 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| 285| else 1977| 285| { 1978| 285| yylval->integer *= 1048576; ------------------ | | 1097| 285| # define yylval yyg->yylval_r ------------------ 1979| 285| } 1980| 285| } 1981| | 1982| 24.3k| return _NUMBER_; ------------------ | | 140| 24.3k|#define _NUMBER_ 272 ------------------ 1983| 24.3k|} 1984| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1985| 1.10k|case 63: ------------------ | Branch (1985:1): [True: 1.10k, False: 468k] ------------------ 1986| 1.10k|YY_RULE_SETUP 1987| 1.10k|#line 541 "lexer.l" 1988| 1.10k|{ 1989| 1.10k| yylval->double_ = atof(yytext); ------------------ | | 1097| 1.10k| # define yylval yyg->yylval_r ------------------ yylval->double_ = atof(yytext); ------------------ | | 348| 1.10k|#define yytext yyg->yytext_r ------------------ 1990| 1.10k| return _DOUBLE_; ------------------ | | 141| 1.10k|#define _DOUBLE_ 273 ------------------ 1991| 24.3k|} 1992| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1993| 350|case 64: ------------------ | Branch (1993:1): [True: 350, False: 469k] ------------------ 1994| 350|YY_RULE_SETUP 1995| 350|#line 546 "lexer.l" 1996| 350|{ 1997| | 1998| 350| char *endptr; 1999| | 2000| 350| errno = 0; 2001| 350| yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 1097| 350| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 348| 350|#define yytext yyg->yytext_r ------------------ 2002| | 2003| 350| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 350| # define yylval yyg->yylval_r ------------------ | Branch (2003:7): [True: 176, False: 174] | Branch (2003:39): [True: 0, False: 176] ------------------ 2004| 0| { 2005| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 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); \ | | ------------------ | | | | 49| 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| 350| return _NUMBER_; ------------------ | | 140| 350|#define _NUMBER_ 272 ------------------ 2010| 350|} 2011| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2012| 336|case 65: ------------------ | Branch (2012:1): [True: 336, False: 469k] ------------------ 2013| 336|YY_RULE_SETUP 2014| 336|#line 562 "lexer.l" 2015| 336|{ 2016| | 2017| 336| char *endptr; 2018| | 2019| 336| errno = 0; 2020| 336| yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 1097| 336| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 348| 336|#define yytext yyg->yytext_r ------------------ 2021| | 2022| 336| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 336| # define yylval yyg->yylval_r ------------------ | Branch (2022:7): [True: 176, False: 160] | Branch (2022:39): [True: 0, False: 176] ------------------ 2023| 0| { 2024| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 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); \ | | ------------------ | | | | 49| 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| 336| return _NUMBER_; ------------------ | | 140| 336|#define _NUMBER_ 272 ------------------ 2029| 336|} 2030| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2031| 18.7k|case 66: ------------------ | Branch (2031:1): [True: 18.7k, False: 450k] ------------------ 2032| 18.7k|YY_RULE_SETUP 2033| 18.7k|#line 579 "lexer.l" 2034| 18.7k|{ /* saw closing quote - all done */ 2035| | 2036| 18.7k| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 18.7k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 18.7k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 18.7k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 18.7k] | | ------------------ | | 1005| 18.7k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 49| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 18.7k| else \ | | 1010| 18.7k| { \ | | 1011| 18.7k| str->length = (uint32_t) (str_len); \ | | 1012| 18.7k| str->flags = 0; \ | | 1013| 18.7k| } \ ------------------ 2037| | 2038| 18.7k| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 18.7k|#define yyextra yyg->yyextra_r ------------------ 2039| 18.7k| memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 18.7k|#define yyextra yyg->yyextra_r ------------------ memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 18.7k|#define yyextra yyg->yyextra_r ------------------ 2040| | 2041| 18.7k| yylval->sized_string = s; ------------------ | | 1097| 18.7k| # define yylval yyg->yylval_r ------------------ 2042| | 2043| 18.7k| BEGIN(INITIAL); ------------------ | | 357| 18.7k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 18.7k|#define INITIAL 0 ------------------ 2044| | 2045| 18.7k| return _TEXT_STRING_; ------------------ | | 143| 18.7k|#define _TEXT_STRING_ 275 ------------------ 2046| 18.7k|} 2047| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2048| 145|case 67: ------------------ | Branch (2048:1): [True: 145, False: 469k] ------------------ 2049| 145|YY_RULE_SETUP 2050| 145|#line 594 "lexer.l" 2051| 145|{ 2052| | 2053| 145| lex_check_space_ok("\t", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 145| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 144] | | ------------------ | | 985| 145| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2054| 144| *yyextra->lex_buf_ptr++ = '\t'; ------------------ | | 346| 144|#define yyextra yyg->yyextra_r ------------------ 2055| 144| yyextra->lex_buf_len++; ------------------ | | 346| 144|#define yyextra yyg->yyextra_r ------------------ 2056| 144|} 2057| 144| YY_BREAK ------------------ | | 1269| 144|#define YY_BREAK /*LINTED*/break; ------------------ 2058| 145|case 68: ------------------ | Branch (2058:1): [True: 145, False: 469k] ------------------ 2059| 145|YY_RULE_SETUP 2060| 145|#line 602 "lexer.l" 2061| 145|{ 2062| | 2063| 145| lex_check_space_ok("\r", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 145| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 144] | | ------------------ | | 985| 145| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2064| 144| *yyextra->lex_buf_ptr++ = '\r'; ------------------ | | 346| 144|#define yyextra yyg->yyextra_r ------------------ 2065| 144| yyextra->lex_buf_len++; ------------------ | | 346| 144|#define yyextra yyg->yyextra_r ------------------ 2066| 144|} 2067| 144| YY_BREAK ------------------ | | 1269| 144|#define YY_BREAK /*LINTED*/break; ------------------ 2068| 162|case 69: ------------------ | Branch (2068:1): [True: 162, False: 469k] ------------------ 2069| 162|YY_RULE_SETUP 2070| 162|#line 610 "lexer.l" 2071| 162|{ 2072| | 2073| 162| lex_check_space_ok("\n", 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"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2074| 161| *yyextra->lex_buf_ptr++ = '\n'; ------------------ | | 346| 161|#define yyextra yyg->yyextra_r ------------------ 2075| 161| yyextra->lex_buf_len++; ------------------ | | 346| 161|#define yyextra yyg->yyextra_r ------------------ 2076| 161|} 2077| 161| YY_BREAK ------------------ | | 1269| 161|#define YY_BREAK /*LINTED*/break; ------------------ 2078| 156|case 70: ------------------ | Branch (2078:1): [True: 156, False: 469k] ------------------ 2079| 156|YY_RULE_SETUP 2080| 156|#line 618 "lexer.l" 2081| 156|{ 2082| | 2083| 156| lex_check_space_ok("\"", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 156| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 155] | | ------------------ | | 985| 156| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2084| 155| *yyextra->lex_buf_ptr++ = '\"'; ------------------ | | 346| 155|#define yyextra yyg->yyextra_r ------------------ 2085| 155| yyextra->lex_buf_len++; ------------------ | | 346| 155|#define yyextra yyg->yyextra_r ------------------ 2086| 155|} 2087| 155| YY_BREAK ------------------ | | 1269| 155|#define YY_BREAK /*LINTED*/break; ------------------ 2088| 295|case 71: ------------------ | Branch (2088:1): [True: 295, False: 469k] ------------------ 2089| 295|YY_RULE_SETUP 2090| 295|#line 626 "lexer.l" 2091| 295|{ 2092| | 2093| 295| lex_check_space_ok("\\", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 295| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 2, False: 293] | | ------------------ | | 985| 295| { \ | | 986| 2| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 2|#define yyerror yara_yyerror | | ------------------ | | 987| 2| yyterminate(); \ | | ------------------ | | | | 1232| 2|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 2|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 2| } ------------------ 2094| 293| *yyextra->lex_buf_ptr++ = '\\'; ------------------ | | 346| 293|#define yyextra yyg->yyextra_r ------------------ 2095| 293| yyextra->lex_buf_len++; ------------------ | | 346| 293|#define yyextra yyg->yyextra_r ------------------ 2096| 293|} 2097| 293| YY_BREAK ------------------ | | 1269| 293|#define YY_BREAK /*LINTED*/break; ------------------ 2098| 322|case 72: ------------------ | Branch (2098:1): [True: 322, False: 469k] ------------------ 2099| 322|YY_RULE_SETUP 2100| 322|#line 634 "lexer.l" 2101| 322|{ 2102| | 2103| 322| int result; 2104| | 2105| 322| sscanf(yytext + 2, "%x", &result); ------------------ | | 348| 322|#define yytext yyg->yytext_r ------------------ 2106| 322| lex_check_space_ok("X", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 322| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 321] | | ------------------ | | 985| 322| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2107| 321| *yyextra->lex_buf_ptr++ = result; ------------------ | | 346| 321|#define yyextra yyg->yyextra_r ------------------ 2108| 321| yyextra->lex_buf_len++; ------------------ | | 346| 321|#define yyextra yyg->yyextra_r ------------------ 2109| 321|} 2110| 321| YY_BREAK ------------------ | | 1269| 321|#define YY_BREAK /*LINTED*/break; ------------------ 2111| 7.57k|case 73: ------------------ | Branch (2111:1): [True: 7.57k, False: 462k] ------------------ 2112| 7.57k|YY_RULE_SETUP 2113| 7.57k|#line 645 "lexer.l" 2114| 7.57k|{ yytext_to_buffer; } ------------------ | | 991| 7.57k| { \ | | 992| 7.57k| char *yptr = yytext; \ | | ------------------ | | | | 348| 7.57k|#define yytext yyg->yytext_r | | ------------------ | | 993| 7.57k| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 7.57k| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 3, False: 7.57k] | | | | ------------------ | | | | 985| 7.57k| { \ | | | | 986| 3| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 49| 3|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 3| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 3|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 3|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 3| } | | ------------------ | | 994| 886k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 879k, False: 7.57k] | | ------------------ | | 995| 879k| { \ | | 996| 879k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 879k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 879k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 879k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 879k| } \ | | 999| 7.57k| } ------------------ 2115| 7.57k| YY_BREAK ------------------ | | 1269| 7.57k|#define YY_BREAK /*LINTED*/break; ------------------ 2116| 2|case 74: ------------------ | Branch (2116:1): [True: 2, False: 469k] ------------------ 2117| |/* rule 74 can match eol */ 2118| 2|YY_RULE_SETUP 2119| 2|#line 648 "lexer.l" 2120| 2|{ 2121| 2| syntax_error("unterminated string"); ------------------ | | 978| 2| { \ | | 979| 2| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 2| strlcpy( \ | | | | 299| 2| compiler->last_error_extra_info, \ | | | | 300| 2| info, \ | | | | 301| 2| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 2| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 2| { \ | | | | 972| 2| compiler->last_error = error_code; \ | | | | 973| 2| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 2| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 2|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 2|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 2| } | | ------------------ | | 981| 0| } ------------------ 2122| 0|} 2123| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2124| 5|case 75: ------------------ | Branch (2124:1): [True: 5, False: 469k] ------------------ 2125| |/* rule 75 can match eol */ 2126| 5|YY_RULE_SETUP 2127| 5|#line 653 "lexer.l" 2128| 5|{ 2129| 5| syntax_error("illegal escape sequence"); ------------------ | | 978| 5| { \ | | 979| 5| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 5| strlcpy( \ | | | | 299| 5| compiler->last_error_extra_info, \ | | | | 300| 5| info, \ | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 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| } ------------------ 2130| 0|} 2131| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2132| 19.5k|case 76: ------------------ | Branch (2132:1): [True: 19.5k, False: 450k] ------------------ 2133| 19.5k|YY_RULE_SETUP 2134| 19.5k|#line 658 "lexer.l" 2135| 19.5k|{ 2136| | 2137| 19.5k| if (yyextra->lex_buf_len > 0) ------------------ | | 346| 19.5k|#define yyextra yyg->yyextra_r ------------------ | Branch (2137:7): [True: 19.5k, False: 0] ------------------ 2138| 19.5k| { 2139| 19.5k| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 19.5k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 19.5k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 19.5k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 19.5k] | | ------------------ | | 1005| 19.5k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 49| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 19.5k| else \ | | 1010| 19.5k| { \ | | 1011| 19.5k| str->length = (uint32_t) (str_len); \ | | 1012| 19.5k| str->flags = 0; \ | | 1013| 19.5k| } \ ------------------ 2140| | 2141| 19.5k| if (yytext[1] == 'i') ------------------ | | 348| 19.5k|#define yytext yyg->yytext_r ------------------ | Branch (2141:9): [True: 3.28k, False: 16.2k] ------------------ 2142| 3.28k| s->flags |= SIZED_STRING_FLAGS_NO_CASE; ------------------ | | 39| 3.28k|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ 2143| | 2144| 19.5k| if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 19.5k|#define yytext yyg->yytext_r ------------------ if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 19.0k|#define yytext yyg->yytext_r ------------------ | Branch (2144:9): [True: 453, False: 19.0k] | Branch (2144:29): [True: 226, False: 18.8k] ------------------ 2145| 679| s->flags |= SIZED_STRING_FLAGS_DOT_ALL; ------------------ | | 43| 679|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ 2146| | 2147| 19.5k| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 19.5k|#define yyextra yyg->yyextra_r ------------------ 2148| 19.5k| strlcpy(s->c_string, yyextra->lex_buf, s->length + 1); ------------------ | | 346| 19.5k|#define yyextra yyg->yyextra_r ------------------ 2149| | 2150| 19.5k| yylval->sized_string = s; ------------------ | | 1097| 19.5k| # define yylval yyg->yylval_r ------------------ 2151| 19.5k| } 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); \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 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| 19.5k| BEGIN(INITIAL); ------------------ | | 357| 19.5k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 19.5k|#define INITIAL 0 ------------------ 2158| 19.5k| return _REGEXP_; ------------------ | | 145| 19.5k|#define _REGEXP_ 277 ------------------ 2159| 19.5k|} 2160| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2161| 140|case 77: ------------------ | Branch (2161:1): [True: 140, False: 469k] ------------------ 2162| 140|YY_RULE_SETUP 2163| 140|#line 685 "lexer.l" 2164| 140|{ 2165| | 2166| 140| lex_check_space_ok("/", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 140| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 139] | | ------------------ | | 985| 140| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 1|#define yyerror yara_yyerror | | ------------------ | | 987| 1| yyterminate(); \ | | ------------------ | | | | 1232| 1|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 1|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 1| } ------------------ 2167| 139| *yyextra->lex_buf_ptr++ = '/'; ------------------ | | 346| 139|#define yyextra yyg->yyextra_r ------------------ 2168| 139| yyextra->lex_buf_len++ ; ------------------ | | 346| 139|#define yyextra yyg->yyextra_r ------------------ 2169| 139|} 2170| 139| YY_BREAK ------------------ | | 1269| 139|#define YY_BREAK /*LINTED*/break; ------------------ 2171| 7.90k|case 78: ------------------ | Branch (2171:1): [True: 7.90k, False: 461k] ------------------ 2172| 7.90k|YY_RULE_SETUP 2173| 7.90k|#line 693 "lexer.l" 2174| 7.90k|{ 2175| | 2176| 7.90k| lex_check_space_ok("\\.", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 7.90k| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 1, False: 7.89k] | | ------------------ | | 985| 7.90k| { \ | | 986| 1| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 49| 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| 7.89k| if (yytext[1] == 0) ------------------ | | 348| 7.89k|#define yytext yyg->yytext_r ------------------ | Branch (2178:7): [True: 0, False: 7.89k] ------------------ 2179| 7.89k| syntax_error("malformed regular expression"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 0| strlcpy( \ | | | | 299| 0| compiler->last_error_extra_info, \ | | | | 300| 0| info, \ | | | | 301| 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); \ | | | | ------------------ | | | | | | 49| 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| 7.89k| *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 346| 7.89k|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 348| 7.89k|#define yytext yyg->yytext_r ------------------ 2182| 7.89k| *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 346| 7.89k|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 348| 7.89k|#define yytext yyg->yytext_r ------------------ 2183| 7.89k| yyextra->lex_buf_len += 2; ------------------ | | 346| 7.89k|#define yyextra yyg->yyextra_r ------------------ 2184| 7.89k|} 2185| 7.89k| YY_BREAK ------------------ | | 1269| 7.89k|#define YY_BREAK /*LINTED*/break; ------------------ 2186| 21.2k|case 79: ------------------ | Branch (2186:1): [True: 21.2k, False: 448k] ------------------ 2187| 21.2k|YY_RULE_SETUP 2188| 21.2k|#line 706 "lexer.l" 2189| 21.2k|{ yytext_to_buffer; } ------------------ | | 991| 21.2k| { \ | | 992| 21.2k| char *yptr = yytext; \ | | ------------------ | | | | 348| 21.2k|#define yytext yyg->yytext_r | | ------------------ | | 993| 21.2k| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 21.2k| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 3, False: 21.2k] | | | | ------------------ | | | | 985| 21.2k| { \ | | | | 986| 3| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 49| 3|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 3| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 3|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 3|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 3| } | | ------------------ | | 994| 506k| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 485k, False: 21.2k] | | ------------------ | | 995| 485k| { \ | | 996| 485k| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 485k|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 485k| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 485k|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 485k| } \ | | 999| 21.2k| } ------------------ 2190| 21.2k| YY_BREAK ------------------ | | 1269| 21.2k|#define YY_BREAK /*LINTED*/break; ------------------ 2191| 2|case 80: ------------------ | Branch (2191:1): [True: 2, False: 469k] ------------------ 2192| |/* rule 80 can match eol */ 2193| 2|YY_RULE_SETUP 2194| 2|#line 709 "lexer.l" 2195| 2|{ 2196| 2| syntax_error("unterminated regular expression"); ------------------ | | 978| 2| { \ | | 979| 2| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 2| strlcpy( \ | | | | 299| 2| compiler->last_error_extra_info, \ | | | | 300| 2| info, \ | | | | 301| 2| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 2| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 2| { \ | | | | 972| 2| compiler->last_error = error_code; \ | | | | 973| 2| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 2|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 2| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 2|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 2|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 2| } | | ------------------ | | 981| 0| } ------------------ 2197| 0|} 2198| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2199| 18.9k|case 81: ------------------ | Branch (2199:1): [True: 18.9k, False: 450k] ------------------ 2200| 18.9k|YY_RULE_SETUP 2201| 18.9k|#line 714 "lexer.l" 2202| 18.9k|{ 2203| | 2204| 18.9k| yylval->sized_string = NULL; ------------------ | | 1097| 18.9k| # define yylval yyg->yylval_r ------------------ 2205| 18.9k| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 18.9k|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 18.9k|#define yyextra yyg->yyextra_r ------------------ 2206| 18.9k| yyextra->lex_buf_len = 0; ------------------ | | 346| 18.9k|#define yyextra yyg->yyextra_r ------------------ 2207| 18.9k| BEGIN(str); ------------------ | | 357| 18.9k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(str); ------------------ | | 1040| 18.9k|#define str 1 ------------------ 2208| 18.9k|} 2209| 18.9k| YY_BREAK ------------------ | | 1269| 18.9k|#define YY_BREAK /*LINTED*/break; ------------------ 2210| 19.6k|case 82: ------------------ | Branch (2210:1): [True: 19.6k, False: 450k] ------------------ 2211| 19.6k|YY_RULE_SETUP 2212| 19.6k|#line 723 "lexer.l" 2213| 19.6k|{ 2214| | 2215| 19.6k| yylval->sized_string = NULL; ------------------ | | 1097| 19.6k| # define yylval yyg->yylval_r ------------------ 2216| 19.6k| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 19.6k|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 19.6k|#define yyextra yyg->yyextra_r ------------------ 2217| 19.6k| yyextra->lex_buf_len = 0; ------------------ | | 346| 19.6k|#define yyextra yyg->yyextra_r ------------------ 2218| 19.6k| BEGIN(regexp); ------------------ | | 357| 19.6k|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(regexp); ------------------ | | 1041| 19.6k|#define regexp 2 ------------------ 2219| 19.6k|} 2220| 19.6k| YY_BREAK ------------------ | | 1269| 19.6k|#define YY_BREAK /*LINTED*/break; ------------------ 2221| 1.37k|case 83: ------------------ | Branch (2221:1): [True: 1.37k, False: 468k] ------------------ 2222| |/* rule 83 can match eol */ 2223| 1.37k|YY_RULE_SETUP 2224| 1.37k|#line 732 "lexer.l" 2225| 1.37k|{ 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.37k| alloc_sized_string(s, strlen(yytext)); ------------------ | | 1002| 1.37k| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 1.37k| str_len + sizeof(SIZED_STRING)); \ | | 1004| 1.37k| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 1.37k] | | ------------------ | | 1005| 1.37k| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 49| 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.37k| else \ | | 1010| 1.37k| { \ | | 1011| 1.37k| str->length = (uint32_t) (str_len); \ | | 1012| 1.37k| str->flags = 0; \ | | 1013| 1.37k| } \ ------------------ 2234| | 2235| 1.37k| strlcpy(s->c_string, yytext, s->length + 1); ------------------ | | 348| 1.37k|#define yytext yyg->yytext_r ------------------ 2236| 1.37k| yylval->sized_string = s; ------------------ | | 1097| 1.37k| # define yylval yyg->yylval_r ------------------ 2237| | 2238| 1.37k| return _HEX_STRING_; ------------------ | | 144| 1.37k|#define _HEX_STRING_ 276 ------------------ 2239| 1.37k|} 2240| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2241| 37.0k|case 84: ------------------ | Branch (2241:1): [True: 37.0k, False: 432k] ------------------ 2242| |/* rule 84 can match eol */ 2243| 37.0k|YY_RULE_SETUP 2244| 37.0k|#line 749 "lexer.l" 2245| |/* skip whitespace */ 2246| 37.0k| YY_BREAK ------------------ | | 1269| 37.0k|#define YY_BREAK /*LINTED*/break; ------------------ 2247| 143k|case 85: ------------------ | Branch (2247:1): [True: 143k, False: 326k] ------------------ 2248| 143k|YY_RULE_SETUP 2249| 143k|#line 751 "lexer.l" 2250| 143k|{ 2251| | 2252| 143k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 143k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 143k|#define yytext yyg->yytext_r ------------------ | Branch (2252:7): [True: 143k, False: 108] | Branch (2252:26): [True: 143k, False: 0] ------------------ 2253| 143k| { 2254| 143k| return yytext[0]; ------------------ | | 348| 143k|#define yytext yyg->yytext_r ------------------ 2255| 143k| } 2256| 108| else 2257| 108| { 2258| 108| syntax_error("non-ascii character"); ------------------ | | 978| 108| { \ | | 979| 108| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 298| 108| strlcpy( \ | | | | 299| 108| compiler->last_error_extra_info, \ | | | | 300| 108| info, \ | | | | 301| 108| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 108| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 108| { \ | | | | 972| 108| compiler->last_error = error_code; \ | | | | 973| 108| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 49| 108|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 108| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 108|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 108|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 108| } | | ------------------ | | 981| 0| } ------------------ 2259| 0| } 2260| 143k|} 2261| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2262| 4|case 86: ------------------ | Branch (2262:1): [True: 4, False: 469k] ------------------ 2263| 4|YY_RULE_SETUP 2264| 4|#line 763 "lexer.l" 2265| 4|ECHO; ------------------ | | 1188| 4|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 348| 4|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 347| 4|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 345| 4|#define yyout yyg->yyout_r | | ------------------ | | | Branch (1188:23): [True: 4, False: 0] | | | Branch (1188:80): [Folded - Ignored] | | ------------------ ------------------ 2266| 4| YY_BREAK ------------------ | | 1269| 4|#define YY_BREAK /*LINTED*/break; ------------------ 2267| 0|#line 2267 "lexer.c" 2268| | 2269| 2.31k| case YY_END_OF_BUFFER: ------------------ | | 584| 2.31k|#define YY_END_OF_BUFFER 87 ------------------ | Branch (2269:2): [True: 2.31k, False: 467k] ------------------ 2270| 2.31k| { 2271| | /* Amount of text matched not including the EOB char. */ 2272| 2.31k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 2.31k|#define yytext_ptr yytext_r ------------------ 2273| | 2274| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2275| 2.31k| *yy_cp = yyg->yy_hold_char; 2276| 2.31k| YY_RESTORE_YY_MORE_OFFSET 2277| | 2278| 2.31k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 2.31k|#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.31k|#define YY_BUFFER_NEW 0 ------------------ | Branch (2278:8): [True: 1.16k, False: 1.14k] ------------------ 2279| 1.16k| { 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.16k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 1.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2290| 1.16k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 1.16k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 1.16k|#define yyin yyg->yyin_r ------------------ 2291| 1.16k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 1.16k|#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.16k|#define YY_BUFFER_NORMAL 1 ------------------ 2292| 1.16k| } 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.31k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2301:8): [True: 0, False: 2.31k] ------------------ 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.31k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (2338:17): [True: 0, False: 2.31k] ------------------ 2339| 2.31k| { 2340| 1.12k| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 1.12k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (2340:4): [True: 1.12k, False: 1.18k] ------------------ 2341| 1.12k| { 2342| 1.12k| yyg->yy_did_buffer_switch_on_eof = 0; 2343| | 2344| 1.12k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 1.12k|#define yywrap yara_yywrap | | ------------------ | | | | 561| 1.12k|#define yara_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:32): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2345| 1.12k| { 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.12k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.12k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1.12k|#define YY_MORE_ADJ 0 ------------------ 2356| | 2357| 1.12k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 1.12k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1.12k|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ 2358| 1.12k| goto do_action; 2359| 1.12k| } 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.12k| } 2368| | 2369| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (2369:4): [True: 0, False: 2.31k] ------------------ 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.18k| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 1.18k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (2379:4): [True: 1.18k, False: 1.12k] ------------------ 2380| 1.18k| yyg->yy_c_buf_p = 2381| 1.18k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 1.18k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2382| | 2383| 1.18k| yy_current_state = yy_get_previous_state( yyscanner ); 2384| | 2385| 1.18k| yy_cp = yyg->yy_c_buf_p; 2386| 1.18k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1.18k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1.18k|#define YY_MORE_ADJ 0 ------------------ 2387| 1.18k| goto yy_find_action; 2388| 2.31k| } 2389| 0| break; 2390| 2.31k| } 2391| | 2392| 0| default: ------------------ | Branch (2392:2): [True: 0, False: 469k] ------------------ 2393| 0| YY_FATAL_ERROR( ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2394| 469k| "fatal flex scanner internal error--no action found" ); 2395| 469k| } /* end of action switch */ 2396| 469k| } /* end of scanning one token */ 2397| 351k| } /* end of user's declarations */ 2398| 351k|} /* end of yylex */ yara_yy_switch_to_buffer: 2714| 1.27k|{ 2715| 1.27k| 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.27k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 1.27k|#define yyensure_buffer_stack yara_yyensure_buffer_stack ------------------ 2723| 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 (2723:7): [True: 0, False: 1.27k] ------------------ 2724| 0| return; 2725| | 2726| 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) ------------------ 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.27k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 1.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2735| 1.27k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1.27k|#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.27k| yyg->yy_did_buffer_switch_on_eof = 1; 2743| 1.27k|} yara_yy_delete_buffer: 2789| 1.27k|{ 2790| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2791| | 2792| 1.27k| if ( ! b ) ------------------ | Branch (2792:7): [True: 0, False: 1.27k] ------------------ 2793| 0| return; 2794| | 2795| 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 (2795:7): [True: 1.27k, False: 0] ------------------ 2796| 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] ------------------ 2797| | 2798| 1.27k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2798:7): [True: 1.27k, False: 0] ------------------ 2799| 1.27k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree yara_yyfree ------------------ 2800| | 2801| 1.27k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree yara_yyfree ------------------ 2802| 1.27k|} yara_yypop_buffer_state: 2899| 1.27k|{ 2900| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2901| 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 (2901:6): [True: 142, False: 1.12k] ------------------ 2902| 142| return; 2903| | 2904| 1.12k| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 1.12k|#define yy_delete_buffer yara_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 509| 1.12k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1.12k, False: 0] | | ------------------ | | 510| 1.12k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.12k| : NULL) ------------------ 2905| 1.12k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 1.12k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2906| 1.12k| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2906:6): [True: 0, False: 1.12k] ------------------ 2907| 0| --yyg->yy_buffer_stack_top; 2908| | 2909| 1.12k| if (YY_CURRENT_BUFFER) { ------------------ | | 509| 1.12k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1.12k] | | | Branch (509:29): [True: 1.12k, False: 0] | | ------------------ | | 510| 1.12k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.12k| : 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.12k|} yara_yy_scan_buffer: 2969| 1.27k|{ 2970| 1.27k| YY_BUFFER_STATE b; 2971| | 2972| 1.27k| if ( size < 2 || ------------------ | Branch (2972:7): [True: 0, False: 1.27k] ------------------ 2973| 1.27k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 2.54k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2973:7): [True: 0, False: 1.27k] ------------------ 2974| 1.27k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 1.27k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2974:7): [True: 0, False: 1.27k] ------------------ 2975| | /* They forgot to leave room for the EOB's. */ 2976| 0| return NULL; 2977| | 2978| 1.27k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 1.27k|#define yyalloc yara_yyalloc ------------------ 2979| 1.27k| if ( ! b ) ------------------ | Branch (2979:7): [True: 0, False: 1.27k] ------------------ 2980| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2981| | 2982| 1.27k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2983| 1.27k| b->yy_buf_pos = b->yy_ch_buf = base; 2984| 1.27k| b->yy_is_our_buffer = 0; 2985| 1.27k| b->yy_input_file = NULL; 2986| 1.27k| b->yy_n_chars = b->yy_buf_size; 2987| 1.27k| b->yy_is_interactive = 0; 2988| 1.27k| b->yy_at_bol = 1; 2989| 1.27k| b->yy_fill_buffer = 0; 2990| 1.27k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 1.27k|#define YY_BUFFER_NEW 0 ------------------ 2991| | 2992| 1.27k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 1.27k|#define yy_switch_to_buffer yara_yy_switch_to_buffer ------------------ 2993| | 2994| 1.27k| return b; 2995| 1.27k|} yara_yy_scan_string: 3006| 1.27k|{ 3007| | 3008| 1.27k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 1.27k|#define yy_scan_bytes yara_yy_scan_bytes ------------------ 3009| 1.27k|} yara_yy_scan_bytes: 3019| 1.27k|{ 3020| 1.27k| YY_BUFFER_STATE b; 3021| 1.27k| char *buf; 3022| 1.27k| yy_size_t n; 3023| 1.27k| int i; 3024| | 3025| | /* Get memory for full buffer, including space for trailing EOB's. */ 3026| 1.27k| n = (yy_size_t) (_yybytes_len + 2); 3027| 1.27k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 1.27k|#define yyalloc yara_yyalloc ------------------ 3028| 1.27k| if ( ! buf ) ------------------ | Branch (3028:7): [True: 0, False: 1.27k] ------------------ 3029| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3030| | 3031| 3.21M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (3031:15): [True: 3.21M, False: 1.27k] ------------------ 3032| 3.21M| buf[i] = yybytes[i]; 3033| | 3034| 1.27k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 1.27k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 3035| | 3036| 1.27k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 1.27k|#define yy_scan_buffer yara_yy_scan_buffer ------------------ 3037| 1.27k| if ( ! b ) ------------------ | Branch (3037:7): [True: 0, False: 1.27k] ------------------ 3038| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 71| 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.27k| b->yy_is_our_buffer = 1; 3044| | 3045| 1.27k| return b; 3046| 1.27k|} yara_yyget_extra: 3083| 3.66M|{ 3084| 3.66M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3085| 3.66M| return yyextra; ------------------ | | 346| 3.66M|#define yyextra yyg->yyextra_r ------------------ 3086| 3.66M|} yara_yyget_lineno: 3092| 38.8k|{ 3093| 38.8k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3094| | 3095| 38.8k| if (! YY_CURRENT_BUFFER) ------------------ | | 509| 38.8k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 38.8k, False: 0] | | ------------------ | | 510| 38.8k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 38.8k| : NULL) ------------------ | Branch (3095:13): [True: 358, False: 38.5k] ------------------ 3096| 358| return 0; 3097| | 3098| 38.5k| return yylineno; ------------------ | | 349| 38.5k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 38.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 3099| 38.8k|} yara_yyset_extra: 3156| 1.27k|{ 3157| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3158| 1.27k| yyextra = user_defined ; ------------------ | | 346| 1.27k|#define yyextra yyg->yyextra_r ------------------ 3159| 1.27k|} yara_yyset_lineno: 3166| 1.27k|{ 3167| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3168| | 3169| | /* lineno is only valid if an input buffer exists. */ 3170| 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 (3170:13): [True: 0, False: 1.27k] ------------------ 3171| 0| YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3172| | 3173| 1.27k| yylineno = _line_number; ------------------ | | 349| 1.27k|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 1.27k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 3174| 1.27k|} yara_yylex_init: 3242| 1.27k|{ 3243| 1.27k| if (ptr_yy_globals == NULL){ ------------------ | Branch (3243:9): [True: 0, False: 1.27k] ------------------ 3244| 0| errno = EINVAL; 3245| 0| return 1; 3246| 0| } 3247| | 3248| 1.27k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 1.27k|#define yyalloc yara_yyalloc ------------------ 3249| | 3250| 1.27k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (3250:9): [True: 0, False: 1.27k] ------------------ 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.27k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 3257| | 3258| 1.27k| return yy_init_globals ( *ptr_yy_globals ); 3259| 1.27k|} yara_yylex_destroy: 3330| 1.27k|{ 3331| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3332| | 3333| | /* Pop the buffer stack, destroying each element. */ 3334| 1.41k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 1.41k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 142, False: 1.27k] | | | Branch (509:29): [True: 1.41k, False: 0] | | ------------------ | | 510| 1.41k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1.41k| : NULL) ------------------ 3335| 142| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 142|#define yy_delete_buffer yara_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 142|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 142, False: 0] | | ------------------ | | 510| 142| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 142| : NULL) ------------------ 3336| 142| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 142|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3337| 142| yypop_buffer_state(yyscanner); ------------------ | | 80| 142|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 3338| 142| } 3339| | 3340| | /* Destroy the stack itself. */ 3341| 1.27k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 1.27k|#define yyfree yara_yyfree ------------------ 3342| 1.27k| yyg->yy_buffer_stack = NULL; 3343| | 3344| | /* Destroy the start condition stack. */ 3345| 1.27k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree yara_yyfree ------------------ 3346| 1.27k| 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.27k| yy_init_globals( yyscanner); 3351| | 3352| | /* Destroy the main struct (reentrant only). */ 3353| 1.27k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 1.27k|#define yyfree yara_yyfree ------------------ 3354| 1.27k| yyscanner = NULL; 3355| 1.27k| return 0; 3356| 1.27k|} yara_yyalloc: 3386| 5.08k|{ 3387| 5.08k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3388| 5.08k| (void)yyg; 3389| 5.08k| return malloc(size); 3390| 5.08k|} yara_yyfree: 3408| 6.35k|{ 3409| 6.35k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3410| 6.35k| (void)yyg; 3411| 6.35k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3412| 6.35k|} yara_yywarning: 3424| 7.42k|{ 3425| 7.42k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 7.42k|#define yyget_extra yara_yyget_extra ------------------ 3426| | 3427| 7.42k| char* file_name; 3428| 7.42k| char message[512]; 3429| 7.42k| va_list message_args; 3430| | 3431| 7.42k| if (compiler->callback == NULL) ------------------ | Branch (3431:7): [True: 7.42k, False: 0] ------------------ 3432| 7.42k| 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), ------------------ | | 56| 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| 16.8k|{ 3479| 16.8k| char message[512] = {'\0'}; 3480| 16.8k| char* file_name = NULL; 3481| | 3482| 16.8k| compiler->errors++; 3483| | 3484| 16.8k| if (compiler->current_line != 0) ------------------ | Branch (3484:7): [True: 531, False: 16.3k] ------------------ 3485| 531| compiler->last_error_line = compiler->current_line; 3486| 16.3k| else 3487| 16.3k| compiler->last_error_line = yyget_lineno(yyscanner); ------------------ | | 56| 16.3k|#define yyget_lineno yara_yyget_lineno ------------------ 3488| | 3489| 16.8k| compiler->current_line = 0; 3490| | 3491| 16.8k| if (compiler->file_name_stack_ptr > 0) ------------------ | Branch (3491:7): [True: 0, False: 16.8k] ------------------ 3492| 0| { 3493| 0| file_name = compiler->file_name_stack[compiler->file_name_stack_ptr - 1]; 3494| 0| } 3495| 16.8k| else 3496| 16.8k| { 3497| 16.8k| file_name = NULL; 3498| 16.8k| } 3499| | 3500| 16.8k| YR_RULE* current_rule = NULL; 3501| | 3502| 16.8k| if (compiler->current_rule_idx != UINT32_MAX) ------------------ | Branch (3502:7): [True: 7.37k, False: 9.51k] ------------------ 3503| 7.37k| current_rule = yr_arena_get_ptr( 3504| 7.37k| compiler->arena, 3505| 7.37k| YR_RULES_TABLE, ------------------ | | 58| 7.37k|#define YR_RULES_TABLE 1 ------------------ 3506| 7.37k| 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| 16.8k| if (error_message != NULL) ------------------ | Branch (3512:7): [True: 4.75k, False: 12.1k] ------------------ 3513| 4.75k| { 3514| 4.75k| yr_compiler_set_error_extra_info(compiler, error_message); ------------------ | | 298| 4.75k| strlcpy( \ | | 299| 4.75k| compiler->last_error_extra_info, \ | | 300| 4.75k| info, \ | | 301| 4.75k| sizeof(compiler->last_error_extra_info)); ------------------ 3515| 4.75k| compiler->last_error = ERROR_SYNTAX_ERROR; ------------------ | | 56| 4.75k|#define ERROR_SYNTAX_ERROR 11 ------------------ 3516| | 3517| 4.75k| if (compiler->callback != NULL) ------------------ | Branch (3517:9): [True: 0, False: 4.75k] ------------------ 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| 4.75k| } 3528| 12.1k| else if (compiler->callback != NULL) ------------------ | Branch (3528:12): [True: 0, False: 12.1k] ------------------ 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| 16.8k|} yr_lex_parse_rules_string: 3546| 1.27k|{ 3547| 1.27k| yyscan_t yyscanner; 3548| | 3549| 1.27k| compiler->errors = 0; 3550| | 3551| 1.27k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 1.27k|#define yylex_init yara_yylex_init ------------------ | Branch (3551:7): [True: 0, False: 1.27k] ------------------ 3552| 0| { 3553| 0| compiler->errors = 1; 3554| 0| compiler->last_error = ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 3555| 0| return compiler->errors; 3556| 0| } 3557| | 3558| 1.27k| if (setjmp(compiler->error_recovery) != 0) ------------------ | Branch (3558:7): [True: 0, False: 1.27k] ------------------ 3559| 0| return compiler->errors; 3560| | 3561| | #if YYDEBUG 3562| | yydebug = 1; 3563| | #endif 3564| | 3565| 1.27k| yyset_extra(compiler, yyscanner); ------------------ | | 140| 1.27k|#define yyset_extra yara_yyset_extra ------------------ 3566| 1.27k| yy_scan_string(rules_string, yyscanner); ------------------ | | 38| 1.27k|#define yy_scan_string yara_yy_scan_string ------------------ 3567| 1.27k| yyset_lineno(1, yyscanner); ------------------ | | 188| 1.27k|#define yyset_lineno yara_yyset_lineno ------------------ 3568| 1.27k| yyparse(yyscanner, compiler); ------------------ | | 47| 1.27k|#define yyparse yara_yyparse ------------------ 3569| 1.27k| yylex_destroy(yyscanner); ------------------ | | 116| 1.27k|#define yylex_destroy yara_yylex_destroy ------------------ 3570| | 3571| 1.27k| return compiler->errors; 3572| 1.27k|} lexer.c:yy_get_next_buffer: 2408| 2.31k|{ 2409| 2.31k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2410| 2.31k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2411| 2.31k| char *source = yyg->yytext_ptr; ------------------ | | 567| 2.31k|#define yytext_ptr yytext_r ------------------ 2412| 2.31k| int number_to_move, i; 2413| 2.31k| int ret_val; 2414| | 2415| 2.31k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2415:7): [True: 0, False: 2.31k] ------------------ 2416| 0| YY_FATAL_ERROR( ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2417| 2.31k| "fatal flex scanner internal error--end of buffer missed" ); 2418| | 2419| 2.31k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 2.31k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2419:7): [True: 2.31k, False: 0] ------------------ 2420| 2.31k| { /* Don't try to fill the buffer, so this is an EOF. */ 2421| 2.31k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 2.31k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 895| 2.31k|#define YY_MORE_ADJ 0 ------------------ | Branch (2421:8): [True: 1.12k, False: 1.18k] ------------------ 2422| 1.12k| { 2423| | /* We matched a single character, the EOB, so 2424| | * treat this as a final EOF. 2425| | */ 2426| 1.12k| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 1.12k|#define EOB_ACT_END_OF_FILE 1 ------------------ 2427| 1.12k| } 2428| | 2429| 1.18k| else 2430| 1.18k| { 2431| | /* We matched some text prior to the EOB, first 2432| | * process it. 2433| | */ 2434| 1.18k| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 1.18k|#define EOB_ACT_LAST_MATCH 2 ------------------ 2435| 1.18k| } 2436| 2.31k| } 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( ------------------ | | 71| 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" ); \ | | ------------------ | | | | 71| 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" ); \ | | ------------------ | | | | 71| 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()" ); ------------------ | | 71| 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.31k|} lexer.c:yy_get_previous_state: 2547| 1.18k|{ 2548| 1.18k| yy_state_type yy_current_state; 2549| 1.18k| char *yy_cp; 2550| 1.18k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2551| | 2552| 1.18k| yy_current_state = yyg->yy_start; 2553| | 2554| 691k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 1.18k|#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.18k|#define YY_MORE_ADJ 0 ------------------ | Branch (2554:47): [True: 690k, False: 1.18k] ------------------ 2555| 690k| { 2556| 690k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 690k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (2556:19): [True: 690k, False: 0] ------------------ 2557| 690k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2557:8): [True: 292k, False: 397k] ------------------ 2558| 292k| { 2559| 292k| yyg->yy_last_accepting_state = yy_current_state; 2560| 292k| yyg->yy_last_accepting_cpos = yy_cp; 2561| 292k| } 2562| 1.37M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2562:11): [True: 687k, False: 690k] ------------------ 2563| 687k| { 2564| 687k| yy_current_state = (int) yy_def[yy_current_state]; 2565| 687k| if ( yy_current_state >= 295 ) ------------------ | Branch (2565:9): [True: 687k, False: 42] ------------------ 2566| 687k| yy_c = yy_meta[yy_c]; 2567| 687k| } 2568| 690k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2569| 690k| } 2570| | 2571| 1.18k| return yy_current_state; 2572| 1.18k|} lexer.c:yara_yy_load_buffer_state: 2746| 2.54k|{ 2747| 2.54k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2748| 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] ------------------ 2749| 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] ------------------ 2750| 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] ------------------ 2751| 2.54k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2752| 2.54k|} lexer.c:yara_yyensure_buffer_stack: 2919| 1.27k|{ 2920| 1.27k| yy_size_t num_to_alloc; 2921| 1.27k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2922| | 2923| 1.27k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2923:6): [True: 1.27k, 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.27k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2930| 1.27k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 1.27k|#define yyalloc yara_yyalloc ------------------ 2931| 1.27k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2932| 1.27k| , yyscanner); 2933| 1.27k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2933:8): [True: 0, False: 1.27k] ------------------ 2934| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 71| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2935| | 2936| 1.27k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2937| | 2938| 1.27k| yyg->yy_buffer_stack_max = num_to_alloc; 2939| 1.27k| yyg->yy_buffer_stack_top = 0; 2940| 1.27k| return; 2941| 1.27k| } 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()" ); ------------------ | | 71| 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| 2.54k|{ 3297| 2.54k| 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| 2.54k| yyg->yy_buffer_stack = NULL; 3303| 2.54k| yyg->yy_buffer_stack_top = 0; 3304| 2.54k| yyg->yy_buffer_stack_max = 0; 3305| 2.54k| yyg->yy_c_buf_p = NULL; 3306| 2.54k| yyg->yy_init = 0; 3307| 2.54k| yyg->yy_start = 0; 3308| | 3309| 2.54k| yyg->yy_start_stack_ptr = 0; 3310| 2.54k| yyg->yy_start_stack_depth = 0; 3311| 2.54k| yyg->yy_start_stack = NULL; 3312| | 3313| |/* Defined in main.c */ 3314| |#ifdef YY_STDINIT 3315| | yyin = stdin; 3316| | yyout = stdout; 3317| |#else 3318| 2.54k| yyin = NULL; ------------------ | | 344| 2.54k|#define yyin yyg->yyin_r ------------------ 3319| 2.54k| yyout = NULL; ------------------ | | 345| 2.54k|#define yyout yyg->yyout_r ------------------ 3320| 2.54k|#endif 3321| | 3322| | /* For future reference: Set errno on error, since we are called by 3323| | * yylex_init() 3324| | */ 3325| 2.54k| return 0; 3326| 2.54k|} yr_initialize: 232| 2|{ 233| 2| YR_DEBUG_FPRINTF(2, stderr, "+ %s() {\n", __FUNCTION__); 234| | 235| 2| uint32_t def_stack_size = DEFAULT_STACK_SIZE; ------------------ | | 81| 2|#define DEFAULT_STACK_SIZE 16384 ------------------ 236| 2| uint32_t def_max_strings_per_rule = DEFAULT_MAX_STRINGS_PER_RULE; ------------------ | | 82| 2|#define DEFAULT_MAX_STRINGS_PER_RULE 10000 ------------------ 237| 2| uint32_t def_max_match_data = DEFAULT_MAX_MATCH_DATA; ------------------ | | 83| 2|#define DEFAULT_MAX_MATCH_DATA 512 ------------------ 238| 2| uint64_t def_max_process_memory_chunk = DEFAULT_MAX_PROCESS_MEMORY_CHUNK; ------------------ | | 84| 2|#define DEFAULT_MAX_PROCESS_MEMORY_CHUNK 1073741824 ------------------ 239| | 240| 2| init_count++; 241| | 242| 2| if (init_count > 1) ------------------ | Branch (242:7): [True: 0, False: 2] ------------------ 243| 0| return ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 244| | 245| | // Initialize random number generator, as it is used for generating object 246| | // canaries. 247| 2| srand((unsigned) time(NULL)); 248| | 249| 514| for (int i = 0; i < 256; i++) ------------------ | Branch (249:19): [True: 512, False: 2] ------------------ 250| 512| { 251| 512| if (i >= 'a' && i <= 'z') ------------------ | Branch (251:9): [True: 318, False: 194] | Branch (251:21): [True: 52, False: 266] ------------------ 252| 52| yr_altercase[i] = i - 32; 253| 460| else if (i >= 'A' && i <= 'Z') ------------------ | Branch (253:14): [True: 330, False: 130] | Branch (253:26): [True: 52, False: 278] ------------------ 254| 52| yr_altercase[i] = i + 32; 255| 408| else 256| 408| yr_altercase[i] = i; 257| | 258| 512| yr_lowercase[i] = tolower(i); 259| 512| } 260| | 261| 2| FAIL_ON_ERROR(yr_heap_alloc()); ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 262| 2| FAIL_ON_ERROR(yr_thread_storage_create(&yr_yyfatal_trampoline_tls)); ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 263| 2| FAIL_ON_ERROR(yr_thread_storage_create(&yr_trycatch_trampoline_tls)); ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 264| | 265| |#if defined HAVE_LIBCRYPTO && OPENSSL_VERSION_NUMBER < 0x10100000L 266| | 267| | openssl_locks = (YR_MUTEX *) OPENSSL_malloc( 268| | CRYPTO_num_locks() * sizeof(YR_MUTEX)); 269| | 270| | for (int i = 0; i < CRYPTO_num_locks(); i++) 271| | yr_mutex_create(&openssl_locks[i]); 272| | 273| | CRYPTO_THREADID_set_callback(_thread_id); 274| | CRYPTO_set_locking_callback(_locking_function); 275| | 276| |#elif defined(HAVE_WINCRYPT_H) 277| | 278| | if (!CryptAcquireContext( 279| | &yr_cryptprov, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) 280| | { 281| | return ERROR_INTERNAL_FATAL_ERROR; 282| | } 283| | 284| |#elif defined(HAVE_COMMON_CRYPTO) 285| | 286| | ... 287| | 288| |#endif 289| | 290| 2| FAIL_ON_ERROR(yr_modules_initialize()); ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 291| | 292| | // Initialize default configuration options 293| | 294| 2| FAIL_ON_ERROR(yr_set_configuration(YR_CONFIG_STACK_SIZE, &def_stack_size)); ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 295| | 296| 2| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 297| 2| YR_CONFIG_MAX_STRINGS_PER_RULE, &def_max_strings_per_rule)); 298| | 299| 2| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 300| 2| YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK, &def_max_process_memory_chunk)); 301| | 302| 2| FAIL_ON_ERROR( ------------------ | | 131| 2| { \ | | 132| 2| int __error = (x); \ | | 133| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2] | | ------------------ | | 134| 2| return __error; \ | | 135| 2| } ------------------ 303| 2| yr_set_configuration(YR_CONFIG_MAX_MATCH_DATA, &def_max_match_data)); 304| | 305| 2| YR_DEBUG_FPRINTF(2, stderr, "} // %s()\n", __FUNCTION__); 306| | 307| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 308| 2|} yr_set_configuration: 386| 8|{ 387| 8| if (src == NULL) ------------------ | Branch (387:7): [True: 0, False: 8] ------------------ 388| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 389| | 390| 8| switch (name) 391| 8| { // lump all the cases using same types together in one cascade 392| 2| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (392:3): [True: 2, False: 6] ------------------ 393| 4| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (393:3): [True: 2, False: 6] ------------------ 394| 6| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (394:3): [True: 2, False: 6] ------------------ 395| 6| yr_cfgs[name].ui32 = *(uint32_t *) src; 396| 6| break; 397| | 398| 2| case YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK: ------------------ | Branch (398:3): [True: 2, False: 6] ------------------ 399| 2| yr_cfgs[name].ui64 = *(uint64_t *) src; 400| 2| break; 401| | 402| 0| default: ------------------ | Branch (402:3): [True: 0, False: 8] ------------------ 403| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 404| 8| } 405| | 406| 8| return ERROR_SUCCESS; ------------------ | | 40| 8|#define ERROR_SUCCESS 0 ------------------ 407| 8|} yr_get_configuration: 476| 120|{ 477| 120| if (dest == NULL) ------------------ | Branch (477:7): [True: 0, False: 120] ------------------ 478| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 74| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 479| | 480| 120| switch (name) 481| 120| { // lump all the cases using same types together in one cascade 482| 0| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (482:3): [True: 0, False: 120] ------------------ 483| 120| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (483:3): [True: 120, False: 0] ------------------ 484| 120| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (484:3): [True: 0, False: 120] ------------------ 485| 120| *(uint32_t *) dest = yr_cfgs[name].ui32; 486| 120| break; 487| | 488| 0| case YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK: ------------------ | Branch (488:3): [True: 0, False: 120] ------------------ 489| 0| *(uint64_t *) dest = yr_cfgs[name].ui64; 490| 0| break; 491| | 492| 0| default: ------------------ | Branch (492:3): [True: 0, False: 120] ------------------ 493| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 74| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 494| 120| } 495| | 496| 120| return ERROR_SUCCESS; ------------------ | | 40| 120|#define ERROR_SUCCESS 0 ------------------ 497| 120|} yr_get_configuration_uint32: 512| 120|{ 513| 120| switch (name) 514| 120| { 515| | // Accept only the configuration options that are of type uint32_t. 516| 0| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (516:3): [True: 0, False: 120] ------------------ 517| 120| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (517:3): [True: 120, False: 0] ------------------ 518| 120| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (518:3): [True: 0, False: 120] ------------------ 519| 120| return yr_get_configuration(name, (void *) dest); 520| 0| default: ------------------ | Branch (520:3): [True: 0, False: 120] ------------------ 521| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 74| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 522| 120| } 523| 120|} yr_heap_alloc: 116| 2|{ 117| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 118| 2|} yr_calloc: 126| 2.67k|{ 127| 2.67k| return calloc(count, size); 128| 2.67k|} yr_malloc: 131| 30.7M|{ 132| 30.7M| return malloc(size); 133| 30.7M|} yr_realloc: 136| 8.22k|{ 137| 8.22k| return realloc(ptr, size); 138| 8.22k|} yr_strdup: 141| 108k|{ 142| 108k| return strdup(str); 143| 108k|} yr_free: 151| 30.8M|{ 152| 30.8M| free(ptr); 153| 30.8M|} 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| 151|{ 94| 151| for (YR_MODULE* module = yr_modules_table; 95| 982| module->name != NULL && module->declarations != NULL; ------------------ | Branch (95:8): [True: 907, False: 75] | Branch (95:32): [True: 907, False: 0] ------------------ 96| 831| module++) 97| 907| { 98| 907| if (strcmp(module->name, module_name) == 0) ------------------ | Branch (98:9): [True: 76, False: 831] ------------------ 99| 76| return module->declarations(main_structure); 100| 907| } 101| | 102| 75| return ERROR_UNKNOWN_MODULE; ------------------ | | 79| 75|#define ERROR_UNKNOWN_MODULE 34 ------------------ 103| 151|} console__initialize: 251| 2|{ 252| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 253| 2|} dex__initialize: 1390| 2|{ 1391| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 1392| 2|} dotnet__initialize: 3495| 2|{ 3496| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 3497| 2|} elf__declarations: 826| 3|begin_declarations ------------------ | | 59| 3| { \ | | 60| 3| YR_OBJECT* stack[64]; \ | | 61| 3| int stack_top = 0; \ | | 62| 3| stack[stack_top] = module; ------------------ 827| 3| declare_integer("ET_NONE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 828| 3| declare_integer("ET_REL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 829| 3| declare_integer("ET_EXEC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 830| 3| declare_integer("ET_DYN"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 831| 3| declare_integer("ET_CORE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 832| | 833| 3| declare_integer("EM_NONE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 834| 3| declare_integer("EM_M32"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 835| 3| declare_integer("EM_SPARC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 836| 3| declare_integer("EM_386"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 837| 3| declare_integer("EM_68K"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 838| 3| declare_integer("EM_88K"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 839| 3| declare_integer("EM_860"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 840| 3| declare_integer("EM_MIPS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 841| 3| declare_integer("EM_MIPS_RS3_LE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 842| 3| declare_integer("EM_PPC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 843| 3| declare_integer("EM_PPC64"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 844| 3| declare_integer("EM_ARM"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 845| 3| declare_integer("EM_X86_64"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 846| 3| declare_integer("EM_AARCH64"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 847| | 848| 3| declare_integer("SHT_NULL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 849| 3| declare_integer("SHT_PROGBITS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 850| 3| declare_integer("SHT_SYMTAB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 851| 3| declare_integer("SHT_STRTAB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 852| 3| declare_integer("SHT_RELA"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 853| 3| declare_integer("SHT_HASH"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 854| 3| declare_integer("SHT_DYNAMIC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 855| 3| declare_integer("SHT_NOTE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 856| 3| declare_integer("SHT_NOBITS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 857| 3| declare_integer("SHT_REL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 858| 3| declare_integer("SHT_SHLIB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 859| 3| declare_integer("SHT_DYNSYM"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 860| | 861| 3| declare_integer("SHF_WRITE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 862| 3| declare_integer("SHF_ALLOC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 863| 3| declare_integer("SHF_EXECINSTR"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 864| | 865| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 866| 3| declare_integer("machine"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 867| 3| declare_integer("entry_point"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 868| | 869| 3| declare_integer("number_of_sections"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 870| 3| declare_integer("sh_offset"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 871| 3| declare_integer("sh_entry_size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 872| | 873| 3| declare_integer("number_of_segments"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 874| 3| declare_integer("ph_offset"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 875| 3| declare_integer("ph_entry_size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 876| | 877| 9| begin_struct_array("sections") ------------------ | | 80| 3| { \ | | 81| 3| YR_OBJECT* structure; \ | | 82| 3| YR_OBJECT* array; \ | | 83| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 84| 3| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 86| 3| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 3| assertf( \ | | ------------------ | | | | 161| 3| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 3] | | | | ------------------ | | | | 162| 3| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 3| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 3| "too many nested structures"); \ | | 90| 3| stack[++stack_top] = structure; \ | | 91| 3| } ------------------ 878| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 879| 3| declare_integer("flags"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 880| 3| declare_integer("address"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 881| 3| declare_string("name"); ------------------ | | 169| 3| { \ | | 170| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 171| 3| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 3| } ------------------ 882| 3| declare_integer("size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 883| 3| declare_integer("offset"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 884| 6| end_struct_array("sections") ------------------ | | 117| 3| end_struct \ | | ------------------ | | | | 108| 3| { \ | | | | 109| 3| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 3| assertf( \ | | | | ------------------ | | | | | | 161| 3| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 162| 3| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 3| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 3| "unbalanced begin_struct/end_struct"); \ | | | | 113| 3| stack_top--; \ | | | | 114| 3| } | | ------------------ | | 118| 3| (name) ------------------ 885| | 886| 3| declare_integer("PT_NULL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 887| 3| declare_integer("PT_LOAD"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 888| 3| declare_integer("PT_DYNAMIC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 889| 3| declare_integer("PT_INTERP"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 890| 3| declare_integer("PT_NOTE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 891| 3| declare_integer("PT_SHLIB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 892| 3| declare_integer("PT_PHDR"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 893| 3| declare_integer("PT_TLS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 894| 3| declare_integer("PT_GNU_EH_FRAME"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 895| 3| declare_integer("PT_GNU_STACK"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 896| | 897| 3| declare_integer("DT_NULL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 898| 3| declare_integer("DT_NEEDED"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 899| 3| declare_integer("DT_PLTRELSZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 900| 3| declare_integer("DT_PLTGOT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 901| 3| declare_integer("DT_HASH"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 902| 3| declare_integer("DT_STRTAB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 903| 3| declare_integer("DT_SYMTAB"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 904| 3| declare_integer("DT_RELA"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 905| 3| declare_integer("DT_RELASZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 906| 3| declare_integer("DT_RELAENT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 907| 3| declare_integer("DT_STRSZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 908| 3| declare_integer("DT_SYMENT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 909| 3| declare_integer("DT_INIT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 910| 3| declare_integer("DT_FINI"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 911| 3| declare_integer("DT_SONAME"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 912| 3| declare_integer("DT_RPATH"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 913| 3| declare_integer("DT_SYMBOLIC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 914| 3| declare_integer("DT_REL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 915| 3| declare_integer("DT_RELSZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 916| 3| declare_integer("DT_RELENT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 917| 3| declare_integer("DT_PLTREL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 918| 3| declare_integer("DT_DEBUG"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 919| 3| declare_integer("DT_TEXTREL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 920| 3| declare_integer("DT_JMPREL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 921| 3| declare_integer("DT_BIND_NOW"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 922| 3| declare_integer("DT_INIT_ARRAY"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 923| 3| declare_integer("DT_FINI_ARRAY"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 924| 3| declare_integer("DT_INIT_ARRAYSZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 925| 3| declare_integer("DT_FINI_ARRAYSZ"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 926| 3| declare_integer("DT_RUNPATH"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 927| 3| declare_integer("DT_FLAGS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 928| 3| declare_integer("DT_ENCODING"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 929| | 930| 3| declare_integer("STT_NOTYPE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 931| 3| declare_integer("STT_OBJECT"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 932| 3| declare_integer("STT_FUNC"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 933| 3| declare_integer("STT_SECTION"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 934| 3| declare_integer("STT_FILE"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 935| 3| declare_integer("STT_COMMON"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 936| 3| declare_integer("STT_TLS"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 937| | 938| 3| declare_integer("STB_LOCAL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 939| 3| declare_integer("STB_GLOBAL"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 940| 3| declare_integer("STB_WEAK"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 941| | 942| 3| declare_integer("PF_X"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 943| 3| declare_integer("PF_W"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 944| 3| declare_integer("PF_R"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 945| | 946| 9| begin_struct_array("segments") ------------------ | | 80| 3| { \ | | 81| 3| YR_OBJECT* structure; \ | | 82| 3| YR_OBJECT* array; \ | | 83| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 84| 3| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 86| 3| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 3| assertf( \ | | ------------------ | | | | 161| 3| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 3] | | | | ------------------ | | | | 162| 3| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 3| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 3| "too many nested structures"); \ | | 90| 3| stack[++stack_top] = structure; \ | | 91| 3| } ------------------ 947| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 948| 3| declare_integer("flags"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 949| 3| declare_integer("offset"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 950| 3| declare_integer("virtual_address"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 951| 3| declare_integer("physical_address"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 952| 3| declare_integer("file_size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 953| 3| declare_integer("memory_size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 954| 3| declare_integer("alignment"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 955| 6| end_struct_array("segments") ------------------ | | 117| 3| end_struct \ | | ------------------ | | | | 108| 3| { \ | | | | 109| 3| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 3| assertf( \ | | | | ------------------ | | | | | | 161| 3| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 162| 3| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 3| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 3| "unbalanced begin_struct/end_struct"); \ | | | | 113| 3| stack_top--; \ | | | | 114| 3| } | | ------------------ | | 118| 3| (name) ------------------ 956| | 957| 3| declare_integer("dynamic_section_entries"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 958| 9| begin_struct_array("dynamic") ------------------ | | 80| 3| { \ | | 81| 3| YR_OBJECT* structure; \ | | 82| 3| YR_OBJECT* array; \ | | 83| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 84| 3| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 86| 3| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 3| assertf( \ | | ------------------ | | | | 161| 3| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 3] | | | | ------------------ | | | | 162| 3| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 3| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 3| "too many nested structures"); \ | | 90| 3| stack[++stack_top] = structure; \ | | 91| 3| } ------------------ 959| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 960| 3| declare_integer("val"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 961| 6| end_struct_array("dynamic") ------------------ | | 117| 3| end_struct \ | | ------------------ | | | | 108| 3| { \ | | | | 109| 3| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 3| assertf( \ | | | | ------------------ | | | | | | 161| 3| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 162| 3| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 3| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 3| "unbalanced begin_struct/end_struct"); \ | | | | 113| 3| stack_top--; \ | | | | 114| 3| } | | ------------------ | | 118| 3| (name) ------------------ 962| | 963| 3| declare_integer("symtab_entries"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 964| 9| begin_struct_array("symtab") ------------------ | | 80| 3| { \ | | 81| 3| YR_OBJECT* structure; \ | | 82| 3| YR_OBJECT* array; \ | | 83| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 84| 3| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 86| 3| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 3| assertf( \ | | ------------------ | | | | 161| 3| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 3] | | | | ------------------ | | | | 162| 3| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 3| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 3| "too many nested structures"); \ | | 90| 3| stack[++stack_top] = structure; \ | | 91| 3| } ------------------ 965| 3| declare_string("name"); ------------------ | | 169| 3| { \ | | 170| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 171| 3| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 3| } ------------------ 966| 3| declare_integer("value"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 967| 3| declare_integer("size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 968| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 969| 3| declare_integer("bind"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 970| 3| declare_integer("shndx"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 971| 6| end_struct_array("symtab") ------------------ | | 117| 3| end_struct \ | | ------------------ | | | | 108| 3| { \ | | | | 109| 3| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 3| assertf( \ | | | | ------------------ | | | | | | 161| 3| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 162| 3| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 3| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 3| "unbalanced begin_struct/end_struct"); \ | | | | 113| 3| stack_top--; \ | | | | 114| 3| } | | ------------------ | | 118| 3| (name) ------------------ 972| | 973| 3| declare_integer("dynsym_entries"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 974| 9| begin_struct_array("dynsym") ------------------ | | 80| 3| { \ | | 81| 3| YR_OBJECT* structure; \ | | 82| 3| YR_OBJECT* array; \ | | 83| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 84| 3| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 86| 3| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 3| assertf( \ | | ------------------ | | | | 161| 3| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 3] | | | | ------------------ | | | | 162| 3| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 3| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 3| "too many nested structures"); \ | | 90| 3| stack[++stack_top] = structure; \ | | 91| 3| } ------------------ 975| 3| declare_string("name"); ------------------ | | 169| 3| { \ | | 170| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 171| 3| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 3| } ------------------ 976| 3| declare_integer("value"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 977| 3| declare_integer("size"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 978| 3| declare_integer("type"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 979| 3| declare_integer("bind"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 980| 3| declare_integer("shndx"); ------------------ | | 125| 3| { \ | | 126| 3| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 127| 3| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 3| } ------------------ 981| 6| end_struct_array("dynsym") ------------------ | | 117| 3| end_struct \ | | ------------------ | | | | 108| 3| { \ | | | | 109| 3| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 3| assertf( \ | | | | ------------------ | | | | | | 161| 3| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 3] | | | | | | ------------------ | | | | | | 162| 3| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 3| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 3| "unbalanced begin_struct/end_struct"); \ | | | | 113| 3| stack_top--; \ | | | | 114| 3| } | | ------------------ | | 118| 3| (name) ------------------ 982| | 983| 3| declare_function("telfhash", "", "s", telfhash); ------------------ | | 191| 3| { \ | | 192| 3| YR_OBJECT* function; \ | | 193| 3| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 3| { \ | | | | 132| 3| int __error = (x); \ | | | | 133| 3| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 3|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 3] | | | | ------------------ | | | | 134| 3| return __error; \ | | | | 135| 3| } | | ------------------ | | 194| 3| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 3| } ------------------ 984| | 985| |#if defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) || \ 986| | defined(HAVE_COMMONCRYPTO_COMMONCRYPTO_H) 987| | declare_function("import_md5", "", "s", import_md5); 988| |#endif // defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) 989| | 990| 3|end_declarations ------------------ | | 65| 3| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 3|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 3| } ------------------ elf__initialize: 993| 2|{ 994| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 995| 2|} macho__initialize: 1333| 2|{ 1334| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 1335| 2|} math__declarations: 761| 1|begin_declarations ------------------ | | 59| 1| { \ | | 60| 1| YR_OBJECT* stack[64]; \ | | 61| 1| int stack_top = 0; \ | | 62| 1| stack[stack_top] = module; ------------------ 762| 1| declare_float("MEAN_BYTES"); ------------------ | | 147| 1| { \ | | 148| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 149| 1| yr_object_create(OBJECT_TYPE_FLOAT, name, stack[stack_top], NULL)); \ | | 150| 1| } ------------------ 763| 1| declare_function("in_range", "fff", "i", in_range); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 764| 1| declare_function("deviation", "iif", "f", data_deviation); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 765| 1| declare_function("deviation", "sf", "f", string_deviation); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 766| 1| declare_function("mean", "ii", "f", data_mean); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 767| 1| declare_function("mean", "s", "f", string_mean); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 768| 1| declare_function("serial_correlation", "ii", "f", data_serial_correlation); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 769| 1| declare_function("serial_correlation", "s", "f", string_serial_correlation); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 770| 1| declare_function("monte_carlo_pi", "ii", "f", data_monte_carlo_pi); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 771| 1| declare_function("monte_carlo_pi", "s", "f", string_monte_carlo_pi); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 772| 1| declare_function("entropy", "ii", "f", data_entropy); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 773| 1| declare_function("entropy", "s", "f", string_entropy); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 774| 1| declare_function("min", "ii", "i", min); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 775| 1| declare_function("max", "ii", "i", max); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 776| 1| declare_function("to_number", "b", "i", to_number); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 777| 1| declare_function("abs", "i", "i", yr_math_abs); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 778| 1| declare_function("count", "iii", "i", count_range); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 779| 1| declare_function("count", "i", "i", count_global); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 780| 1| declare_function("percentage", "iii", "f", percentage_range); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 781| 1| declare_function("percentage", "i", "f", percentage_global); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 782| 1| declare_function("mode", "ii", "i", mode_range); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 783| 1| declare_function("mode", "", "i", mode_global); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 784| 1| declare_function("to_string", "i", "s", to_string); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 785| 1| declare_function("to_string", "ii", "s", to_string_base); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 1| { \ | | | | 132| 1| int __error = (x); \ | | | | 133| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 1] | | | | ------------------ | | | | 134| 1| return __error; \ | | | | 135| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 786| 1|end_declarations ------------------ | | 65| 1| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 1| } ------------------ math__initialize: 789| 2|{ 790| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 791| 2|} pe__declarations: 3428| 72|begin_declarations ------------------ | | 59| 72| { \ | | 60| 72| YR_OBJECT* stack[64]; \ | | 61| 72| int stack_top = 0; \ | | 62| 72| stack[stack_top] = module; ------------------ 3429| 72| declare_integer("MACHINE_UNKNOWN"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3430| 72| declare_integer("MACHINE_AM33"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3431| 72| declare_integer("MACHINE_AMD64"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3432| 72| declare_integer("MACHINE_ARM"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3433| 72| declare_integer("MACHINE_ARMNT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3434| 72| declare_integer("MACHINE_ARM64"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3435| 72| declare_integer("MACHINE_EBC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3436| 72| declare_integer("MACHINE_I386"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3437| 72| declare_integer("MACHINE_IA64"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3438| 72| declare_integer("MACHINE_M32R"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3439| 72| declare_integer("MACHINE_MIPS16"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3440| 72| declare_integer("MACHINE_MIPSFPU"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3441| 72| declare_integer("MACHINE_MIPSFPU16"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3442| 72| declare_integer("MACHINE_POWERPC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3443| 72| declare_integer("MACHINE_POWERPCFP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3444| 72| declare_integer("MACHINE_R4000"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3445| 72| declare_integer("MACHINE_SH3"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3446| 72| declare_integer("MACHINE_SH3DSP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3447| 72| declare_integer("MACHINE_SH4"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3448| 72| declare_integer("MACHINE_SH5"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3449| 72| declare_integer("MACHINE_THUMB"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3450| 72| declare_integer("MACHINE_WCEMIPSV2"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3451| 72| declare_integer("MACHINE_TARGET_HOST"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3452| 72| declare_integer("MACHINE_R3000"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3453| 72| declare_integer("MACHINE_R10000"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3454| 72| declare_integer("MACHINE_ALPHA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3455| 72| declare_integer("MACHINE_SH3E"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3456| 72| declare_integer("MACHINE_ALPHA64"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3457| 72| declare_integer("MACHINE_AXP64"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3458| 72| declare_integer("MACHINE_TRICORE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3459| 72| declare_integer("MACHINE_CEF"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3460| 72| declare_integer("MACHINE_CEE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3461| | 3462| 72| declare_integer("SUBSYSTEM_UNKNOWN"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3463| 72| declare_integer("SUBSYSTEM_NATIVE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3464| 72| declare_integer("SUBSYSTEM_WINDOWS_GUI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3465| 72| declare_integer("SUBSYSTEM_WINDOWS_CUI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3466| 72| declare_integer("SUBSYSTEM_OS2_CUI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3467| 72| declare_integer("SUBSYSTEM_POSIX_CUI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3468| 72| declare_integer("SUBSYSTEM_NATIVE_WINDOWS"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3469| 72| declare_integer("SUBSYSTEM_WINDOWS_CE_GUI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3470| 72| declare_integer("SUBSYSTEM_EFI_APPLICATION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3471| 72| declare_integer("SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3472| 72| declare_integer("SUBSYSTEM_EFI_RUNTIME_DRIVER"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3473| 72| declare_integer("SUBSYSTEM_EFI_ROM_IMAGE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3474| 72| declare_integer("SUBSYSTEM_XBOX"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3475| 72| declare_integer("SUBSYSTEM_WINDOWS_BOOT_APPLICATION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3476| | 3477| 72| declare_integer("HIGH_ENTROPY_VA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3478| 72| declare_integer("DYNAMIC_BASE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3479| 72| declare_integer("FORCE_INTEGRITY"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3480| 72| declare_integer("NX_COMPAT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3481| 72| declare_integer("NO_ISOLATION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3482| 72| declare_integer("NO_SEH"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3483| 72| declare_integer("NO_BIND"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3484| 72| declare_integer("APPCONTAINER"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3485| 72| declare_integer("WDM_DRIVER"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3486| 72| declare_integer("GUARD_CF"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3487| 72| declare_integer("TERMINAL_SERVER_AWARE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3488| | 3489| 72| declare_integer("RELOCS_STRIPPED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3490| 72| declare_integer("EXECUTABLE_IMAGE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3491| 72| declare_integer("LINE_NUMS_STRIPPED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3492| 72| declare_integer("LOCAL_SYMS_STRIPPED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3493| 72| declare_integer("AGGRESIVE_WS_TRIM"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3494| 72| declare_integer("LARGE_ADDRESS_AWARE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3495| 72| declare_integer("BYTES_REVERSED_LO"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3496| 72| declare_integer("MACHINE_32BIT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3497| 72| declare_integer("DEBUG_STRIPPED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3498| 72| declare_integer("REMOVABLE_RUN_FROM_SWAP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3499| 72| declare_integer("NET_RUN_FROM_SWAP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3500| 72| declare_integer("SYSTEM"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3501| 72| declare_integer("DLL"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3502| 72| declare_integer("UP_SYSTEM_ONLY"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3503| 72| declare_integer("BYTES_REVERSED_HI"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3504| | 3505| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_EXPORT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3506| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_IMPORT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3507| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_RESOURCE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3508| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_EXCEPTION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3509| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_SECURITY"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3510| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_BASERELOC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3511| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_DEBUG"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3512| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_ARCHITECTURE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3513| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_COPYRIGHT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3514| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_GLOBALPTR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3515| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_TLS"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3516| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3517| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3518| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_IAT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3519| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3520| 72| declare_integer("IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3521| | 3522| 72| declare_integer("IMAGE_NT_OPTIONAL_HDR32_MAGIC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3523| 72| declare_integer("IMAGE_NT_OPTIONAL_HDR64_MAGIC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3524| 72| declare_integer("IMAGE_ROM_OPTIONAL_HDR_MAGIC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3525| | 3526| 72| declare_integer("SECTION_NO_PAD"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3527| 72| declare_integer("SECTION_CNT_CODE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3528| 72| declare_integer("SECTION_CNT_INITIALIZED_DATA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3529| 72| declare_integer("SECTION_CNT_UNINITIALIZED_DATA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3530| 72| declare_integer("SECTION_LNK_OTHER"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3531| 72| declare_integer("SECTION_LNK_INFO"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3532| 72| declare_integer("SECTION_LNK_REMOVE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3533| 72| declare_integer("SECTION_LNK_COMDAT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3534| 72| declare_integer("SECTION_NO_DEFER_SPEC_EXC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3535| 72| declare_integer("SECTION_GPREL"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3536| 72| declare_integer("SECTION_MEM_FARDATA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3537| 72| declare_integer("SECTION_MEM_PURGEABLE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3538| 72| declare_integer("SECTION_MEM_16BIT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3539| 72| declare_integer("SECTION_MEM_LOCKED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3540| 72| declare_integer("SECTION_MEM_PRELOAD"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3541| 72| declare_integer("SECTION_ALIGN_1BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3542| 72| declare_integer("SECTION_ALIGN_2BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3543| 72| declare_integer("SECTION_ALIGN_4BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3544| 72| declare_integer("SECTION_ALIGN_8BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3545| 72| declare_integer("SECTION_ALIGN_16BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3546| 72| declare_integer("SECTION_ALIGN_32BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3547| 72| declare_integer("SECTION_ALIGN_64BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3548| 72| declare_integer("SECTION_ALIGN_128BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3549| 72| declare_integer("SECTION_ALIGN_256BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3550| 72| declare_integer("SECTION_ALIGN_512BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3551| 72| declare_integer("SECTION_ALIGN_1024BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3552| 72| declare_integer("SECTION_ALIGN_2048BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3553| 72| declare_integer("SECTION_ALIGN_4096BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3554| 72| declare_integer("SECTION_ALIGN_8192BYTES"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3555| 72| declare_integer("SECTION_ALIGN_MASK"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3556| 72| declare_integer("SECTION_LNK_NRELOC_OVFL"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3557| 72| declare_integer("SECTION_MEM_DISCARDABLE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3558| 72| declare_integer("SECTION_MEM_NOT_CACHED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3559| 72| declare_integer("SECTION_MEM_NOT_PAGED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3560| 72| declare_integer("SECTION_MEM_SHARED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3561| 72| declare_integer("SECTION_MEM_EXECUTE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3562| 72| declare_integer("SECTION_MEM_READ"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3563| 72| declare_integer("SECTION_MEM_WRITE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3564| 72| declare_integer("SECTION_SCALE_INDEX"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3565| | 3566| 72| declare_integer("RESOURCE_TYPE_CURSOR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3567| 72| declare_integer("RESOURCE_TYPE_BITMAP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3568| 72| declare_integer("RESOURCE_TYPE_ICON"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3569| 72| declare_integer("RESOURCE_TYPE_MENU"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3570| 72| declare_integer("RESOURCE_TYPE_DIALOG"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3571| 72| declare_integer("RESOURCE_TYPE_STRING"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3572| 72| declare_integer("RESOURCE_TYPE_FONTDIR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3573| 72| declare_integer("RESOURCE_TYPE_FONT"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3574| 72| declare_integer("RESOURCE_TYPE_ACCELERATOR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3575| 72| declare_integer("RESOURCE_TYPE_RCDATA"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3576| 72| declare_integer("RESOURCE_TYPE_MESSAGETABLE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3577| 72| declare_integer("RESOURCE_TYPE_GROUP_CURSOR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3578| 72| declare_integer("RESOURCE_TYPE_GROUP_ICON"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3579| 72| declare_integer("RESOURCE_TYPE_VERSION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3580| 72| declare_integer("RESOURCE_TYPE_DLGINCLUDE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3581| 72| declare_integer("RESOURCE_TYPE_PLUGPLAY"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3582| 72| declare_integer("RESOURCE_TYPE_VXD"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3583| 72| declare_integer("RESOURCE_TYPE_ANICURSOR"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3584| 72| declare_integer("RESOURCE_TYPE_ANIICON"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3585| 72| declare_integer("RESOURCE_TYPE_HTML"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3586| 72| declare_integer("RESOURCE_TYPE_MANIFEST"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3587| | 3588| 72| declare_integer("IMAGE_DEBUG_TYPE_UNKNOWN"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3589| 72| declare_integer("IMAGE_DEBUG_TYPE_COFF"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3590| 72| declare_integer("IMAGE_DEBUG_TYPE_CODEVIEW"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3591| 72| declare_integer("IMAGE_DEBUG_TYPE_FPO"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3592| 72| declare_integer("IMAGE_DEBUG_TYPE_MISC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3593| 72| declare_integer("IMAGE_DEBUG_TYPE_EXCEPTION"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3594| 72| declare_integer("IMAGE_DEBUG_TYPE_FIXUP"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3595| 72| declare_integer("IMAGE_DEBUG_TYPE_OMAP_TO_SRC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3596| 72| declare_integer("IMAGE_DEBUG_TYPE_OMAP_FROM_SRC"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3597| 72| declare_integer("IMAGE_DEBUG_TYPE_BORLAND"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3598| 72| declare_integer("IMAGE_DEBUG_TYPE_RESERVED10"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3599| 72| declare_integer("IMAGE_DEBUG_TYPE_CLSID"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3600| 72| declare_integer("IMAGE_DEBUG_TYPE_VC_FEATURE"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3601| 72| declare_integer("IMAGE_DEBUG_TYPE_POGO"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3602| 72| declare_integer("IMAGE_DEBUG_TYPE_ILTCG"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3603| 72| declare_integer("IMAGE_DEBUG_TYPE_MPX"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3604| 72| declare_integer("IMAGE_DEBUG_TYPE_REPRO"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3605| | 3606| 72| declare_integer("is_pe"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3607| 72| declare_integer("machine"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3608| 72| declare_integer("number_of_sections"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3609| 72| declare_integer("timestamp"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3610| 72| declare_integer("pointer_to_symbol_table"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3611| 72| declare_integer("number_of_symbols"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3612| 72| declare_integer("size_of_optional_header"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3613| 72| declare_integer("characteristics"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3614| | 3615| 72| declare_integer("entry_point"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3616| 72| declare_integer("entry_point_raw"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3617| 72| declare_integer("image_base"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3618| 72| declare_integer("number_of_rva_and_sizes"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3619| 72| declare_integer("number_of_version_infos"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3620| | 3621| 144| declare_string_dictionary("version_info"); ------------------ | | 183| 72| { \ | | 184| 72| YR_OBJECT* dict; \ | | 185| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 186| 72| OBJECT_TYPE_DICTIONARY, name, stack[stack_top], &dict)); \ | | 187| 72| FAIL_ON_ERROR(yr_object_create(OBJECT_TYPE_STRING, name, dict, NULL)); \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 188| 72| } ------------------ 3622| | 3623| 216| begin_struct_array("version_info_list") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3624| 72| declare_string("key"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3625| 72| declare_string("value"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3626| 144| end_struct_array("version_info_list"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3627| | 3628| 144| declare_integer("opthdr_magic"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3629| 72| declare_integer("size_of_code"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3630| 72| declare_integer("size_of_initialized_data"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3631| 72| declare_integer("size_of_uninitialized_data"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3632| 72| declare_integer("base_of_code"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3633| 72| declare_integer("base_of_data"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3634| 72| declare_integer("section_alignment"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3635| 72| declare_integer("file_alignment"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3636| | 3637| 144| begin_struct("linker_version") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3638| 72| declare_integer("major"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3639| 72| declare_integer("minor"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3640| 144| end_struct("linker_version"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3641| | 3642| 144| begin_struct("os_version") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3643| 72| declare_integer("major"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3644| 72| declare_integer("minor"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3645| 144| end_struct("os_version"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3646| | 3647| 144| begin_struct("image_version") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3648| 72| declare_integer("major"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3649| 72| declare_integer("minor"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3650| 144| end_struct("image_version"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3651| | 3652| 144| begin_struct("subsystem_version") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3653| 72| declare_integer("major"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3654| 72| declare_integer("minor"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3655| 144| end_struct("subsystem_version"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3656| | 3657| 144| declare_integer("win32_version_value"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3658| 72| declare_integer("size_of_image"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3659| 72| declare_integer("size_of_headers"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3660| | 3661| 72| declare_integer("checksum"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3662| 72| declare_function("calculate_checksum", "", "i", calculate_checksum); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3663| 72| declare_integer("subsystem"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3664| | 3665| 72| declare_integer("dll_characteristics"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3666| 72| declare_integer("size_of_stack_reserve"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3667| 72| declare_integer("size_of_stack_commit"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3668| 72| declare_integer("size_of_heap_reserve"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3669| 72| declare_integer("size_of_heap_commit"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3670| 72| declare_integer("loader_flags"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3671| | 3672| 216| begin_struct_array("data_directories") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3673| 72| declare_integer("virtual_address"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3674| 72| declare_integer("size"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3675| 144| end_struct_array("data_directories"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3676| | 3677| 216| begin_struct_array("sections") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3678| 72| declare_string("name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3679| 72| declare_string("full_name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3680| 72| declare_integer("characteristics"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3681| 72| declare_integer("virtual_address"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3682| 72| declare_integer("virtual_size"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3683| 72| declare_integer("raw_data_offset"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3684| 72| declare_integer("raw_data_size"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3685| 72| declare_integer("pointer_to_relocations"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3686| 72| declare_integer("pointer_to_line_numbers"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3687| 72| declare_integer("number_of_relocations"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3688| 72| declare_integer("number_of_line_numbers"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3689| 144| end_struct_array("sections"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3690| | 3691| 144| begin_struct("overlay") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3692| 72| declare_integer("offset"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3693| 72| declare_integer("size"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3694| 144| end_struct("overlay"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3695| | 3696| 144| begin_struct("rich_signature") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3697| 72| declare_integer("offset"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3698| 72| declare_integer("length"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3699| 72| declare_integer("key"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3700| 72| declare_string("raw_data"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3701| 72| declare_string("clear_data"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3702| 72| declare_string("version_data"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3703| 72| declare_function("version", "i", "i", rich_version); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3704| 72| declare_function("version", "ii", "i", rich_version_toolid); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3705| 72| declare_function("toolid", "i", "i", rich_toolid); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3706| 72| declare_function("toolid", "ii", "i", rich_toolid_version); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3707| 144| end_struct("rich_signature"); ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3708| | 3709| |#if defined(HAVE_LIBCRYPTO) || defined(HAVE_WINCRYPT_H) || \ 3710| | defined(HAVE_COMMONCRYPTO_COMMONCRYPTO_H) 3711| | declare_function("imphash", "", "s", imphash); 3712| |#endif 3713| | 3714| 144| declare_integer("IMPORT_DELAYED"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3715| 72| declare_integer("IMPORT_STANDARD"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3716| 72| declare_integer("IMPORT_ANY"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3717| | 3718| 72| declare_function("section_index", "s", "i", section_index_name); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3719| 72| declare_function("section_index", "i", "i", section_index_addr); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3720| 72| declare_function("exports", "s", "i", exports); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3721| 72| declare_function("exports", "r", "i", exports_regexp); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3722| 72| declare_function("exports", "i", "i", exports_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3723| 72| declare_function("exports_index", "s", "i", exports_index_name); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3724| 72| declare_function("exports_index", "i", "i", exports_index_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3725| 72| declare_function("exports_index", "r", "i", exports_index_regex); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3726| 72| declare_function("imports", "ss", "i", imports_standard); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3727| 72| declare_function("imports", "si", "i", imports_standard_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3728| 72| declare_function("imports", "s", "i", imports_standard_dll); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3729| 72| declare_function("imports", "rr", "i", imports_standard_regex); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3730| 72| declare_function("imports", "iss", "i", imports); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3731| 72| declare_function("imports", "isi", "i", imports_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3732| 72| declare_function("imports", "is", "i", imports_dll); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3733| 72| declare_function("imports", "irr", "i", imports_regex); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3734| 72| declare_function("import_rva", "ss", "i", import_rva); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3735| 72| declare_function("import_rva", "si", "i", import_rva_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3736| 72| declare_function("delayed_import_rva", "ss", "i", delayed_import_rva); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3737| 72| declare_function("delayed_import_rva", "si", "i", delayed_import_rva_ordinal); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3738| 72| declare_function("locale", "i", "i", locale); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3739| 72| declare_function("language", "i", "i", language); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3740| 72| declare_function("is_dll", "", "i", is_dll); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3741| 72| declare_function("is_32bit", "", "i", is_32bit); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3742| 72| declare_function("is_64bit", "", "i", is_64bit); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3743| | 3744| 72| declare_integer("number_of_imports"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3745| 72| declare_integer("number_of_imported_functions"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3746| 72| declare_integer("number_of_delayed_imports"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3747| 72| declare_integer("number_of_delayed_imported_functions"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3748| 72| declare_integer("number_of_exports"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3749| | 3750| 72| declare_string("dll_name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3751| 72| declare_integer("export_timestamp"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3752| 216| begin_struct_array("export_details") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3753| 72| declare_integer("offset"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3754| 72| declare_string("name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3755| 72| declare_string("forward_name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3756| 72| declare_integer("ordinal"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3757| 144| end_struct_array("export_details") ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3758| | 3759| 216| begin_struct_array("import_details") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3760| 72| declare_string("library_name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3761| 72| declare_integer("number_of_functions"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3762| 216| begin_struct_array("functions") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3763| 72| declare_string("name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3764| 72| declare_integer("ordinal"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3765| 72| declare_integer("rva"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3766| 144| end_struct_array("functions"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3767| 144| end_struct_array("import_details"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3768| | 3769| 216| begin_struct_array("delayed_import_details") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3770| 72| declare_string("library_name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3771| 72| declare_integer("number_of_functions"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3772| 216| begin_struct_array("functions") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3773| 72| declare_string("name"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3774| 72| declare_integer("ordinal"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3775| 72| declare_integer("rva"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3776| 144| end_struct_array("functions"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3777| 144| end_struct_array("delayed_import_details"); ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3778| | 3779| 144| declare_integer("resource_timestamp"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3780| | 3781| 144| begin_struct("resource_version") ------------------ | | 69| 72| { \ | | 70| 72| YR_OBJECT* structure; \ | | 71| 72| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 72| 72| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 74| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 72| "too many nested structures"); \ | | 76| 72| stack[++stack_top] = structure; \ | | 77| 72| } ------------------ 3782| 72| declare_integer("major"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3783| 72| declare_integer("minor"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3784| 144| end_struct("resource_version") ------------------ | | 108| 72| { \ | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | 113| 72| stack_top--; \ | | 114| 72| } ------------------ 3785| | 3786| 216| begin_struct_array("resources") ------------------ | | 80| 72| { \ | | 81| 72| YR_OBJECT* structure; \ | | 82| 72| YR_OBJECT* array; \ | | 83| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 84| 72| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 86| 72| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 72| assertf( \ | | ------------------ | | | | 161| 72| if (!(expr)) \ | | | | ------------------ | | | | | Branch (161:7): [True: 0, False: 72] | | | | ------------------ | | | | 162| 72| { \ | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 164| 0| abort(); \ | | | | 165| 0| } | | ------------------ | | 88| 72| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 72| "too many nested structures"); \ | | 90| 72| stack[++stack_top] = structure; \ | | 91| 72| } ------------------ 3787| 72| declare_integer("rva"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3788| 72| declare_integer("offset"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3789| 72| declare_integer("length"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3790| 72| declare_integer("type"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3791| 72| declare_integer("id"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3792| 72| declare_integer("language"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3793| 72| declare_string("type_string"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3794| 72| declare_string("name_string"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3795| 72| declare_string("language_string"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3796| 144| end_struct_array("resources") ------------------ | | 117| 72| end_struct \ | | ------------------ | | | | 108| 72| { \ | | | | 109| 72| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 72| assertf( \ | | | | ------------------ | | | | | | 161| 72| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (161:7): [True: 0, False: 72] | | | | | | ------------------ | | | | | | 162| 72| { \ | | | | | | 163| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 164| 0| abort(); \ | | | | | | 165| 0| } | | | | ------------------ | | | | 111| 72| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 72| "unbalanced begin_struct/end_struct"); \ | | | | 113| 72| stack_top--; \ | | | | 114| 72| } | | ------------------ | | 118| 72| (name) ------------------ 3797| | 3798| 72| declare_integer("number_of_resources"); ------------------ | | 125| 72| { \ | | 126| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 127| 72| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 72| } ------------------ 3799| 72| declare_string("pdb_path"); ------------------ | | 169| 72| { \ | | 170| 72| FAIL_ON_ERROR( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 171| 72| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 72| } ------------------ 3800| | 3801| |#if defined(HAVE_LIBCRYPTO) && !defined(BORINGSSL) 3802| | begin_struct_array("signatures") 3803| | declare_string("thumbprint"); 3804| | declare_string("issuer"); 3805| | declare_string("subject"); 3806| | declare_integer("version"); 3807| | declare_string("algorithm"); 3808| | declare_string("algorithm_oid"); 3809| | declare_string("serial"); 3810| | declare_integer("not_before"); 3811| | declare_integer("not_after"); 3812| | 3813| | declare_integer("verified"); 3814| | declare_string("digest_alg"); 3815| | declare_string("digest"); 3816| | declare_string("file_digest"); 3817| | declare_integer("number_of_certificates"); 3818| | begin_struct_array("certificates") 3819| | ; 3820| | declare_string("thumbprint"); 3821| | declare_string("issuer"); 3822| | declare_string("subject"); 3823| | declare_integer("version"); 3824| | declare_string("algorithm"); 3825| | declare_string("algorithm_oid"); 3826| | declare_string("serial"); 3827| | declare_integer("not_before"); 3828| | declare_integer("not_after"); 3829| | end_struct_array("certificates"); 3830| | 3831| | begin_struct("signer_info") 3832| | ; 3833| | declare_string("program_name"); 3834| | declare_string("digest"); 3835| | declare_string("digest_alg"); 3836| | declare_integer("length_of_chain"); 3837| | begin_struct_array("chain") 3838| | ; 3839| | declare_string("thumbprint"); 3840| | declare_string("issuer"); 3841| | declare_string("subject"); 3842| | declare_integer("version"); 3843| | declare_string("algorithm"); 3844| | declare_string("algorithm_oid"); 3845| | declare_string("serial"); 3846| | declare_integer("not_before"); 3847| | declare_integer("not_after"); 3848| | end_struct_array("chain"); 3849| | end_struct("signer_info"); 3850| | 3851| | declare_integer("number_of_countersignatures"); 3852| | begin_struct_array("countersignatures") 3853| | ; 3854| | declare_integer("verified"); 3855| | declare_integer("sign_time"); 3856| | declare_string("digest_alg"); 3857| | declare_string("digest"); 3858| | declare_integer("length_of_chain"); 3859| | begin_struct_array("chain") 3860| | ; 3861| | declare_string("thumbprint"); 3862| | declare_string("issuer"); 3863| | declare_string("subject"); 3864| | declare_integer("version"); 3865| | declare_string("algorithm"); 3866| | declare_string("algorithm_oid"); 3867| | declare_string("serial"); 3868| | declare_integer("not_before"); 3869| | declare_integer("not_after"); 3870| | end_struct_array("chain"); 3871| | end_struct_array("countersignatures") 3872| | 3873| | declare_function("valid_on", "i", "i", valid_on); 3874| | 3875| | end_struct_array("signatures") 3876| | 3877| | // If any of the signatures correctly signs the binary 3878| | declare_integer("is_signed"); 3879| | declare_integer("number_of_signatures"); 3880| |#endif 3881| | 3882| 72| declare_function("rva_to_offset", "i", "i", rva_to_offset); ------------------ | | 191| 72| { \ | | 192| 72| YR_OBJECT* function; \ | | 193| 72| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 131| 72| { \ | | | | 132| 72| int __error = (x); \ | | | | 133| 72| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 72|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (133:9): [True: 0, False: 72] | | | | ------------------ | | | | 134| 72| return __error; \ | | | | 135| 72| } | | ------------------ | | 194| 72| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 72| } ------------------ 3883| 72|end_declarations ------------------ | | 65| 72| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 72|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 72| } ------------------ pe__initialize: 3886| 2|{ 3887| |#if defined(HAVE_LIBCRYPTO) 3888| | // Initialize OpenSSL global objects for the auth library before any 3889| | // multithreaded environment as it is not thread-safe. This can 3890| | // only be called once per process. 3891| | static bool s_initialized = false; 3892| | 3893| | if (!s_initialized) 3894| | { 3895| | s_initialized = true; 3896| | initialize_authenticode_parser(); 3897| | } 3898| |#endif 3899| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 3900| 2|} string__initialize: 103| 2|{ 104| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 105| 2|} 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| 24.0k|{ 57| 24.0k| YR_OBJECT* obj; 58| 24.0k| size_t object_size = 0; 59| | 60| 24.0k| assert(parent != NULL || object != NULL); 61| 24.0k| assert(identifier != NULL); 62| | 63| 24.0k| switch (type) 64| 24.0k| { 65| 1.31k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 1.31k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (65:3): [True: 1.31k, False: 22.7k] ------------------ 66| 1.31k| object_size = sizeof(YR_OBJECT_STRUCTURE); 67| 1.31k| break; 68| 663| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 663|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (68:3): [True: 663, False: 23.4k] ------------------ 69| 663| object_size = sizeof(YR_OBJECT_ARRAY); 70| 663| break; 71| 72| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 72|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (71:3): [True: 72, False: 24.0k] ------------------ 72| 72| object_size = sizeof(YR_OBJECT_DICTIONARY); 73| 72| break; 74| 19.5k| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 19.5k|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (74:3): [True: 19.5k, False: 4.53k] ------------------ 75| 19.5k| object_size = sizeof(YR_OBJECT); 76| 19.5k| break; 77| 7| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 7|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (77:3): [True: 7, False: 24.0k] ------------------ 78| 7| object_size = sizeof(YR_OBJECT); 79| 7| break; 80| 1.38k| case OBJECT_TYPE_STRING: ------------------ | | 59| 1.38k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (80:3): [True: 1.38k, False: 22.6k] ------------------ 81| 1.38k| object_size = sizeof(YR_OBJECT); 82| 1.38k| break; 83| 1.09k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 1.09k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (83:3): [True: 1.09k, False: 22.9k] ------------------ 84| 1.09k| object_size = sizeof(YR_OBJECT_FUNCTION); 85| 1.09k| break; 86| 0| default: ------------------ | Branch (86:3): [True: 0, False: 24.0k] ------------------ 87| 0| assert(false); 88| 24.0k| } 89| | 90| 24.0k| obj = (YR_OBJECT*) yr_malloc(object_size); 91| | 92| 24.0k| if (obj == NULL) ------------------ | Branch (92:7): [True: 0, False: 24.0k] ------------------ 93| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 94| | 95| 24.0k| obj->type = type; 96| 24.0k| obj->identifier = yr_strdup(identifier); 97| 24.0k| obj->parent = parent; 98| 24.0k| obj->data = NULL; 99| | 100| 24.0k| switch (type) ------------------ | Branch (100:11): [True: 0, False: 24.0k] ------------------ 101| 24.0k| { 102| 19.5k| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 19.5k|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (102:3): [True: 19.5k, False: 4.53k] ------------------ 103| 19.5k| obj->value.i = YR_UNDEFINED; ------------------ | | 38| 19.5k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 104| 19.5k| break; 105| 7| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 7|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (105:3): [True: 7, False: 24.0k] ------------------ 106| 7| obj->value.d = NAN; 107| 7| break; 108| 1.38k| case OBJECT_TYPE_STRING: ------------------ | | 59| 1.38k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (108:3): [True: 1.38k, False: 22.6k] ------------------ 109| 1.38k| obj->value.ss = NULL; 110| 1.38k| break; 111| 1.31k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 1.31k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (111:3): [True: 1.31k, False: 22.7k] ------------------ 112| 1.31k| object_as_structure(obj)->members = NULL; ------------------ | | 892| 1.31k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 113| 1.31k| break; 114| 663| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 663|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (114:3): [True: 663, False: 23.4k] ------------------ 115| 663| object_as_array(obj)->items = NULL; ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 116| 663| object_as_array(obj)->prototype_item = NULL; ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 117| 663| break; 118| 72| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 72|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (118:3): [True: 72, False: 24.0k] ------------------ 119| 72| object_as_dictionary(obj)->items = NULL; ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 120| 72| object_as_dictionary(obj)->prototype_item = NULL; ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 121| 72| break; 122| 1.09k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 1.09k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (122:3): [True: 1.09k, False: 22.9k] ------------------ 123| 1.09k| object_as_function(obj)->return_obj = NULL; ------------------ | | 895| 1.09k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 124| 12.0k| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 136| 12.0k|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (124:21): [True: 10.9k, False: 1.09k] ------------------ 125| 10.9k| { 126| 10.9k| object_as_function(obj)->prototypes[i].arguments_fmt = NULL; ------------------ | | 895| 10.9k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 127| 10.9k| object_as_function(obj)->prototypes[i].code = NULL; ------------------ | | 895| 10.9k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 128| 10.9k| } 129| 1.09k| break; 130| 24.0k| } 131| | 132| 24.0k| if (obj->identifier == NULL) ------------------ | Branch (132:7): [True: 0, False: 24.0k] ------------------ 133| 0| { 134| 0| yr_free(obj); 135| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 136| 0| } 137| | 138| 24.0k| if (parent != NULL) ------------------ | Branch (138:7): [True: 23.9k, False: 151] ------------------ 139| 23.9k| { 140| 23.9k| assert( 141| 23.9k| parent->type == OBJECT_TYPE_STRUCTURE || 142| 23.9k| parent->type == OBJECT_TYPE_ARRAY || 143| 23.9k| parent->type == OBJECT_TYPE_DICTIONARY || 144| 23.9k| parent->type == OBJECT_TYPE_FUNCTION); 145| | 146| | // Objects with a parent take the canary from it. 147| 23.9k| obj->canary = parent->canary; 148| | 149| 23.9k| switch (parent->type) ------------------ | Branch (149:13): [True: 0, False: 23.9k] ------------------ 150| 23.9k| { 151| 22.0k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 22.0k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (151:5): [True: 22.0k, False: 1.83k] ------------------ 152| 22.0k| FAIL_ON_ERROR_WITH_CLEANUP(yr_object_structure_set_member(parent, obj), { ------------------ | | 139| 22.0k| { \ | | 140| 22.0k| int __error = (x); \ | | 141| 22.0k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 22.0k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 22.0k] | | ------------------ | | 142| 22.0k| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 22.0k| } ------------------ 153| 22.0k| yr_free((void*) obj->identifier); 154| 22.0k| yr_free(obj); 155| 22.0k| }); 156| 22.0k| break; 157| | 158| 663| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 663|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (158:5): [True: 663, False: 23.2k] ------------------ 159| 663| object_as_array(parent)->prototype_item = obj; ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 160| 663| break; 161| | 162| 72| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 72|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (162:5): [True: 72, False: 23.8k] ------------------ 163| 72| object_as_dictionary(parent)->prototype_item = obj; ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 164| 72| break; 165| | 166| 1.09k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 1.09k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (166:5): [True: 1.09k, False: 22.8k] ------------------ 167| 1.09k| object_as_function(parent)->return_obj = obj; ------------------ | | 895| 1.09k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 168| 1.09k| break; 169| 23.9k| } 170| 23.9k| } 171| | 172| 24.0k| if (object != NULL) ------------------ | Branch (172:7): [True: 4.24k, False: 19.8k] ------------------ 173| 4.24k| *object = obj; 174| | 175| 24.0k| return ERROR_SUCCESS; ------------------ | | 40| 24.0k|#define ERROR_SUCCESS 0 ------------------ 176| 24.0k|} yr_object_function_create: 190| 2.25k|{ 191| 2.25k| YR_OBJECT* return_obj; 192| 2.25k| YR_OBJECT* o = NULL; 193| 2.25k| YR_OBJECT_FUNCTION* f = NULL; 194| | 195| 2.25k| int8_t return_type; 196| | 197| | // The parent of a function must be a structure. 198| 2.25k| assert(parent != NULL && parent->type == OBJECT_TYPE_STRUCTURE); 199| | 200| 2.25k| switch (*return_fmt) 201| 2.25k| { 202| 2.24k| case 'i': ------------------ | Branch (202:3): [True: 2.24k, False: 17] ------------------ 203| 2.24k| return_type = OBJECT_TYPE_INTEGER; ------------------ | | 58| 2.24k|#define OBJECT_TYPE_INTEGER 1 ------------------ 204| 2.24k| break; 205| 5| case 's': ------------------ | Branch (205:3): [True: 5, False: 2.25k] ------------------ 206| 5| return_type = OBJECT_TYPE_STRING; ------------------ | | 59| 5|#define OBJECT_TYPE_STRING 2 ------------------ 207| 5| break; 208| 12| case 'f': ------------------ | Branch (208:3): [True: 12, False: 2.24k] ------------------ 209| 12| return_type = OBJECT_TYPE_FLOAT; ------------------ | | 64| 12|#define OBJECT_TYPE_FLOAT 7 ------------------ 210| 12| break; 211| 0| default: ------------------ | Branch (211:3): [True: 0, False: 2.25k] ------------------ 212| 0| return ERROR_INVALID_FORMAT; ------------------ | | 83| 0|#define ERROR_INVALID_FORMAT 38 ------------------ 213| 2.25k| } 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| 2.25k| f = object_as_function(yr_object_lookup_field(parent, identifier)); ------------------ | | 895| 2.25k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 218| | 219| | // Overloaded functions must have the same return type. 220| 2.25k| if (f != NULL && return_type != f->return_obj->type) ------------------ | Branch (220:7): [True: 1.16k, False: 1.09k] | Branch (220:20): [True: 0, False: 1.16k] ------------------ 221| 0| return ERROR_WRONG_RETURN_TYPE; ------------------ | | 86| 0|#define ERROR_WRONG_RETURN_TYPE 41 ------------------ 222| | 223| 2.25k| if (f == NULL) // Function doesn't exist yet ------------------ | Branch (223:7): [True: 1.09k, False: 1.16k] ------------------ 224| 1.09k| { 225| 1.09k| FAIL_ON_ERROR( ------------------ | | 131| 1.09k| { \ | | 132| 1.09k| int __error = (x); \ | | 133| 1.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.09k] | | ------------------ | | 134| 1.09k| return __error; \ | | 135| 1.09k| } ------------------ 226| 1.09k| 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| 1.09k| FAIL_ON_ERROR(yr_object_create(return_type, "result", o, &return_obj)); ------------------ | | 131| 1.09k| { \ | | 132| 1.09k| int __error = (x); \ | | 133| 1.09k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.09k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.09k] | | ------------------ | | 134| 1.09k| return __error; \ | | 135| 1.09k| } ------------------ 232| | 233| 1.09k| f = object_as_function(o); ------------------ | | 895| 1.09k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 234| 1.09k| } 235| | 236| 5.07k| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 136| 5.07k|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (236:19): [True: 5.07k, False: 0] ------------------ 237| 5.07k| { 238| 5.07k| if (f->prototypes[i].arguments_fmt == NULL) ------------------ | Branch (238:9): [True: 2.25k, False: 2.81k] ------------------ 239| 2.25k| { 240| 2.25k| f->prototypes[i].arguments_fmt = arguments_fmt; 241| 2.25k| f->prototypes[i].code = code; 242| | 243| 2.25k| break; 244| 2.25k| } 245| 5.07k| } 246| | 247| 2.25k| if (function != NULL) ------------------ | Branch (247:7): [True: 2.25k, False: 0] ------------------ 248| 2.25k| *function = (YR_OBJECT*) f; 249| | 250| 2.25k| return ERROR_SUCCESS; ------------------ | | 40| 2.25k|#define ERROR_SUCCESS 0 ------------------ 251| 2.25k|} yr_object_destroy: 321| 24.0k|{ 322| 24.0k| YR_STRUCTURE_MEMBER* member; 323| 24.0k| YR_STRUCTURE_MEMBER* next_member; 324| 24.0k| YR_ARRAY_ITEMS* array_items; 325| 24.0k| YR_DICTIONARY_ITEMS* dict_items; 326| | 327| 24.0k| if (object == NULL) ------------------ | Branch (327:7): [True: 0, False: 24.0k] ------------------ 328| 0| return; 329| | 330| 24.0k| switch (object->type) ------------------ | Branch (330:11): [True: 19.5k, False: 4.53k] ------------------ 331| 24.0k| { 332| 1.31k| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 1.31k|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (332:3): [True: 1.31k, False: 22.7k] ------------------ 333| 1.31k| member = object_as_structure(object)->members; ------------------ | | 892| 1.31k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 334| | 335| 23.4k| while (member != NULL) ------------------ | Branch (335:12): [True: 22.0k, False: 1.31k] ------------------ 336| 22.0k| { 337| 22.0k| next_member = member->next; 338| 22.0k| yr_object_destroy(member->object); 339| 22.0k| yr_free(member); 340| 22.0k| member = next_member; 341| 22.0k| } 342| 1.31k| break; 343| | 344| 1.38k| case OBJECT_TYPE_STRING: ------------------ | | 59| 1.38k|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (344:3): [True: 1.38k, False: 22.6k] ------------------ 345| 1.38k| if (object->value.ss != NULL) ------------------ | Branch (345:9): [True: 0, False: 1.38k] ------------------ 346| 0| yr_free(object->value.ss); 347| 1.38k| break; 348| | 349| 663| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 663|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (349:3): [True: 663, False: 23.4k] ------------------ 350| 663| if (object_as_array(object)->prototype_item != NULL) ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ | Branch (350:9): [True: 663, False: 0] ------------------ 351| 663| yr_object_destroy(object_as_array(object)->prototype_item); ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 352| | 353| 663| array_items = object_as_array(object)->items; ------------------ | | 893| 663|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 354| | 355| 663| if (array_items != NULL) ------------------ | Branch (355:9): [True: 0, False: 663] ------------------ 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| 663| yr_free(array_items); 363| 663| break; 364| | 365| 72| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 72|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (365:3): [True: 72, False: 24.0k] ------------------ 366| 72| if (object_as_dictionary(object)->prototype_item != NULL) ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ | Branch (366:9): [True: 72, False: 0] ------------------ 367| 72| yr_object_destroy(object_as_dictionary(object)->prototype_item); ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 368| | 369| 72| dict_items = object_as_dictionary(object)->items; ------------------ | | 894| 72|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 370| | 371| 72| if (dict_items != NULL) ------------------ | Branch (371:9): [True: 0, False: 72] ------------------ 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| 72| yr_free(dict_items); 384| 72| break; 385| | 386| 1.09k| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 1.09k|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (386:3): [True: 1.09k, False: 22.9k] ------------------ 387| 1.09k| yr_object_destroy(object_as_function(object)->return_obj); ------------------ | | 895| 1.09k|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 388| 1.09k| break; 389| 24.0k| } 390| | 391| 24.0k| yr_free((void*) object->identifier); 392| 24.0k| yr_free(object); 393| 24.0k|} yr_object_lookup_field: 396| 25.1k|{ 397| 25.1k| YR_STRUCTURE_MEMBER* member; 398| | 399| 25.1k| assert(object != NULL); 400| 25.1k| assert(object->type == OBJECT_TYPE_STRUCTURE); 401| | 402| 25.1k| member = object_as_structure(object)->members; ------------------ | | 892| 25.1k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 403| | 404| 2.39M| while (member != NULL) ------------------ | Branch (404:10): [True: 2.36M, False: 23.2k] ------------------ 405| 2.36M| { 406| 2.36M| if (strcmp(member->object->identifier, field_name) == 0) ------------------ | Branch (406:9): [True: 1.98k, False: 2.36M] ------------------ 407| 1.98k| return member->object; 408| | 409| 2.36M| member = member->next; 410| 2.36M| } 411| | 412| 23.2k| return NULL; 413| 25.1k|} yr_object_structure_set_member: 634| 22.0k|{ 635| 22.0k| YR_STRUCTURE_MEMBER* sm; 636| | 637| 22.0k| assert(object->type == OBJECT_TYPE_STRUCTURE); 638| | 639| | // Check if the object already have a member with the same identifier 640| | 641| 22.0k| if (yr_object_lookup_field(object, member->identifier) != NULL) ------------------ | Branch (641:7): [True: 0, False: 22.0k] ------------------ 642| 0| return ERROR_DUPLICATED_STRUCTURE_MEMBER; ------------------ | | 87| 0|#define ERROR_DUPLICATED_STRUCTURE_MEMBER 42 ------------------ 643| | 644| 22.0k| sm = (YR_STRUCTURE_MEMBER*) yr_malloc(sizeof(YR_STRUCTURE_MEMBER)); 645| | 646| 22.0k| if (sm == NULL) ------------------ | Branch (646:7): [True: 0, False: 22.0k] ------------------ 647| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 648| | 649| 22.0k| member->parent = object; 650| 22.0k| sm->object = member; 651| 22.0k| sm->next = object_as_structure(object)->members; ------------------ | | 892| 22.0k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 652| | 653| 22.0k| object_as_structure(object)->members = sm; ------------------ | | 892| 22.0k|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 654| | 655| 22.0k| return ERROR_SUCCESS; ------------------ | | 40| 22.0k|#define ERROR_SUCCESS 0 ------------------ 656| 22.0k|} yr_parser_emit: 55| 48.1k|{ 56| 48.1k| return yr_arena_write_data( 57| 48.1k| yyget_extra(yyscanner)->arena, ------------------ | | 55| 48.1k|#define yyget_extra yara_yyget_extra ------------------ 58| 48.1k| YR_CODE_SECTION, ------------------ | | 63| 48.1k|#define YR_CODE_SECTION 6 ------------------ 59| 48.1k| &instruction, 60| 48.1k| sizeof(uint8_t), 61| 48.1k| instruction_ref); 62| 48.1k|} yr_parser_emit_with_arg_double: 70| 917|{ 71| 917| int result = yr_arena_write_data( 72| 917| yyget_extra(yyscanner)->arena, ------------------ | | 55| 917|#define yyget_extra yara_yyget_extra ------------------ 73| 917| YR_CODE_SECTION, ------------------ | | 63| 917|#define YR_CODE_SECTION 6 ------------------ 74| 917| &instruction, 75| 917| sizeof(uint8_t), 76| 917| instruction_ref); 77| | 78| 917| if (result == ERROR_SUCCESS) ------------------ | | 40| 917|#define ERROR_SUCCESS 0 ------------------ | Branch (78:7): [True: 917, False: 0] ------------------ 79| 917| result = yr_arena_write_data( 80| 917| yyget_extra(yyscanner)->arena, ------------------ | | 55| 917|#define yyget_extra yara_yyget_extra ------------------ 81| 917| YR_CODE_SECTION, ------------------ | | 63| 917|#define YR_CODE_SECTION 6 ------------------ 82| 917| &argument, 83| 917| sizeof(double), 84| 917| argument_ref); 85| | 86| 917| return result; 87| 917|} yr_parser_emit_with_arg_int32: 95| 11.8k|{ 96| 11.8k| int result = yr_arena_write_data( 97| 11.8k| yyget_extra(yyscanner)->arena, ------------------ | | 55| 11.8k|#define yyget_extra yara_yyget_extra ------------------ 98| 11.8k| YR_CODE_SECTION, ------------------ | | 63| 11.8k|#define YR_CODE_SECTION 6 ------------------ 99| 11.8k| &instruction, 100| 11.8k| sizeof(uint8_t), 101| 11.8k| instruction_ref); 102| | 103| 11.8k| if (result == ERROR_SUCCESS) ------------------ | | 40| 11.8k|#define ERROR_SUCCESS 0 ------------------ | Branch (103:7): [True: 11.8k, False: 0] ------------------ 104| 11.8k| result = yr_arena_write_data( 105| 11.8k| yyget_extra(yyscanner)->arena, ------------------ | | 55| 11.8k|#define yyget_extra yara_yyget_extra ------------------ 106| 11.8k| YR_CODE_SECTION, ------------------ | | 63| 11.8k|#define YR_CODE_SECTION 6 ------------------ 107| 11.8k| &argument, 108| 11.8k| sizeof(int32_t), 109| 11.8k| argument_ref); 110| | 111| 11.8k| return result; 112| 11.8k|} yr_parser_emit_with_arg: 120| 26.8k|{ 121| 26.8k| int result = yr_arena_write_data( 122| 26.8k| yyget_extra(yyscanner)->arena, ------------------ | | 55| 26.8k|#define yyget_extra yara_yyget_extra ------------------ 123| 26.8k| YR_CODE_SECTION, ------------------ | | 63| 26.8k|#define YR_CODE_SECTION 6 ------------------ 124| 26.8k| &instruction, 125| 26.8k| sizeof(uint8_t), 126| 26.8k| instruction_ref); 127| | 128| 26.8k| if (result == ERROR_SUCCESS) ------------------ | | 40| 26.8k|#define ERROR_SUCCESS 0 ------------------ | Branch (128:7): [True: 26.8k, False: 0] ------------------ 129| 26.8k| result = yr_arena_write_data( 130| 26.8k| yyget_extra(yyscanner)->arena, ------------------ | | 55| 26.8k|#define yyget_extra yara_yyget_extra ------------------ 131| 26.8k| YR_CODE_SECTION, ------------------ | | 63| 26.8k|#define YR_CODE_SECTION 6 ------------------ 132| 26.8k| &argument, 133| 26.8k| sizeof(int64_t), 134| 26.8k| argument_ref); 135| | 136| 26.8k| return result; 137| 26.8k|} yr_parser_emit_with_arg_reloc: 145| 1.12M|{ 146| 1.12M| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 1.12M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 147| | 148| 1.12M| DECLARE_REFERENCE(void*, ptr) arg; ------------------ | | 45| 1.12M| union \ | | 46| 1.12M| { \ | | 47| 1.12M| type name; \ | | 48| 1.12M| YR_ARENA_REF name##_; \ | | 49| 1.12M| } YR_ALIGN(8) ------------------ 149| | 150| 1.12M| memset(&arg, 0, sizeof(arg)); 151| 1.12M| arg.ptr = argument; 152| | 153| 1.12M| int result = yr_arena_write_data( 154| 1.12M| yyget_extra(yyscanner)->arena, ------------------ | | 55| 1.12M|#define yyget_extra yara_yyget_extra ------------------ 155| 1.12M| YR_CODE_SECTION, ------------------ | | 63| 1.12M|#define YR_CODE_SECTION 6 ------------------ 156| 1.12M| &instruction, 157| 1.12M| sizeof(uint8_t), 158| 1.12M| instruction_ref); 159| | 160| 1.12M| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.12M|#define ERROR_SUCCESS 0 ------------------ | Branch (160:7): [True: 1.12M, False: 0] ------------------ 161| 1.12M| result = yr_arena_write_data( 162| 1.12M| yyget_extra(yyscanner)->arena, ------------------ | | 55| 1.12M|#define yyget_extra yara_yyget_extra ------------------ 163| 1.12M| YR_CODE_SECTION, ------------------ | | 63| 1.12M|#define YR_CODE_SECTION 6 ------------------ 164| 1.12M| &arg, 165| 1.12M| sizeof(arg), 166| 1.12M| &ref); 167| | 168| 1.12M| if (result == ERROR_SUCCESS) ------------------ | | 40| 1.12M|#define ERROR_SUCCESS 0 ------------------ | Branch (168:7): [True: 1.12M, False: 0] ------------------ 169| 1.12M| result = yr_arena_make_ptr_relocatable( 170| 1.12M| yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 55| 1.12M|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 63| 1.12M|#define YR_CODE_SECTION 6 ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 38| 1.12M|#define EOL ((size_t) -1) ------------------ 171| | 172| 1.12M| if (argument_ref != NULL) ------------------ | Branch (172:7): [True: 0, False: 1.12M] ------------------ 173| 0| *argument_ref = ref; 174| | 175| 1.12M| return result; 176| 1.12M|} yr_parser_emit_pushes_for_strings: 182| 3.75k|{ 183| 3.75k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 3.75k|#define yyget_extra yara_yyget_extra ------------------ 184| | 185| 3.75k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 186| 3.75k| compiler, compiler->current_rule_idx); 187| | 188| 3.75k| YR_STRING* string; 189| | 190| 3.75k| const char* string_identifier; 191| 3.75k| const char* target_identifier; 192| | 193| 3.75k| int matching = 0; 194| | 195| 3.75k| yr_rule_strings_foreach(current_rule, string) ------------------ | | 60| 1.13M| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 1.12M, False: 3.75k] | | ------------------ | | 61| 1.12M| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 1.12M|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 1.12M|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 3.69k, False: 1.12M] | | | | ------------------ | | ------------------ ------------------ 196| 1.12M| { 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| 1.12M| if (string->chained_to == NULL) ------------------ | Branch (200:9): [True: 1.12M, False: 3.71k] ------------------ 201| 1.12M| { 202| 1.12M| string_identifier = string->identifier; 203| 1.12M| target_identifier = identifier; 204| | 205| 2.24M| while (*target_identifier != '\0' && *string_identifier != '\0' && ------------------ | Branch (205:14): [True: 1.13M, False: 1.11M] | Branch (205:44): [True: 1.12M, False: 7.86k] ------------------ 206| 2.24M| *target_identifier == *string_identifier) ------------------ | Branch (206:14): [True: 1.12M, False: 82] ------------------ 207| 1.12M| { 208| 1.12M| target_identifier++; 209| 1.12M| string_identifier++; 210| 1.12M| } 211| | 212| 1.12M| if ((*target_identifier == '\0' && *string_identifier == '\0') || ------------------ | Branch (212:12): [True: 1.11M, False: 7.94k] | Branch (212:42): [True: 1.11M, False: 2.72k] ------------------ 213| 1.12M| *target_identifier == '*') ------------------ | Branch (213:11): [True: 7.77k, False: 2.88k] ------------------ 214| 1.12M| { 215| 1.12M| yr_parser_emit_with_arg_reloc(yyscanner, OP_PUSH, string, NULL, NULL); ------------------ | | 61| 1.12M|#define OP_PUSH 13 ------------------ 216| | 217| 1.12M| string->flags |= STRING_FLAGS_REFERENCED; ------------------ | | 66| 1.12M|#define STRING_FLAGS_REFERENCED 0x01 ------------------ 218| 1.12M| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 1.12M|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 219| 1.12M| matching++; 220| 1.12M| } 221| 1.12M| } 222| 1.12M| } 223| | 224| 3.75k| if (count != NULL) ------------------ | Branch (224:7): [True: 3.75k, False: 0] ------------------ 225| 3.75k| { 226| 3.75k| *count = matching; 227| 3.75k| } 228| | 229| 3.75k| if (matching == 0) ------------------ | Branch (229:7): [True: 70, False: 3.68k] ------------------ 230| 70| { 231| 70| yr_compiler_set_error_extra_info( ------------------ | | 298| 70| strlcpy( \ | | 299| 70| compiler->last_error_extra_info, \ | | 300| 70| info, \ | | 301| 70| sizeof(compiler->last_error_extra_info)); ------------------ 232| 70| compiler, identifier) return ERROR_UNDEFINED_STRING; ------------------ | | 64| 70|#define ERROR_UNDEFINED_STRING 19 ------------------ 233| 70| } 234| | 235| 3.68k| return ERROR_SUCCESS; ------------------ | | 40| 3.68k|#define ERROR_SUCCESS 0 ------------------ 236| 3.75k|} yr_parser_emit_pushes_for_rules: 244| 1.01k|{ 245| 1.01k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 1.01k|#define yyget_extra yara_yyget_extra ------------------ 246| | 247| | // Make sure the compiler is parsing a rule 248| 1.01k| assert(compiler->current_rule_idx != UINT32_MAX); 249| | 250| 1.01k| YR_RULE* rule; 251| 1.01k| int matching = 0; 252| | 253| 1.01k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 254| 1.01k| compiler->arena, 255| 1.01k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.01k|#define YR_NAMESPACES_TABLE 0 ------------------ 256| 1.01k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 257| | 258| | // Can't use yr_rules_foreach here as that requires the rules to have been 259| | // finalized (inserting a NULL rule at the end). This is done when 260| | // yr_compiler_get_rules() is called, which also inserts a HALT instruction 261| | // into the current position in the code arena. Obviously we aren't done 262| | // compiling the rules yet so inserting a HALT is a bad idea. To deal with 263| | // this I'm manually walking all the currently compiled rules (up to the 264| | // current rule index) and comparing identifiers to see if it is one we should 265| | // use. 266| | // 267| | // Further, we have to get compiler->current_rule_idx before we start because 268| | // if we emit an OP_PUSH_RULE 269| 1.01k| rule = yr_arena_get_ptr(compiler->arena, YR_RULES_TABLE, 0); ------------------ | | 58| 1.01k|#define YR_RULES_TABLE 1 ------------------ 270| | 271| 4.29k| for (uint32_t i = 0; i <= compiler->current_rule_idx; i++) ------------------ | Branch (271:24): [True: 3.27k, False: 1.01k] ------------------ 272| 3.27k| { 273| | // Is rule->identifier prefixed by prefix? 274| 3.27k| if (strncmp(prefix, rule->identifier, strlen(prefix)) == 0) ------------------ | Branch (274:9): [True: 1.14k, False: 2.13k] ------------------ 275| 1.14k| { 276| 1.14k| uint32_t rule_idx = yr_hash_table_lookup_uint32( 277| 1.14k| compiler->rules_table, rule->identifier, ns->name); 278| | 279| 1.14k| if (rule_idx != UINT32_MAX) ------------------ | Branch (279:11): [True: 1.14k, False: 0] ------------------ 280| 1.14k| { 281| 1.14k| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 131| 1.14k| { \ | | 132| 1.14k| int __error = (x); \ | | 133| 1.14k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.14k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.14k] | | ------------------ | | 134| 1.14k| return __error; \ | | 135| 1.14k| } ------------------ 282| 1.14k| yyscanner, OP_PUSH_RULE, rule_idx, NULL, NULL)); 283| 1.14k| matching++; 284| 1.14k| } 285| 1.14k| } 286| | 287| 3.27k| rule++; 288| 3.27k| } 289| | 290| 1.01k| if (count != NULL) ------------------ | Branch (290:7): [True: 1.01k, False: 0] ------------------ 291| 1.01k| { 292| 1.01k| *count = matching; 293| 1.01k| } 294| | 295| 1.01k| if (matching == 0) ------------------ | Branch (295:7): [True: 30, False: 984] ------------------ 296| 30| { 297| 30| yr_compiler_set_error_extra_info(compiler, prefix); ------------------ | | 298| 30| strlcpy( \ | | 299| 30| compiler->last_error_extra_info, \ | | 300| 30| info, \ | | 301| 30| sizeof(compiler->last_error_extra_info)); ------------------ 298| 30| return ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 30|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 299| 30| } 300| | 301| 984| return ERROR_SUCCESS; ------------------ | | 40| 984|#define ERROR_SUCCESS 0 ------------------ 302| 1.01k|} yr_parser_emit_push_const: 305| 32.8k|{ 306| 32.8k| uint8_t opcode[9]; 307| 32.8k| int opcode_len = 1; 308| | 309| 32.8k| if (argument == YR_UNDEFINED) ------------------ | | 38| 32.8k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (309:7): [True: 4.46k, False: 28.3k] ------------------ 310| 4.46k| { 311| 4.46k| opcode[0] = OP_PUSH_U; ------------------ | | 114| 4.46k|#define OP_PUSH_U 66 ------------------ 312| 4.46k| } 313| 28.3k| else if (argument <= 0xff) ------------------ | Branch (313:12): [True: 26.4k, False: 1.90k] ------------------ 314| 26.4k| { 315| 26.4k| opcode[0] = OP_PUSH_8; ------------------ | | 111| 26.4k|#define OP_PUSH_8 63 ------------------ 316| 26.4k| opcode[1] = (uint8_t) argument; 317| 26.4k| opcode_len += sizeof(uint8_t); 318| 26.4k| } 319| 1.90k| else if (argument <= 0xffff) ------------------ | Branch (319:12): [True: 982, False: 924] ------------------ 320| 982| { 321| 982| opcode[0] = OP_PUSH_16; ------------------ | | 112| 982|#define OP_PUSH_16 64 ------------------ 322| 982| uint16_t u = (uint16_t) argument; 323| 982| memcpy(opcode + 1, &u, sizeof(uint16_t)); 324| 982| opcode_len += sizeof(uint16_t); 325| 982| } 326| 924| else if (argument <= 0xffffffff) ------------------ | Branch (326:12): [True: 679, False: 245] ------------------ 327| 679| { 328| 679| opcode[0] = OP_PUSH_32; ------------------ | | 113| 679|#define OP_PUSH_32 65 ------------------ 329| 679| uint32_t u = (uint32_t) argument; 330| 679| memcpy(opcode + 1, &u, sizeof(uint32_t)); 331| 679| opcode_len += sizeof(uint32_t); 332| 679| } 333| 245| else 334| 245| { 335| 245| opcode[0] = OP_PUSH; ------------------ | | 61| 245|#define OP_PUSH 13 ------------------ 336| 245| memcpy(opcode + 1, &argument, sizeof(uint64_t)); 337| 245| opcode_len += sizeof(uint64_t); 338| 245| } 339| | 340| 32.8k| return yr_arena_write_data( 341| 32.8k| yyget_extra(yyscanner)->arena, YR_CODE_SECTION, opcode, opcode_len, NULL); ------------------ | | 55| 32.8k|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, opcode, opcode_len, NULL); ------------------ | | 63| 32.8k|#define YR_CODE_SECTION 6 ------------------ 342| 32.8k|} yr_parser_check_types: 348| 63|{ 349| 63| int i; 350| | 351| 63| for (i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 136| 63|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (351:15): [True: 63, False: 0] ------------------ 352| 63| { 353| 63| if (function->prototypes[i].arguments_fmt == NULL) ------------------ | Branch (353:9): [True: 0, False: 63] ------------------ 354| 0| break; 355| | 356| 63| if (strcmp(function->prototypes[i].arguments_fmt, actual_args_fmt) == 0) ------------------ | Branch (356:9): [True: 63, False: 0] ------------------ 357| 63| return ERROR_SUCCESS; ------------------ | | 40| 63|#define ERROR_SUCCESS 0 ------------------ 358| 63| } 359| | 360| 0| yr_compiler_set_error_extra_info(compiler, function->identifier) ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 361| | 362| 0| return ERROR_WRONG_ARGUMENTS; ------------------ | | 85| 0|#define ERROR_WRONG_ARGUMENTS 40 ------------------ 363| 63|} yr_parser_lookup_string: 369| 1.41k|{ 370| 1.41k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 1.41k|#define yyget_extra yara_yyget_extra ------------------ 371| | 372| 1.41k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 373| 1.41k| compiler, compiler->current_rule_idx); 374| | 375| 1.41k| yr_rule_strings_foreach(current_rule, *string) ------------------ | | 60| 1.81k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 1.79k, False: 22] | | ------------------ | | 61| 1.41k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 395|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 395|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 11, False: 384] | | | | ------------------ | | ------------------ ------------------ 376| 1.79k| { 377| | // If some string $a gets fragmented into multiple chained 378| | // strings, all those fragments have the same $a identifier 379| | // but we are interested in the heading fragment, which is 380| | // that with chained_to == NULL 381| | 382| 1.79k| if ((*string)->chained_to == NULL && ------------------ | Branch (382:9): [True: 1.53k, False: 256] ------------------ 383| 1.79k| strcmp((*string)->identifier, identifier) == 0) ------------------ | Branch (383:9): [True: 1.39k, False: 139] ------------------ 384| 1.39k| { 385| 1.39k| return ERROR_SUCCESS; ------------------ | | 40| 1.39k|#define ERROR_SUCCESS 0 ------------------ 386| 1.39k| } 387| 1.79k| } 388| | 389| 22| yr_compiler_set_error_extra_info(compiler, identifier) ------------------ | | 298| 22| strlcpy( \ | | 299| 22| compiler->last_error_extra_info, \ | | 300| 22| info, \ | | 301| 22| sizeof(compiler->last_error_extra_info)); ------------------ 390| | 391| 22| * string = NULL; 392| | 393| 22| return ERROR_UNDEFINED_STRING; ------------------ | | 64| 22|#define ERROR_UNDEFINED_STRING 19 ------------------ 394| 1.41k|} yr_parser_lookup_loop_variable: 415| 13.0k|{ 416| 13.0k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 13.0k|#define yyget_extra yara_yyget_extra ------------------ 417| 13.0k| int i, j; 418| 13.0k| int var_offset = 0; 419| | 420| 16.2k| for (i = 0; i <= compiler->loop_index; i++) ------------------ | Branch (420:15): [True: 10.4k, False: 5.74k] ------------------ 421| 10.4k| { 422| 10.4k| var_offset += compiler->loop[i].vars_internal_count; 423| | 424| 18.3k| for (j = 0; j < compiler->loop[i].vars_count; j++) ------------------ | Branch (424:17): [True: 15.1k, False: 3.21k] ------------------ 425| 15.1k| { 426| 15.1k| if (compiler->loop[i].vars[j].identifier.ptr != NULL && ------------------ | Branch (426:11): [True: 15.0k, False: 129] ------------------ 427| 15.1k| strcmp(identifier, compiler->loop[i].vars[j].identifier.ptr) == 0) ------------------ | Branch (427:11): [True: 7.27k, False: 7.76k] ------------------ 428| 7.27k| { 429| 7.27k| if (expr != NULL) ------------------ | Branch (429:13): [True: 7.21k, False: 59] ------------------ 430| 7.21k| *expr = compiler->loop[i].vars[j]; 431| | 432| 7.27k| return var_offset + j; 433| 7.27k| } 434| 15.1k| } 435| | 436| 3.21k| var_offset += compiler->loop[i].vars_count; 437| 3.21k| } 438| | 439| 5.74k| return -1; 440| 13.0k|} yr_parser_reduce_string_declaration: 654| 22.4k|{ 655| 22.4k| int result = ERROR_SUCCESS; ------------------ | | 40| 22.4k|#define ERROR_SUCCESS 0 ------------------ 656| 22.4k| int min_atom_quality = YR_MAX_ATOM_QUALITY; ------------------ | | 72| 22.4k|#define YR_MAX_ATOM_QUALITY 255 ------------------ 657| 22.4k| int atom_quality; 658| | 659| 22.4k| char message[512]; 660| | 661| 22.4k| int32_t min_gap = 0; 662| 22.4k| int32_t max_gap = 0; 663| | 664| 22.4k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 22.4k|#define yyget_extra yara_yyget_extra ------------------ 665| | 666| 22.4k| RE_AST* re_ast = NULL; 667| 22.4k| RE_AST* remainder_re_ast = NULL; 668| 22.4k| RE_ERROR re_error; 669| | 670| 22.4k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 671| 22.4k| compiler, compiler->current_rule_idx); 672| | 673| | // Determine if a string with the same identifier was already defined 674| | // by searching for the identifier in strings_table. 675| 22.4k| uint32_t string_idx = yr_hash_table_lookup_uint32( 676| 22.4k| compiler->strings_table, identifier, NULL); 677| | 678| | // The string was already defined, return an error. 679| 22.4k| if (string_idx != UINT32_MAX) ------------------ | Branch (679:7): [True: 8, False: 22.4k] ------------------ 680| 8| { 681| 8| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 298| 8| strlcpy( \ | | 299| 8| compiler->last_error_extra_info, \ | | 300| 8| info, \ | | 301| 8| sizeof(compiler->last_error_extra_info)); ------------------ 682| 8| return ERROR_DUPLICATED_STRING_IDENTIFIER; ------------------ | | 62| 8|#define ERROR_DUPLICATED_STRING_IDENTIFIER 17 ------------------ 683| 8| } 684| | 685| | // Empty strings are not allowed. 686| 22.4k| if (str->length == 0) ------------------ | Branch (686:7): [True: 8, False: 22.4k] ------------------ 687| 8| { 688| 8| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 298| 8| strlcpy( \ | | 299| 8| compiler->last_error_extra_info, \ | | 300| 8| info, \ | | 301| 8| sizeof(compiler->last_error_extra_info)); ------------------ 689| 8| return ERROR_EMPTY_STRING; ------------------ | | 88| 8|#define ERROR_EMPTY_STRING 43 ------------------ 690| 8| } 691| | 692| 22.4k| if (str->flags & SIZED_STRING_FLAGS_NO_CASE) ------------------ | | 39| 22.4k|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ | Branch (692:7): [True: 2.98k, False: 19.4k] ------------------ 693| 2.98k| modifier.flags |= STRING_FLAGS_NO_CASE; ------------------ | | 68| 2.98k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 694| | 695| 22.4k| if (str->flags & SIZED_STRING_FLAGS_DOT_ALL) ------------------ | | 43| 22.4k|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ | Branch (695:7): [True: 295, False: 22.1k] ------------------ 696| 295| modifier.flags |= STRING_FLAGS_DOT_ALL; ------------------ | | 83| 295|#define STRING_FLAGS_DOT_ALL 0x20000 ------------------ 697| | 698| | // Hex strings are always handled as DOT_ALL regexps. 699| 22.4k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL) ------------------ | | 67| 22.4k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (699:7): [True: 1.07k, False: 21.3k] ------------------ 700| 1.07k| modifier.flags |= STRING_FLAGS_DOT_ALL; ------------------ | | 83| 1.07k|#define STRING_FLAGS_DOT_ALL 0x20000 ------------------ 701| | 702| 22.4k| if (!(modifier.flags & STRING_FLAGS_WIDE) && ------------------ | | 70| 22.4k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (702:7): [True: 20.9k, False: 1.42k] ------------------ 703| 22.4k| !(modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 41.9k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (703:9): [True: 1.00k, False: 19.9k] ------------------ 704| 20.9k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 19.9k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (704:9): [True: 690, False: 19.2k] ------------------ 705| 19.2k| { 706| 19.2k| modifier.flags |= STRING_FLAGS_ASCII; ------------------ | | 69| 19.2k|#define STRING_FLAGS_ASCII 0x08 ------------------ 707| 19.2k| } 708| | 709| | // The STRING_FLAGS_SINGLE_MATCH flag indicates that finding 710| | // a single match for the string is enough. This is true in 711| | // most cases, except when the string count (#) and string offset (@) 712| | // operators are used. All strings are marked STRING_FLAGS_SINGLE_MATCH 713| | // initially, and unmarked later if required. 714| 22.4k| modifier.flags |= STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 22.4k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 715| | 716| | // The STRING_FLAGS_FIXED_OFFSET indicates that the string doesn't 717| | // need to be searched all over the file because the user is using the 718| | // "at" operator. The string must be searched at a fixed offset in the 719| | // file. All strings are marked STRING_FLAGS_FIXED_OFFSET initially, 720| | // and unmarked later if required. 721| 22.4k| modifier.flags |= STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 22.4k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 722| | 723| | // If string identifier is $ this is an anonymous string, if not add the 724| | // identifier to strings_table. 725| 22.4k| if (strcmp(identifier, "$") == 0) ------------------ | Branch (725:7): [True: 22.0k, False: 395] ------------------ 726| 22.0k| { 727| 22.0k| modifier.flags |= STRING_FLAGS_ANONYMOUS; ------------------ | | 74| 22.0k|#define STRING_FLAGS_ANONYMOUS 0x100 ------------------ 728| 22.0k| } 729| 395| else 730| 395| { 731| 395| FAIL_ON_ERROR(yr_hash_table_add_uint32( ------------------ | | 131| 395| { \ | | 132| 395| int __error = (x); \ | | 133| 395| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 395|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 395] | | ------------------ | | 134| 395| return __error; \ | | 135| 395| } ------------------ 732| 395| compiler->strings_table, 733| 395| identifier, 734| 395| NULL, 735| 395| compiler->current_string_idx)); 736| 395| } 737| | 738| | // Make sure that the the string does not have an invalid combination of 739| | // modifiers. 740| 22.4k| FAIL_ON_ERROR(_yr_parser_check_string_modifiers(yyscanner, modifier)); ------------------ | | 131| 22.4k| { \ | | 132| 22.4k| int __error = (x); \ | | 133| 22.4k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 22.4k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 9, False: 22.3k] | | ------------------ | | 134| 22.4k| return __error; \ | | 135| 22.4k| } ------------------ 741| | 742| 22.3k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL || ------------------ | | 67| 44.7k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (742:7): [True: 1.07k, False: 21.3k] ------------------ 743| 22.3k| modifier.flags & STRING_FLAGS_REGEXP || ------------------ | | 71| 43.7k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (743:7): [True: 17.1k, False: 4.12k] ------------------ 744| 22.3k| modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 26.5k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (744:7): [True: 1.39k, False: 2.73k] ------------------ 745| 22.3k| modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 2.73k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (745:7): [True: 969, False: 1.76k] ------------------ 746| 20.6k| { 747| 20.6k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL) ------------------ | | 67| 20.6k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (747:9): [True: 1.07k, False: 19.5k] ------------------ 748| 1.07k| result = yr_re_parse_hex(str->c_string, &re_ast, &re_error); 749| 19.5k| else if (modifier.flags & STRING_FLAGS_REGEXP) ------------------ | | 71| 19.5k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (749:14): [True: 17.1k, False: 2.36k] ------------------ 750| 17.1k| result = yr_re_parse(str->c_string, &re_ast, &re_error); 751| 2.36k| else 752| 2.36k| result = yr_base64_ast_from_string(str, modifier, &re_ast, &re_error); 753| | 754| 20.6k| if (result != ERROR_SUCCESS) ------------------ | | 40| 20.6k|#define ERROR_SUCCESS 0 ------------------ | Branch (754:9): [True: 350, False: 20.2k] ------------------ 755| 350| { 756| 350| snprintf( 757| 350| message, 758| 350| sizeof(message), 759| 350| "invalid %s \"%s\": %s", 760| 350| (modifier.flags & STRING_FLAGS_HEXADECIMAL) ? "hex string" ------------------ | | 67| 350|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (760:11): [True: 252, False: 98] ------------------ 761| 350| : "regular expression", 762| 350| identifier, 763| 350| re_error.message); 764| | 765| 350| yr_compiler_set_error_extra_info(compiler, message); ------------------ | | 298| 350| strlcpy( \ | | 299| 350| compiler->last_error_extra_info, \ | | 300| 350| info, \ | | 301| 350| sizeof(compiler->last_error_extra_info)); ------------------ 766| 350| goto _exit; 767| 350| } 768| | 769| 20.2k| if (re_ast->flags & RE_FLAGS_FAST_REGEXP) ------------------ | | 94| 20.2k|#define RE_FLAGS_FAST_REGEXP 0x02 ------------------ | Branch (769:9): [True: 819, False: 19.4k] ------------------ 770| 819| modifier.flags |= STRING_FLAGS_FAST_REGEXP; ------------------ | | 72| 819|#define STRING_FLAGS_FAST_REGEXP 0x40 ------------------ 771| | 772| 20.2k| if (re_ast->flags & RE_FLAGS_GREEDY) ------------------ | | 101| 20.2k|#define RE_FLAGS_GREEDY 0x400 ------------------ | Branch (772:9): [True: 1.09k, False: 19.1k] ------------------ 773| 1.09k| modifier.flags |= STRING_FLAGS_GREEDY_REGEXP; ------------------ | | 82| 1.09k|#define STRING_FLAGS_GREEDY_REGEXP 0x10000 ------------------ 774| | 775| | // Regular expressions in the strings section can't mix greedy and 776| | // ungreedy quantifiers like .* and .*?. That's because these regular 777| | // expressions can be matched forwards and/or backwards depending on the 778| | // atom found, and we need the regexp to be all-greedy or all-ungreedy to 779| | // be able to properly calculate the length of the match. 780| | 781| 20.2k| if ((re_ast->flags & RE_FLAGS_GREEDY) && ------------------ | | 101| 20.2k|#define RE_FLAGS_GREEDY 0x400 ------------------ | Branch (781:9): [True: 1.09k, False: 19.1k] ------------------ 782| 20.2k| (re_ast->flags & RE_FLAGS_UNGREEDY)) ------------------ | | 102| 1.09k|#define RE_FLAGS_UNGREEDY 0x800 ------------------ | Branch (782:9): [True: 4, False: 1.08k] ------------------ 783| 4| { 784| 4| result = ERROR_INVALID_REGULAR_EXPRESSION; ------------------ | | 54| 4|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ 785| | 786| 4| yr_compiler_set_error_extra_info( ------------------ | | 298| 4| strlcpy( \ | | 299| 4| compiler->last_error_extra_info, \ | | 300| 4| info, \ | | 301| 4| sizeof(compiler->last_error_extra_info)); ------------------ 787| 4| compiler, 788| 4| "greedy and ungreedy quantifiers can't be mixed in a regular " 789| 4| "expression"); 790| | 791| 4| goto _exit; 792| 4| } 793| | 794| 20.2k| if (yr_re_ast_has_unbounded_quantifier_for_dot(re_ast)) ------------------ | Branch (794:9): [True: 760, False: 19.5k] ------------------ 795| 760| { 796| 760| yywarning( ------------------ | | 51| 760|#define yywarning yara_yywarning ------------------ 797| 760| yyscanner, 798| 760| "%s contains .*, .+ or .{x,} consider using .{,N}, .{1,N} or {x,N} " 799| 760| "with a reasonable value for N", 800| 760| identifier); 801| 760| } 802| | 803| 20.2k| if (compiler->re_ast_callback != NULL) ------------------ | Branch (803:9): [True: 0, False: 20.2k] ------------------ 804| 0| { 805| 0| compiler->re_ast_callback( 806| 0| current_rule, identifier, re_ast, compiler->re_ast_clbk_user_data); 807| 0| } 808| | 809| 20.2k| *string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 20.2k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 810| | 811| 43.4k| while (re_ast != NULL) ------------------ | Branch (811:12): [True: 23.2k, False: 20.2k] ------------------ 812| 23.2k| { 813| 23.2k| YR_ARENA_REF ref; 814| | 815| 23.2k| uint32_t prev_string_idx = compiler->current_string_idx - 1; 816| | 817| 23.2k| int32_t prev_min_gap = min_gap; 818| 23.2k| int32_t prev_max_gap = max_gap; 819| | 820| 23.2k| result = yr_re_ast_split_at_chaining_point( 821| 23.2k| re_ast, &remainder_re_ast, &min_gap, &max_gap); 822| | 823| 23.2k| if (result != ERROR_SUCCESS) ------------------ | | 40| 23.2k|#define ERROR_SUCCESS 0 ------------------ | Branch (823:11): [True: 0, False: 23.2k] ------------------ 824| 0| goto _exit; 825| | 826| 23.2k| result = _yr_parser_write_string( 827| 23.2k| identifier, 828| 23.2k| modifier, 829| 23.2k| compiler, 830| 23.2k| NULL, 831| 23.2k| re_ast, 832| 23.2k| &ref, 833| 23.2k| &atom_quality, 834| 23.2k| ¤t_rule->num_atoms); 835| | 836| 23.2k| if (result != ERROR_SUCCESS) ------------------ | | 40| 23.2k|#define ERROR_SUCCESS 0 ------------------ | Branch (836:11): [True: 70, False: 23.1k] ------------------ 837| 70| goto _exit; 838| | 839| 23.1k| if (atom_quality < min_atom_quality) ------------------ | Branch (839:11): [True: 18.5k, False: 4.55k] ------------------ 840| 18.5k| min_atom_quality = atom_quality; 841| | 842| 23.1k| if (YR_ARENA_IS_NULL_REF(*string_ref)) ------------------ | | 46| 23.1k| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 23.1k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 23.1k| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } | | ------------------ | | | Branch (46:3): [True: 20.2k, False: 2.95k] | | ------------------ ------------------ 843| 20.2k| { 844| | // This is the first string in the chain, the string reference 845| | // returned by this function must point to this string. 846| 20.2k| *string_ref = ref; 847| 20.2k| } 848| 2.95k| else 849| 2.95k| { 850| | // This is not the first string in the chain, set the appropriate 851| | // flags and fill the chained_to, chain_gap_min and chain_gap_max 852| | // fields. 853| 2.95k| YR_STRING* prev_string = (YR_STRING*) yr_arena_get_ptr( 854| 2.95k| compiler->arena, 855| 2.95k| YR_STRINGS_TABLE, ------------------ | | 60| 2.95k|#define YR_STRINGS_TABLE 3 ------------------ 856| 2.95k| prev_string_idx * sizeof(YR_STRING)); 857| | 858| 2.95k| YR_STRING* new_string = (YR_STRING*) yr_arena_ref_to_ptr( 859| 2.95k| compiler->arena, &ref); 860| | 861| 2.95k| new_string->chained_to = prev_string; 862| 2.95k| new_string->chain_gap_min = prev_min_gap; 863| 2.95k| new_string->chain_gap_max = prev_max_gap; 864| | 865| | // A string chained to another one can't have a fixed offset, only the 866| | // head of the string chain can have a fixed offset. 867| 2.95k| new_string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 2.95k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 868| | 869| | // There is a previous string, but that string wasn't marked as part 870| | // of a chain because we can't do that until knowing there will be 871| | // another string, let's flag it now the we know. 872| 2.95k| prev_string->flags |= STRING_FLAGS_CHAIN_PART; ------------------ | | 79| 2.95k|#define STRING_FLAGS_CHAIN_PART 0x2000 ------------------ 873| | 874| | // There is a previous string, so this string is part of a chain, but 875| | // there will be no more strings because there are no more AST to 876| | // split, which means that this is the chain's tail. 877| 2.95k| if (remainder_re_ast == NULL) ------------------ | Branch (877:13): [True: 226, False: 2.72k] ------------------ 878| 226| new_string->flags |= STRING_FLAGS_CHAIN_PART | ------------------ | | 79| 226|#define STRING_FLAGS_CHAIN_PART 0x2000 ------------------ 879| 226| STRING_FLAGS_CHAIN_TAIL; ------------------ | | 80| 226|#define STRING_FLAGS_CHAIN_TAIL 0x4000 ------------------ 880| 2.95k| } 881| | 882| 23.1k| yr_re_ast_destroy(re_ast); 883| 23.1k| re_ast = remainder_re_ast; 884| 23.1k| } 885| 20.2k| } 886| 1.76k| else // not a STRING_FLAGS_HEXADECIMAL or STRING_FLAGS_REGEXP or 887| | // STRING_FLAGS_BASE64 or STRING_FLAGS_BASE64_WIDE 888| 1.76k| { 889| 1.76k| result = _yr_parser_write_string( 890| 1.76k| identifier, 891| 1.76k| modifier, 892| 1.76k| compiler, 893| 1.76k| str, 894| 1.76k| NULL, 895| 1.76k| string_ref, 896| 1.76k| &min_atom_quality, 897| 1.76k| ¤t_rule->num_atoms); 898| | 899| 1.76k| if (result != ERROR_SUCCESS) ------------------ | | 40| 1.76k|#define ERROR_SUCCESS 0 ------------------ | Branch (899:9): [True: 0, False: 1.76k] ------------------ 900| 0| goto _exit; 901| 1.76k| } 902| | 903| 21.9k| if (min_atom_quality < compiler->atoms_config.quality_warning_threshold) ------------------ | Branch (903:7): [True: 5.56k, False: 16.4k] ------------------ 904| 5.56k| { 905| 5.56k| yywarning(yyscanner, "string \"%s\" may slow down scanning", identifier); ------------------ | | 51| 5.56k|#define yywarning yara_yywarning ------------------ 906| 5.56k| } 907| | 908| 22.3k|_exit: 909| | 910| 22.3k| if (re_ast != NULL) ------------------ | Branch (910:7): [True: 326, False: 22.0k] ------------------ 911| 326| yr_re_ast_destroy(re_ast); 912| | 913| 22.3k| if (remainder_re_ast != NULL) ------------------ | Branch (913:7): [True: 0, False: 22.3k] ------------------ 914| 0| yr_re_ast_destroy(remainder_re_ast); 915| | 916| 22.3k| return result; 917| 21.9k|} yr_parser_reduce_rule_declaration_phase_1: 939| 12.5k|{ 940| 12.5k| int result; 941| 12.5k| YR_FIXUP* fixup; 942| 12.5k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 12.5k|#define yyget_extra yara_yyget_extra ------------------ 943| | 944| 12.5k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 945| 12.5k| compiler->arena, 946| 12.5k| YR_NAMESPACES_TABLE, ------------------ | | 57| 12.5k|#define YR_NAMESPACES_TABLE 0 ------------------ 947| 12.5k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 948| | 949| 12.5k| if (yr_hash_table_lookup_uint32( ------------------ | Branch (949:7): [True: 4.81k, False: 7.77k] ------------------ 950| 12.5k| compiler->rules_table, identifier, ns->name) != UINT32_MAX || 951| 12.5k| yr_hash_table_lookup(compiler->objects_table, identifier, NULL) != NULL) ------------------ | Branch (951:7): [True: 0, False: 7.77k] ------------------ 952| 4.81k| { 953| | // A rule or variable with the same identifier already exists, return the 954| | // appropriate error. 955| | 956| 4.81k| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 298| 4.81k| strlcpy( \ | | 299| 4.81k| compiler->last_error_extra_info, \ | | 300| 4.81k| info, \ | | 301| 4.81k| sizeof(compiler->last_error_extra_info)); ------------------ 957| 4.81k| return ERROR_DUPLICATED_IDENTIFIER; ------------------ | | 59| 4.81k|#define ERROR_DUPLICATED_IDENTIFIER 14 ------------------ 958| 4.81k| } 959| | 960| | // Iterate over all identifiers in wildcard_identifiers_table, and check if 961| | // any of them are a prefix of the identifier being declared. If so, return 962| | // ERROR_IDENTIFIER_MATCHES_WILDCARD. 963| 7.77k| result = yr_hash_table_iterate( 964| 7.77k| compiler->wildcard_identifiers_table, 965| 7.77k| ns->name, 966| 7.77k| wildcard_iterator, 967| 7.77k| (void*) identifier); 968| | 969| 7.77k| if (result == ERROR_IDENTIFIER_MATCHES_WILDCARD) ------------------ | | 108| 7.77k|#define ERROR_IDENTIFIER_MATCHES_WILDCARD 63 ------------------ | Branch (969:7): [True: 978, False: 6.80k] ------------------ 970| 978| { 971| | // This rule matches an existing wildcard rule set. 972| 978| yr_compiler_set_error_extra_info(compiler, identifier); ------------------ | | 298| 978| strlcpy( \ | | 299| 978| compiler->last_error_extra_info, \ | | 300| 978| info, \ | | 301| 978| sizeof(compiler->last_error_extra_info)); ------------------ 973| 978| } 974| | 975| 7.77k| FAIL_ON_ERROR(result); ------------------ | | 131| 7.77k| { \ | | 132| 7.77k| int __error = (x); \ | | 133| 7.77k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7.77k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 978, False: 6.80k] | | ------------------ | | 134| 7.77k| return __error; \ | | 135| 7.77k| } ------------------ 976| | 977| 6.80k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 6.80k| { \ | | 132| 6.80k| int __error = (x); \ | | 133| 6.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 6.80k] | | ------------------ | | 134| 6.80k| return __error; \ | | 135| 6.80k| } ------------------ 978| 6.80k| compiler->arena, 979| 6.80k| YR_RULES_TABLE, 980| 6.80k| sizeof(YR_RULE), 981| 6.80k| rule_ref, 982| 6.80k| offsetof(YR_RULE, identifier), 983| 6.80k| offsetof(YR_RULE, tags), 984| 6.80k| offsetof(YR_RULE, strings), 985| 6.80k| offsetof(YR_RULE, metas), 986| 6.80k| offsetof(YR_RULE, ns), 987| 6.80k| EOL)); 988| | 989| 6.80k| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr(compiler->arena, rule_ref); 990| | 991| 6.80k| YR_ARENA_REF ref; 992| | 993| 6.80k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 131| 6.80k| { \ | | 132| 6.80k| int __error = (x); \ | | 133| 6.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 6.80k] | | ------------------ | | 134| 6.80k| return __error; \ | | 135| 6.80k| } ------------------ 994| | 995| 6.80k| rule->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 996| 6.80k| rule->flags = flags; 997| 6.80k| rule->ns = ns; 998| 6.80k| rule->num_atoms = 0; 999| | 1000| 6.80k| YR_ARENA_REF jmp_offset_ref; 1001| | 1002| | // We are starting to parse a new rule, set current_rule_idx accordingly. 1003| 6.80k| compiler->current_rule_idx = compiler->next_rule_idx; 1004| 6.80k| compiler->next_rule_idx++; 1005| | 1006| | // The OP_INIT_RULE instruction behaves like a jump. When the rule is 1007| | // disabled it skips over the rule's code and go straight to the next rule's 1008| | // code. The jmp_offset_ref variable points to the jump's offset. The offset 1009| | // is set to 0 as we don't know the jump target yet. When we finish 1010| | // generating the rule's code in yr_parser_reduce_rule_declaration_phase_2 1011| | // the jump offset is set to its final value. 1012| | 1013| 6.80k| FAIL_ON_ERROR(yr_parser_emit_with_arg_int32( ------------------ | | 131| 6.80k| { \ | | 132| 6.80k| int __error = (x); \ | | 133| 6.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 6.80k] | | ------------------ | | 134| 6.80k| return __error; \ | | 135| 6.80k| } ------------------ 1014| 6.80k| yyscanner, OP_INIT_RULE, 0, NULL, &jmp_offset_ref)); 1015| | 1016| 6.80k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 6.80k| { \ | | 132| 6.80k| int __error = (x); \ | | 133| 6.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 6.80k] | | ------------------ | | 134| 6.80k| return __error; \ | | 135| 6.80k| } ------------------ 1017| 6.80k| compiler->arena, 1018| 6.80k| YR_CODE_SECTION, 1019| 6.80k| &compiler->current_rule_idx, 1020| 6.80k| sizeof(compiler->current_rule_idx), 1021| 6.80k| NULL)); 1022| | 1023| | // Create a fixup entry for the jump and push it in the stack 1024| 6.80k| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 1025| | 1026| 6.80k| if (fixup == NULL) ------------------ | Branch (1026:7): [True: 0, False: 6.80k] ------------------ 1027| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 1028| | 1029| 6.80k| fixup->ref = jmp_offset_ref; 1030| 6.80k| fixup->next = compiler->fixup_stack_head; 1031| 6.80k| compiler->fixup_stack_head = fixup; 1032| | 1033| | // Clean strings_table as we are starting to parse a new rule. 1034| 6.80k| yr_hash_table_clean(compiler->strings_table, NULL); 1035| | 1036| 6.80k| FAIL_ON_ERROR(yr_hash_table_add_uint32( ------------------ | | 131| 6.80k| { \ | | 132| 6.80k| int __error = (x); \ | | 133| 6.80k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 6.80k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 6.80k] | | ------------------ | | 134| 6.80k| return __error; \ | | 135| 6.80k| } ------------------ 1037| 6.80k| compiler->rules_table, identifier, ns->name, compiler->current_rule_idx)); 1038| | 1039| 6.80k| return ERROR_SUCCESS; ------------------ | | 40| 6.80k|#define ERROR_SUCCESS 0 ------------------ 1040| 6.80k|} yr_parser_reduce_rule_declaration_phase_2: 1045| 120|{ 1046| 120| uint32_t max_strings_per_rule; 1047| 120| uint32_t strings_in_rule = 0; 1048| | 1049| 120| YR_FIXUP* fixup; 1050| 120| YR_STRING* string; 1051| 120| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 120|#define yyget_extra yara_yyget_extra ------------------ 1052| | 1053| 120| yr_get_configuration_uint32( 1054| 120| YR_CONFIG_MAX_STRINGS_PER_RULE, &max_strings_per_rule); 1055| | 1056| 120| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr(compiler->arena, rule_ref); 1057| | 1058| | // Show warning if the rule is generating too many atoms. The warning is 1059| | // shown if the number of atoms is greater than 20 times the maximum number 1060| | // of strings allowed for a rule, as 20 is minimum number of atoms generated 1061| | // for a string using *nocase*, *ascii* and *wide* modifiers simultaneously. 1062| | 1063| 120| if (rule->num_atoms > YR_ATOMS_PER_RULE_WARNING_THRESHOLD) ------------------ | | 90| 120|#define YR_ATOMS_PER_RULE_WARNING_THRESHOLD 12000 ------------------ | Branch (1063:7): [True: 20, False: 100] ------------------ 1064| 20| { 1065| 20| yywarning(yyscanner, "rule is slowing down scanning"); ------------------ | | 51| 20|#define yywarning yara_yywarning ------------------ 1066| 20| } 1067| | 1068| 120| yr_rule_strings_foreach(rule, string) ------------------ | | 60| 7.68k| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 7.57k, False: 119] | | ------------------ | | 61| 7.56k| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 7.56k|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 7.56k|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 72, False: 7.49k] | | | | ------------------ | | ------------------ ------------------ 1069| 7.57k| { 1070| | // Only the heading fragment in a chain of strings (the one with 1071| | // chained_to == NULL) must be referenced. All other fragments 1072| | // are never marked as referenced. 1073| | 1074| 7.57k| if (!STRING_IS_REFERENCED(string) && string->chained_to == NULL) ------------------ | | 108| 15.1k|#define STRING_IS_REFERENCED(x) (((x)->flags) & STRING_FLAGS_REFERENCED) | | ------------------ | | | | 66| 7.57k|#define STRING_FLAGS_REFERENCED 0x01 | | ------------------ ------------------ | Branch (1074:9): [True: 162, False: 7.40k] | Branch (1074:42): [True: 1, False: 161] ------------------ 1075| 1| { 1076| 1| yr_compiler_set_error_extra_info( ------------------ | | 298| 1| strlcpy( \ | | 299| 1| compiler->last_error_extra_info, \ | | 300| 1| info, \ | | 301| 1| sizeof(compiler->last_error_extra_info)); ------------------ 1077| 1| compiler, string->identifier) return ERROR_UNREFERENCED_STRING; ------------------ | | 63| 1|#define ERROR_UNREFERENCED_STRING 18 ------------------ 1078| 1| } 1079| | 1080| 7.56k| strings_in_rule++; 1081| | 1082| 7.56k| if (strings_in_rule > max_strings_per_rule) ------------------ | Branch (1082:9): [True: 0, False: 7.56k] ------------------ 1083| 0| { 1084| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1085| 0| compiler, rule->identifier) return ERROR_TOO_MANY_STRINGS; ------------------ | | 96| 0|#define ERROR_TOO_MANY_STRINGS 51 ------------------ 1086| 0| } 1087| 7.56k| } 1088| | 1089| 119| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 131| 119| { \ | | 132| 119| int __error = (x); \ | | 133| 119| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 119|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 119] | | ------------------ | | 134| 119| return __error; \ | | 135| 119| } ------------------ 1090| 119| yyscanner, OP_MATCH_RULE, compiler->current_rule_idx, NULL, NULL)); 1091| | 1092| 119| fixup = compiler->fixup_stack_head; 1093| | 1094| 119| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 1095| 119| compiler->arena, &fixup->ref); 1096| | 1097| 119| int32_t jmp_offset = yr_arena_get_current_offset( 1098| 119| compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 119|#define YR_CODE_SECTION 6 ------------------ 1099| 119| fixup->ref.offset + 1; 1100| | 1101| 119| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 1102| | 1103| | // Remove fixup from the stack. 1104| 119| compiler->fixup_stack_head = fixup->next; 1105| 119| yr_free(fixup); 1106| | 1107| | // We have finished parsing the current rule set current_rule_idx to 1108| | // UINT32_MAX indicating that we are not currently parsing a rule. 1109| 119| compiler->current_rule_idx = UINT32_MAX; 1110| | 1111| 119| return ERROR_SUCCESS; ------------------ | | 40| 119|#define ERROR_SUCCESS 0 ------------------ 1112| 119|} yr_parser_reduce_string_identifier: 1119| 8.77k|{ 1120| 8.77k| YR_STRING* string; 1121| 8.77k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 8.77k|#define yyget_extra yara_yyget_extra ------------------ 1122| | 1123| 8.77k| if (strcmp(identifier, "$") == 0) // is an anonymous string ? ------------------ | Branch (1123:7): [True: 7.35k, False: 1.41k] ------------------ 1124| 7.35k| { 1125| 7.35k| if (compiler->loop_for_of_var_index >= 0) // inside a loop ? ------------------ | Branch (1125:9): [True: 7.31k, False: 40] ------------------ 1126| 7.31k| { 1127| 7.31k| yr_parser_emit_with_arg( 1128| 7.31k| yyscanner, OP_PUSH_M, compiler->loop_for_of_var_index, NULL, NULL); ------------------ | | 82| 7.31k|#define OP_PUSH_M 34 ------------------ 1129| | 1130| 7.31k| yr_parser_emit(yyscanner, instruction, NULL); 1131| | 1132| 7.31k| YR_RULE* current_rule = _yr_compiler_get_rule_by_idx( 1133| 7.31k| compiler, compiler->current_rule_idx); 1134| | 1135| 7.31k| yr_rule_strings_foreach(current_rule, string) ------------------ | | 60| 1.08M| for (string = rule->strings; string != NULL; \ | | ------------------ | | | Branch (60:32): [True: 1.07M, False: 7.31k] | | ------------------ | | 61| 1.07M| string = STRING_IS_LAST_IN_RULE(string) ? NULL : string + 1) | | ------------------ | | | | 122| 1.07M|#define STRING_IS_LAST_IN_RULE(x) (((x)->flags) & STRING_FLAGS_LAST_IN_RULE) | | | | ------------------ | | | | | | 78| 1.07M|#define STRING_FLAGS_LAST_IN_RULE 0x1000 | | | | ------------------ | | | | | Branch (122:35): [True: 4.71k, False: 1.07M] | | | | ------------------ | | ------------------ ------------------ 1136| 1.07M| { 1137| 1.07M| if (instruction != OP_FOUND) ------------------ | | 70| 1.07M|#define OP_FOUND 22 ------------------ | Branch (1137:13): [True: 1.07M, False: 224] ------------------ 1138| 1.07M| string->flags &= ~STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 1.07M|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 1139| | 1140| 1.07M| if (instruction == OP_FOUND_AT) ------------------ | | 71| 1.07M|#define OP_FOUND_AT 23 ------------------ | Branch (1140:13): [True: 134, False: 1.07M] ------------------ 1141| 134| { 1142| | // Avoid overwriting any previous fixed offset 1143| 134| if (string->fixed_offset == YR_UNDEFINED) ------------------ | | 38| 134|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1143:15): [True: 3, False: 131] ------------------ 1144| 3| string->fixed_offset = at_offset; 1145| | 1146| | // If a previous fixed offset was different, disable 1147| | // the STRING_GFLAGS_FIXED_OFFSET flag because we only 1148| | // have room to store a single fixed offset value 1149| 134| if (string->fixed_offset != at_offset) ------------------ | Branch (1149:15): [True: 128, False: 6] ------------------ 1150| 128| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 128|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1151| 134| } 1152| 1.07M| else 1153| 1.07M| { 1154| 1.07M| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 1.07M|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1155| 1.07M| } 1156| 1.07M| } 1157| 7.31k| } 1158| 40| else 1159| 40| { 1160| | // Anonymous strings not allowed outside of a loop 1161| 40| return ERROR_MISPLACED_ANONYMOUS_STRING; ------------------ | | 66| 40|#define ERROR_MISPLACED_ANONYMOUS_STRING 21 ------------------ 1162| 40| } 1163| 7.35k| } 1164| 1.41k| else 1165| 1.41k| { 1166| 1.41k| FAIL_ON_ERROR(yr_parser_lookup_string(yyscanner, identifier, &string)); ------------------ | | 131| 1.41k| { \ | | 132| 1.41k| int __error = (x); \ | | 133| 1.41k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.41k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 22, False: 1.39k] | | ------------------ | | 134| 1.41k| return __error; \ | | 135| 1.41k| } ------------------ 1167| | 1168| 1.39k| FAIL_ON_ERROR( ------------------ | | 131| 1.39k| { \ | | 132| 1.39k| int __error = (x); \ | | 133| 1.39k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.39k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.39k] | | ------------------ | | 134| 1.39k| return __error; \ | | 135| 1.39k| } ------------------ 1169| 1.39k| yr_parser_emit_with_arg_reloc(yyscanner, OP_PUSH, string, NULL, NULL)); 1170| | 1171| 1.39k| if (instruction != OP_FOUND) ------------------ | | 70| 1.39k|#define OP_FOUND 22 ------------------ | Branch (1171:9): [True: 1.22k, False: 168] ------------------ 1172| 1.22k| string->flags &= ~STRING_FLAGS_SINGLE_MATCH; ------------------ | | 75| 1.22k|#define STRING_FLAGS_SINGLE_MATCH 0x200 ------------------ 1173| | 1174| 1.39k| if (instruction == OP_FOUND_AT) ------------------ | | 71| 1.39k|#define OP_FOUND_AT 23 ------------------ | Branch (1174:9): [True: 653, False: 743] ------------------ 1175| 653| { 1176| | // Avoid overwriting any previous fixed offset 1177| | 1178| 653| if (string->fixed_offset == YR_UNDEFINED) ------------------ | | 38| 653|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1178:11): [True: 166, False: 487] ------------------ 1179| 166| string->fixed_offset = at_offset; 1180| | 1181| | // If a previous fixed offset was different, disable 1182| | // the STRING_GFLAGS_FIXED_OFFSET flag because we only 1183| | // have room to store a single fixed offset value 1184| | 1185| 653| if (string->fixed_offset == YR_UNDEFINED || ------------------ | | 38| 1.30k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (1185:11): [True: 160, False: 493] ------------------ 1186| 653| string->fixed_offset != at_offset) ------------------ | Branch (1186:11): [True: 182, False: 311] ------------------ 1187| 342| { 1188| 342| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 342|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1189| 342| } 1190| 653| } 1191| 743| else 1192| 743| { 1193| 743| string->flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 743|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 1194| 743| } 1195| | 1196| 1.39k| FAIL_ON_ERROR(yr_parser_emit(yyscanner, instruction, NULL)); ------------------ | | 131| 1.39k| { \ | | 132| 1.39k| int __error = (x); \ | | 133| 1.39k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.39k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.39k] | | ------------------ | | 134| 1.39k| return __error; \ | | 135| 1.39k| } ------------------ 1197| | 1198| 1.39k| string->flags |= STRING_FLAGS_REFERENCED; ------------------ | | 66| 1.39k|#define STRING_FLAGS_REFERENCED 0x01 ------------------ 1199| 1.39k| } 1200| | 1201| 8.71k| return ERROR_SUCCESS; ------------------ | | 40| 8.71k|#define ERROR_SUCCESS 0 ------------------ 1202| 8.77k|} yr_parser_reduce_meta_declaration: 1211| 1.61k|{ 1212| 1.61k| YR_ARENA_REF ref; 1213| 1.61k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 1.61k|#define yyget_extra yara_yyget_extra ------------------ 1214| | 1215| 1.61k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 1.61k| { \ | | 132| 1.61k| int __error = (x); \ | | 133| 1.61k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.61k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.61k] | | ------------------ | | 134| 1.61k| return __error; \ | | 135| 1.61k| } ------------------ 1216| 1.61k| compiler->arena, 1217| 1.61k| YR_METAS_TABLE, 1218| 1.61k| sizeof(YR_META), 1219| 1.61k| meta_ref, 1220| 1.61k| offsetof(YR_META, identifier), 1221| 1.61k| offsetof(YR_META, string), 1222| 1.61k| EOL)); 1223| | 1224| 1.61k| YR_META* meta = (YR_META*) yr_arena_ref_to_ptr(compiler->arena, meta_ref); 1225| | 1226| 1.61k| meta->type = type; 1227| 1.61k| meta->integer = integer; 1228| | 1229| 1.61k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 131| 1.61k| { \ | | 132| 1.61k| int __error = (x); \ | | 133| 1.61k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.61k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.61k] | | ------------------ | | 134| 1.61k| return __error; \ | | 135| 1.61k| } ------------------ 1230| | 1231| 1.61k| meta->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 1232| | 1233| 1.61k| if (string != NULL) ------------------ | Branch (1233:7): [True: 403, False: 1.21k] ------------------ 1234| 403| { 1235| 403| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, string, &ref)); ------------------ | | 131| 403| { \ | | 132| 403| int __error = (x); \ | | 133| 403| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 403|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 403] | | ------------------ | | 134| 403| return __error; \ | | 135| 403| } ------------------ 1236| | 1237| 403| meta->string = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 1238| 403| } 1239| 1.21k| else 1240| 1.21k| { 1241| 1.21k| meta->string = NULL; 1242| 1.21k| } 1243| | 1244| 1.61k| compiler->current_meta_idx++; 1245| | 1246| 1.61k| return ERROR_SUCCESS; ------------------ | | 40| 1.61k|#define ERROR_SUCCESS 0 ------------------ 1247| 1.61k|} yr_parser_reduce_import: 1261| 9.15k|{ 1262| 9.15k| int result; 1263| | 1264| 9.15k| YR_ARENA_REF ref; 1265| 9.15k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 9.15k|#define yyget_extra yara_yyget_extra ------------------ 1266| 9.15k| YR_OBJECT* module_structure; 1267| | 1268| 9.15k| if (!_yr_parser_valid_module_name(module_name)) ------------------ | Branch (1268:7): [True: 8.13k, False: 1.01k] ------------------ 1269| 8.13k| { 1270| 8.13k| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 298| 8.13k| strlcpy( \ | | 299| 8.13k| compiler->last_error_extra_info, \ | | 300| 8.13k| info, \ | | 301| 8.13k| sizeof(compiler->last_error_extra_info)); ------------------ 1271| | 1272| 8.13k| return ERROR_INVALID_MODULE_NAME; ------------------ | | 95| 8.13k|#define ERROR_INVALID_MODULE_NAME 50 ------------------ 1273| 8.13k| } 1274| | 1275| 1.01k| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1276| 1.01k| compiler->arena, 1277| 1.01k| YR_NAMESPACES_TABLE, ------------------ | | 57| 1.01k|#define YR_NAMESPACES_TABLE 0 ------------------ 1278| 1.01k| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1279| | 1280| 1.01k| module_structure = (YR_OBJECT*) yr_hash_table_lookup( 1281| 1.01k| compiler->objects_table, module_name->c_string, ns->name); 1282| | 1283| | // if module already imported, do nothing 1284| | 1285| 1.01k| if (module_structure != NULL) ------------------ | Branch (1285:7): [True: 864, False: 151] ------------------ 1286| 864| return ERROR_SUCCESS; ------------------ | | 40| 864|#define ERROR_SUCCESS 0 ------------------ 1287| | 1288| 151| FAIL_ON_ERROR(yr_object_create( ------------------ | | 131| 151| { \ | | 132| 151| int __error = (x); \ | | 133| 151| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 151|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 151] | | ------------------ | | 134| 151| return __error; \ | | 135| 151| } ------------------ 1289| 151| OBJECT_TYPE_STRUCTURE, module_name->c_string, NULL, &module_structure)); 1290| | 1291| 151| FAIL_ON_ERROR(yr_hash_table_add( ------------------ | | 131| 151| { \ | | 132| 151| int __error = (x); \ | | 133| 151| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 151|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 151] | | ------------------ | | 134| 151| return __error; \ | | 135| 151| } ------------------ 1292| 151| compiler->objects_table, 1293| 151| module_name->c_string, 1294| 151| ns->name, 1295| 151| module_structure)); 1296| | 1297| 151| result = yr_modules_do_declarations(module_name->c_string, module_structure); 1298| | 1299| 151| if (result == ERROR_UNKNOWN_MODULE) ------------------ | | 79| 151|#define ERROR_UNKNOWN_MODULE 34 ------------------ | Branch (1299:7): [True: 75, False: 76] ------------------ 1300| 75| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 298| 75| strlcpy( \ | | 299| 75| compiler->last_error_extra_info, \ | | 300| 75| info, \ | | 301| 75| sizeof(compiler->last_error_extra_info)); ------------------ 1301| | 1302| 151| if (result != ERROR_SUCCESS) ------------------ | | 40| 151|#define ERROR_SUCCESS 0 ------------------ | Branch (1302:7): [True: 75, False: 76] ------------------ 1303| 75| return result; 1304| | 1305| 76| FAIL_ON_ERROR( ------------------ | | 131| 76| { \ | | 132| 76| int __error = (x); \ | | 133| 76| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 76|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 76] | | ------------------ | | 134| 76| return __error; \ | | 135| 76| } ------------------ 1306| 76| _yr_compiler_store_string(compiler, module_name->c_string, &ref)); 1307| | 1308| 76| FAIL_ON_ERROR(yr_parser_emit_with_arg_reloc( ------------------ | | 131| 76| { \ | | 132| 76| int __error = (x); \ | | 133| 76| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 76|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 76] | | ------------------ | | 134| 76| return __error; \ | | 135| 76| } ------------------ 1309| 76| yyscanner, 1310| 76| OP_IMPORT, 1311| 76| yr_arena_ref_to_ptr(compiler->arena, &ref), 1312| 76| NULL, 1313| 76| NULL)); 1314| | 1315| 76| return ERROR_SUCCESS; ------------------ | | 40| 76|#define ERROR_SUCCESS 0 ------------------ 1316| 76|} yr_parser_reduce_operation: 1388| 12.4k|{ 1389| 12.4k| int expression_type; 1390| | 1391| 12.4k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 12.4k|#define yyget_extra yara_yyget_extra ------------------ 1392| | 1393| 12.4k| if ((left_operand.type == EXPRESSION_TYPE_INTEGER || ------------------ | | 47| 24.8k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1393:8): [True: 9.22k, False: 3.19k] ------------------ 1394| 12.4k| left_operand.type == EXPRESSION_TYPE_FLOAT) && ------------------ | | 51| 3.19k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1394:8): [True: 1.12k, False: 2.07k] ------------------ 1395| 12.4k| (right_operand.type == EXPRESSION_TYPE_INTEGER || ------------------ | | 47| 20.6k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1395:8): [True: 8.92k, False: 1.42k] ------------------ 1396| 10.3k| right_operand.type == EXPRESSION_TYPE_FLOAT)) ------------------ | | 51| 1.42k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1396:8): [True: 1.31k, False: 105] ------------------ 1397| 10.2k| { 1398| 10.2k| if (left_operand.type != right_operand.type) ------------------ | Branch (1398:9): [True: 1.43k, False: 8.80k] ------------------ 1399| 1.43k| { 1400| | // One operand is double and the other is integer, 1401| | // cast the integer to double 1402| | 1403| 1.43k| FAIL_ON_ERROR(yr_parser_emit_with_arg( ------------------ | | 131| 1.43k| { \ | | 132| 2.86k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 812, False: 621] | | ------------------ | | 133| 1.43k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.43k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.43k] | | ------------------ | | 134| 1.43k| return __error; \ | | 135| 1.43k| } ------------------ 1404| 1.43k| yyscanner, 1405| 1.43k| OP_INT_TO_DBL, 1406| 1.43k| (left_operand.type == EXPRESSION_TYPE_INTEGER) ? 2 : 1, 1407| 1.43k| NULL, 1408| 1.43k| NULL)); 1409| 1.43k| } 1410| | 1411| 10.2k| expression_type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 10.2k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 1412| | 1413| 10.2k| if (left_operand.type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 20.4k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1413:9): [True: 9.11k, False: 1.12k] ------------------ 1414| 10.2k| right_operand.type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 9.11k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1414:9): [True: 8.30k, False: 812] ------------------ 1415| 8.30k| { 1416| 8.30k| expression_type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 8.30k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 1417| 8.30k| } 1418| | 1419| 10.2k| FAIL_ON_ERROR(yr_parser_emit( ------------------ | | 131| 10.2k| { \ | | 132| 10.2k| int __error = (x); \ | | 133| 10.2k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 10.2k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 10.2k] | | ------------------ | | 134| 10.2k| return __error; \ | | 135| 10.2k| } ------------------ 1420| 10.2k| yyscanner, _yr_parser_operator_to_opcode(op, expression_type), NULL)); 1421| 10.2k| } 1422| 2.17k| else if ( 1423| 2.17k| left_operand.type == EXPRESSION_TYPE_STRING && ------------------ | | 48| 4.35k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1423:7): [True: 2.06k, False: 114] ------------------ 1424| 2.17k| right_operand.type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 2.06k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1424:7): [True: 1.89k, False: 168] ------------------ 1425| 1.89k| { 1426| 1.89k| int opcode = _yr_parser_operator_to_opcode(op, EXPRESSION_TYPE_STRING); ------------------ | | 48| 1.89k|#define EXPRESSION_TYPE_STRING 4 ------------------ 1427| | 1428| 1.89k| if (opcode != OP_ERROR) ------------------ | | 45| 1.89k|#define OP_ERROR 0 ------------------ | Branch (1428:9): [True: 1.88k, False: 8] ------------------ 1429| 1.88k| { 1430| 1.88k| FAIL_ON_ERROR(yr_parser_emit(yyscanner, opcode, NULL)); ------------------ | | 131| 1.88k| { \ | | 132| 1.88k| int __error = (x); \ | | 133| 1.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 1.88k] | | ------------------ | | 134| 1.88k| return __error; \ | | 135| 1.88k| } ------------------ 1431| 1.88k| } 1432| 8| else 1433| 8| { 1434| 8| yr_compiler_set_error_extra_info_fmt( ------------------ | | 304| 8| snprintf( \ | | 305| 8| compiler->last_error_extra_info, \ | | 306| 8| sizeof(compiler->last_error_extra_info), \ | | 307| 8| fmt, \ | | 308| 8| __VA_ARGS__); ------------------ 1435| 8| compiler, "strings don't support \"%s\" operation", op); 1436| | 1437| 8| return ERROR_WRONG_TYPE; ------------------ | | 69| 8|#define ERROR_WRONG_TYPE 24 ------------------ 1438| 8| } 1439| 1.89k| } 1440| 282| else 1441| 282| { 1442| 282| yr_compiler_set_error_extra_info(compiler, "type mismatch"); ------------------ | | 298| 282| strlcpy( \ | | 299| 282| compiler->last_error_extra_info, \ | | 300| 282| info, \ | | 301| 282| sizeof(compiler->last_error_extra_info)); ------------------ 1443| | 1444| 282| return ERROR_WRONG_TYPE; ------------------ | | 69| 282|#define ERROR_WRONG_TYPE 24 ------------------ 1445| 282| } 1446| | 1447| 12.1k| return ERROR_SUCCESS; ------------------ | | 40| 12.1k|#define ERROR_SUCCESS 0 ------------------ 1448| 12.4k|} parser.c:_yr_parser_check_string_modifiers: 594| 22.4k|{ 595| 22.4k| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 55| 22.4k|#define yyget_extra yara_yyget_extra ------------------ 596| | 597| | // xor and nocase together is not implemented. 598| 22.4k| if (modifier.flags & STRING_FLAGS_XOR && ------------------ | | 85| 44.8k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (598:7): [True: 989, False: 21.4k] ------------------ 599| 22.4k| modifier.flags & STRING_FLAGS_NO_CASE) ------------------ | | 68| 989|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (599:7): [True: 0, False: 989] ------------------ 600| 0| { 601| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 602| 0| compiler, "invalid modifier combination: xor nocase"); 603| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 604| 0| } 605| | 606| | // base64 and nocase together is not implemented. 607| 22.4k| if (modifier.flags & STRING_FLAGS_NO_CASE && ------------------ | | 68| 44.8k|#define STRING_FLAGS_NO_CASE 0x04 ------------------ | Branch (607:7): [True: 3.32k, False: 19.0k] ------------------ 608| 22.4k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 6.64k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (608:8): [True: 0, False: 3.32k] ------------------ 609| 3.32k| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 3.32k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (609:8): [True: 0, False: 3.32k] ------------------ 610| 0| { 611| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | ------------------ | | | Branch (300:7): [True: 0, False: 0] | | ------------------ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 612| 0| compiler, 613| 0| modifier.flags & STRING_FLAGS_BASE64 614| 0| ? "invalid modifier combination: base64 nocase" 615| 0| : "invalid modifier combination: base64wide nocase"); 616| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 617| 0| } 618| | 619| | // base64 and fullword together is not implemented. 620| 22.4k| if (modifier.flags & STRING_FLAGS_FULL_WORD && ------------------ | | 73| 44.8k|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ | Branch (620:7): [True: 201, False: 22.2k] ------------------ 621| 22.4k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 402|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (621:8): [True: 0, False: 201] ------------------ 622| 201| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 201|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (622:8): [True: 9, False: 192] ------------------ 623| 9| { 624| 9| yr_compiler_set_error_extra_info( ------------------ | | 298| 9| strlcpy( \ | | 299| 9| compiler->last_error_extra_info, \ | | 300| 18| info, \ | | ------------------ | | | Branch (300:7): [True: 0, False: 9] | | ------------------ | | 301| 9| sizeof(compiler->last_error_extra_info)); ------------------ 625| 9| compiler, 626| 9| modifier.flags & STRING_FLAGS_BASE64 627| 9| ? "invalid modifier combination: base64 fullword" 628| 9| : "invalid modifier combination: base64wide fullword"); 629| 9| return ERROR_INVALID_MODIFIER; ------------------ | | 104| 9|#define ERROR_INVALID_MODIFIER 59 ------------------ 630| 9| } 631| | 632| | // base64 and xor together is not implemented. 633| 22.3k| if (modifier.flags & STRING_FLAGS_XOR && ------------------ | | 85| 44.7k|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (633:7): [True: 989, False: 21.4k] ------------------ 634| 22.3k| (modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 1.97k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (634:8): [True: 0, False: 989] ------------------ 635| 989| modifier.flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 989|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (635:8): [True: 0, False: 989] ------------------ 636| 0| { 637| 0| yr_compiler_set_error_extra_info( ------------------ | | 298| 0| strlcpy( \ | | 299| 0| compiler->last_error_extra_info, \ | | 300| 0| info, \ | | ------------------ | | | Branch (300:7): [True: 0, False: 0] | | ------------------ | | 301| 0| sizeof(compiler->last_error_extra_info)); ------------------ 638| 0| compiler, 639| 0| modifier.flags & STRING_FLAGS_BASE64 640| 0| ? "invalid modifier combination: base64 xor" 641| 0| : "invalid modifier combination: base64wide xor"); 642| 0| return ERROR_INVALID_MODIFIER; ------------------ | | 104| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 643| 0| } 644| | 645| 22.3k| return ERROR_SUCCESS; ------------------ | | 40| 22.3k|#define ERROR_SUCCESS 0 ------------------ 646| 22.3k|} parser.c:_yr_parser_write_string: 451| 24.9k|{ 452| 24.9k| SIZED_STRING* literal_string; 453| 24.9k| YR_ATOM_LIST_ITEM* atom; 454| 24.9k| YR_ATOM_LIST_ITEM* atom_list = NULL; 455| | 456| 24.9k| int c, result; 457| 24.9k| int max_string_len; 458| 24.9k| bool free_literal = false; 459| | 460| 24.9k| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 131| 24.9k| { \ | | 132| 24.9k| int __error = (x); \ | | 133| 24.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 24.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 24.9k] | | ------------------ | | 134| 24.9k| return __error; \ | | 135| 24.9k| } ------------------ 461| 24.9k| compiler->arena, 462| 24.9k| YR_STRINGS_TABLE, 463| 24.9k| sizeof(YR_STRING), 464| 24.9k| string_ref, 465| 24.9k| offsetof(YR_STRING, identifier), 466| 24.9k| offsetof(YR_STRING, string), 467| 24.9k| offsetof(YR_STRING, chained_to), 468| 24.9k| EOL)); 469| | 470| 24.9k| YR_STRING* string = (YR_STRING*) yr_arena_ref_to_ptr( 471| 24.9k| compiler->arena, string_ref); 472| | 473| 24.9k| YR_ARENA_REF ref; 474| | 475| 24.9k| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, identifier, &ref)); ------------------ | | 131| 24.9k| { \ | | 132| 24.9k| int __error = (x); \ | | 133| 24.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 24.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 24.9k] | | ------------------ | | 134| 24.9k| return __error; \ | | 135| 24.9k| } ------------------ 476| | 477| 24.9k| string->identifier = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 478| | 479| 24.9k| if (modifier.flags & STRING_FLAGS_HEXADECIMAL || ------------------ | | 67| 49.9k|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ | Branch (479:7): [True: 1.59k, False: 23.3k] ------------------ 480| 24.9k| modifier.flags & STRING_FLAGS_REGEXP || ------------------ | | 71| 48.3k|#define STRING_FLAGS_REGEXP 0x20 ------------------ | Branch (480:7): [True: 19.2k, False: 4.12k] ------------------ 481| 24.9k| modifier.flags & STRING_FLAGS_BASE64 || ------------------ | | 87| 29.1k|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (481:7): [True: 1.39k, False: 2.73k] ------------------ 482| 24.9k| modifier.flags & STRING_FLAGS_BASE64_WIDE) ------------------ | | 88| 2.73k|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (482:7): [True: 969, False: 1.76k] ------------------ 483| 23.2k| { 484| 23.2k| literal_string = yr_re_ast_extract_literal(re_ast); 485| | 486| 23.2k| if (literal_string != NULL) ------------------ | Branch (486:9): [True: 16.0k, False: 7.16k] ------------------ 487| 16.0k| free_literal = true; 488| 23.2k| } 489| 1.76k| else 490| 1.76k| { 491| 1.76k| literal_string = str; 492| 1.76k| } 493| | 494| 24.9k| if (literal_string != NULL) ------------------ | Branch (494:7): [True: 17.8k, False: 7.16k] ------------------ 495| 17.8k| { 496| 17.8k| modifier.flags |= STRING_FLAGS_LITERAL; ------------------ | | 76| 17.8k|#define STRING_FLAGS_LITERAL 0x400 ------------------ 497| | 498| 17.8k| result = _yr_compiler_store_data( 499| 17.8k| compiler, 500| 17.8k| literal_string->c_string, 501| 17.8k| literal_string->length + 1, // +1 to include terminating NULL 502| 17.8k| &ref); 503| | 504| 17.8k| string->length = (uint32_t) literal_string->length; 505| 17.8k| string->string = (uint8_t*) yr_arena_ref_to_ptr(compiler->arena, &ref); 506| | 507| 17.8k| if (result == ERROR_SUCCESS) ------------------ | | 40| 17.8k|#define ERROR_SUCCESS 0 ------------------ | Branch (507:9): [True: 17.8k, False: 0] ------------------ 508| 17.8k| { 509| 17.8k| result = yr_atoms_extract_from_string( 510| 17.8k| &compiler->atoms_config, 511| 17.8k| (uint8_t*) literal_string->c_string, 512| 17.8k| (int32_t) literal_string->length, 513| 17.8k| modifier, 514| 17.8k| &atom_list, 515| 17.8k| min_atom_quality); 516| 17.8k| } 517| 17.8k| } 518| 7.16k| else 519| 7.16k| { 520| | // Non-literal strings can't be marked as fixed offset because once we 521| | // find a string atom in the scanned data we don't know the offset where 522| | // the string should start, as the non-literal strings can contain 523| | // variable-length portions. 524| 7.16k| modifier.flags &= ~STRING_FLAGS_FIXED_OFFSET; ------------------ | | 81| 7.16k|#define STRING_FLAGS_FIXED_OFFSET 0x8000 ------------------ 525| | 526| | // Emit forwards code 527| 7.16k| result = yr_re_ast_emit_code(re_ast, compiler->arena, false); 528| | 529| | // Emit backwards code 530| 7.16k| if (result == ERROR_SUCCESS) ------------------ | | 40| 7.16k|#define ERROR_SUCCESS 0 ------------------ | Branch (530:9): [True: 7.09k, False: 70] ------------------ 531| 7.09k| result = yr_re_ast_emit_code(re_ast, compiler->arena, true); 532| | 533| 7.16k| if (result == ERROR_SUCCESS) ------------------ | | 40| 7.16k|#define ERROR_SUCCESS 0 ------------------ | Branch (533:9): [True: 7.09k, False: 70] ------------------ 534| 7.09k| result = yr_atoms_extract_from_re( 535| 7.09k| &compiler->atoms_config, 536| 7.09k| re_ast, 537| 7.09k| modifier, 538| 7.09k| &atom_list, 539| 7.09k| min_atom_quality); 540| 7.16k| } 541| | 542| 24.9k| string->flags = modifier.flags; 543| 24.9k| string->rule_idx = compiler->current_rule_idx; 544| 24.9k| string->idx = compiler->current_string_idx; 545| 24.9k| string->fixed_offset = YR_UNDEFINED; ------------------ | | 38| 24.9k|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 546| | 547| 24.9k| if (result == ERROR_SUCCESS) ------------------ | | 40| 24.9k|#define ERROR_SUCCESS 0 ------------------ | Branch (547:7): [True: 24.9k, False: 70] ------------------ 548| 24.9k| { 549| | // Add the string to Aho-Corasick automaton. 550| 24.9k| result = yr_ac_add_string( 551| 24.9k| compiler->automaton, 552| 24.9k| string, 553| 24.9k| compiler->current_string_idx, 554| 24.9k| atom_list, 555| 24.9k| compiler->arena); 556| 24.9k| } 557| | 558| 24.9k| if (modifier.flags & STRING_FLAGS_LITERAL) ------------------ | | 76| 24.9k|#define STRING_FLAGS_LITERAL 0x400 ------------------ | Branch (558:7): [True: 17.8k, False: 7.16k] ------------------ 559| 17.8k| { 560| 17.8k| if (modifier.flags & STRING_FLAGS_WIDE) ------------------ | | 70| 17.8k|#define STRING_FLAGS_WIDE 0x10 ------------------ | Branch (560:9): [True: 1.49k, False: 16.3k] ------------------ 561| 1.49k| max_string_len = string->length * 2; 562| 16.3k| else 563| 16.3k| max_string_len = string->length; 564| | 565| 17.8k| if (max_string_len <= YR_MAX_ATOM_LENGTH) ------------------ | | 68| 17.8k|#define YR_MAX_ATOM_LENGTH 4 ------------------ | Branch (565:9): [True: 13.4k, False: 4.41k] ------------------ 566| 13.4k| string->flags |= STRING_FLAGS_FITS_IN_ATOM; ------------------ | | 77| 13.4k|#define STRING_FLAGS_FITS_IN_ATOM 0x800 ------------------ 567| 17.8k| } 568| | 569| 24.9k| atom = atom_list; 570| 24.9k| c = 0; 571| | 572| 5.26M| while (atom != NULL) ------------------ | Branch (572:10): [True: 5.24M, False: 24.9k] ------------------ 573| 5.24M| { 574| 5.24M| atom = atom->next; 575| 5.24M| c++; 576| 5.24M| } 577| | 578| 24.9k| (*num_atom) += c; 579| | 580| 24.9k| compiler->current_string_idx++; 581| | 582| 24.9k| if (free_literal) ------------------ | Branch (582:7): [True: 16.0k, False: 8.93k] ------------------ 583| 16.0k| yr_free(literal_string); 584| | 585| 24.9k| if (atom_list != NULL) ------------------ | Branch (585:7): [True: 24.9k, False: 70] ------------------ 586| 24.9k| yr_atoms_list_destroy(atom_list); 587| | 588| 24.9k| return result; 589| 24.9k|} parser.c:wildcard_iterator: 924| 1.48k|{ 925| 1.48k| const char* identifier = (const char*) data; 926| | 927| | // If the identifier is prefixed by prefix, then it matches the wildcard. 928| 1.48k| if (!strncmp(prefix, identifier, prefix_len)) ------------------ | Branch (928:7): [True: 978, False: 503] ------------------ 929| 978| return ERROR_IDENTIFIER_MATCHES_WILDCARD; ------------------ | | 108| 978|#define ERROR_IDENTIFIER_MATCHES_WILDCARD 63 ------------------ 930| | 931| 503| return ERROR_SUCCESS; ------------------ | | 40| 503|#define ERROR_SUCCESS 0 ------------------ 932| 1.48k|} parser.c:_yr_parser_valid_module_name: 1250| 9.15k|{ 1251| 9.15k| if (module_name->length == 0) ------------------ | Branch (1251:7): [True: 7.97k, False: 1.18k] ------------------ 1252| 7.97k| return false; 1253| | 1254| 1.18k| if (strlen(module_name->c_string) != module_name->length) ------------------ | Branch (1254:7): [True: 166, False: 1.01k] ------------------ 1255| 166| return false; 1256| | 1257| 1.01k| return true; 1258| 1.18k|} parser.c:_yr_parser_operator_to_opcode: 1319| 12.1k|{ 1320| 12.1k| int opcode = 0; 1321| | 1322| 12.1k| switch (expression_type) 1323| 12.1k| { 1324| 8.30k| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 8.30k|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (1324:3): [True: 8.30k, False: 3.83k] ------------------ 1325| 8.30k| opcode = OP_INT_BEGIN; ------------------ | | 141| 8.30k|#define OP_INT_BEGIN 100 ------------------ 1326| 8.30k| break; 1327| 1.93k| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 1.93k|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (1327:3): [True: 1.93k, False: 10.2k] ------------------ 1328| 1.93k| opcode = OP_DBL_BEGIN; ------------------ | | 155| 1.93k|#define OP_DBL_BEGIN 120 ------------------ 1329| 1.93k| break; 1330| 1.89k| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 1.89k|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (1330:3): [True: 1.89k, False: 10.2k] ------------------ 1331| 1.89k| opcode = OP_STR_BEGIN; ------------------ | | 169| 1.89k|#define OP_STR_BEGIN 140 ------------------ 1332| 1.89k| break; 1333| 0| default: ------------------ | Branch (1333:3): [True: 0, False: 12.1k] ------------------ 1334| 0| assert(false); 1335| 12.1k| } 1336| | 1337| 12.1k| if (op[0] == '<') ------------------ | Branch (1337:7): [True: 1.15k, False: 10.9k] ------------------ 1338| 1.15k| { 1339| 1.15k| if (op[1] == '=') ------------------ | Branch (1339:9): [True: 323, False: 836] ------------------ 1340| 323| opcode += _OP_LE; ------------------ | | 133| 323|#define _OP_LE 4 ------------------ 1341| 836| else 1342| 836| opcode += _OP_LT; ------------------ | | 131| 836|#define _OP_LT 2 ------------------ 1343| 1.15k| } 1344| 10.9k| else if (op[0] == '>') ------------------ | Branch (1344:12): [True: 1.56k, False: 9.41k] ------------------ 1345| 1.56k| { 1346| 1.56k| if (op[1] == '=') ------------------ | Branch (1346:9): [True: 400, False: 1.16k] ------------------ 1347| 400| opcode += _OP_GE; ------------------ | | 134| 400|#define _OP_GE 5 ------------------ 1348| 1.16k| else 1349| 1.16k| opcode += _OP_GT; ------------------ | | 132| 1.16k|#define _OP_GT 3 ------------------ 1350| 1.56k| } 1351| 9.41k| else if (op[1] == '=') ------------------ | Branch (1351:12): [True: 494, False: 8.92k] ------------------ 1352| 494| { 1353| 494| if (op[0] == '=') ------------------ | Branch (1353:9): [True: 302, False: 192] ------------------ 1354| 302| opcode += _OP_EQ; ------------------ | | 129| 302|#define _OP_EQ 0 ------------------ 1355| 192| else 1356| 192| opcode += _OP_NEQ; ------------------ | | 130| 192|#define _OP_NEQ 1 ------------------ 1357| 494| } 1358| 8.92k| else if (op[0] == '+') ------------------ | Branch (1358:12): [True: 2.07k, False: 6.84k] ------------------ 1359| 2.07k| { 1360| 2.07k| opcode += _OP_ADD; ------------------ | | 135| 2.07k|#define _OP_ADD 6 ------------------ 1361| 2.07k| } 1362| 6.84k| else if (op[0] == '-') ------------------ | Branch (1362:12): [True: 4.27k, False: 2.56k] ------------------ 1363| 4.27k| { 1364| 4.27k| opcode += _OP_SUB; ------------------ | | 136| 4.27k|#define _OP_SUB 7 ------------------ 1365| 4.27k| } 1366| 2.56k| else if (op[0] == '*') ------------------ | Branch (1366:12): [True: 1.62k, False: 938] ------------------ 1367| 1.62k| { 1368| 1.62k| opcode += _OP_MUL; ------------------ | | 137| 1.62k|#define _OP_MUL 8 ------------------ 1369| 1.62k| } 1370| 938| else if (op[0] == '\\') ------------------ | Branch (1370:12): [True: 938, False: 0] ------------------ 1371| 938| { 1372| 938| opcode += _OP_DIV; ------------------ | | 138| 938|#define _OP_DIV 9 ------------------ 1373| 938| } 1374| | 1375| 12.1k| if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 178| 24.2k|#define IS_INT_OP(x) ((x) >= OP_INT_BEGIN && (x) <= OP_INT_END) | | ------------------ | | | | 141| 24.2k|#define OP_INT_BEGIN 100 | | ------------------ | | #define IS_INT_OP(x) ((x) >= OP_INT_BEGIN && (x) <= OP_INT_END) | | ------------------ | | | | 153| 12.1k|#define OP_INT_END OP_INT_MINUS | | | | ------------------ | | | | | | 152| 12.1k|#define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 141| 12.1k|#define OP_INT_BEGIN 100 | | | | | | ------------------ | | | | | | #define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 139| 12.1k|#define _OP_MINUS 10 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (178:23): [True: 12.1k, False: 0] | | | Branch (178:46): [True: 8.30k, False: 3.83k] | | ------------------ ------------------ if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 179| 15.9k|#define IS_DBL_OP(x) ((x) >= OP_DBL_BEGIN && (x) <= OP_DBL_END) | | ------------------ | | | | 155| 7.66k|#define OP_DBL_BEGIN 120 | | ------------------ | | #define IS_DBL_OP(x) ((x) >= OP_DBL_BEGIN && (x) <= OP_DBL_END) | | ------------------ | | | | 167| 3.83k|#define OP_DBL_END OP_DBL_MINUS | | | | ------------------ | | | | | | 166| 3.83k|#define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 155| 3.83k|#define OP_DBL_BEGIN 120 | | | | | | ------------------ | | | | | | #define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | | | | | ------------------ | | | | | | | | 139| 3.83k|#define _OP_MINUS 10 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (179:23): [True: 3.83k, False: 0] | | | Branch (179:46): [True: 1.93k, False: 1.89k] | | ------------------ ------------------ if (IS_INT_OP(opcode) || IS_DBL_OP(opcode) || IS_STR_OP(opcode)) ------------------ | | 180| 1.89k|#define IS_STR_OP(x) ((x) >= OP_STR_BEGIN && (x) <= OP_STR_END) | | ------------------ | | | | 169| 3.79k|#define OP_STR_BEGIN 140 | | ------------------ | | #define IS_STR_OP(x) ((x) >= OP_STR_BEGIN && (x) <= OP_STR_END) | | ------------------ | | | | 176| 1.89k|#define OP_STR_END OP_STR_GE | | | | ------------------ | | | | | | 175| 1.89k|#define OP_STR_GE (OP_STR_BEGIN + _OP_GE) | | | | | | ------------------ | | | | | | | | 169| 1.89k|#define OP_STR_BEGIN 140 | | | | | | ------------------ | | | | | | #define OP_STR_GE (OP_STR_BEGIN + _OP_GE) | | | | | | ------------------ | | | | | | | | 134| 1.89k|#define _OP_GE 5 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (180:23): [True: 1.89k, False: 0] | | | Branch (180:46): [True: 1.88k, False: 8] | | ------------------ ------------------ 1376| 12.1k| { 1377| 12.1k| return opcode; 1378| 12.1k| } 1379| | 1380| 8| return OP_ERROR; ------------------ | | 45| 8|#define OP_ERROR 0 ------------------ 1381| 12.1k|} yr_re_node_create: 125| 2.08M|{ 126| 2.08M| RE_NODE* result = (RE_NODE*) yr_malloc(sizeof(RE_NODE)); 127| | 128| 2.08M| if (result != NULL) ------------------ | Branch (128:7): [True: 2.08M, False: 0] ------------------ 129| 2.08M| { 130| 2.08M| result->type = type; 131| 2.08M| result->children_head = NULL; 132| 2.08M| result->children_tail = NULL; 133| 2.08M| result->prev_sibling = NULL; 134| 2.08M| result->next_sibling = NULL; 135| 2.08M| result->greedy = true; 136| 2.08M| result->forward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 2.08M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 137| 2.08M| result->backward_code_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 2.08M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 138| 2.08M| } 139| | 140| 2.08M| return result; 141| 2.08M|} yr_re_node_destroy: 144| 2.08M|{ 145| 2.08M| RE_NODE* child = node->children_head; 146| 2.08M| RE_NODE* next_child; 147| | 148| 4.14M| while (child != NULL) ------------------ | Branch (148:10): [True: 2.05M, False: 2.08M] ------------------ 149| 2.05M| { 150| 2.05M| next_child = child->next_sibling; 151| 2.05M| yr_re_node_destroy(child); 152| 2.05M| child = next_child; 153| 2.05M| } 154| | 155| 2.08M| if (node->type == RE_NODE_CLASS) ------------------ | | 49| 2.08M|#define RE_NODE_CLASS 9 ------------------ | Branch (155:7): [True: 588, False: 2.08M] ------------------ 156| 588| yr_free(node->re_class); 157| | 158| 2.08M| yr_free(node); 159| 2.08M|} yr_re_node_append_child: 165| 2.05M|{ 166| 2.05M| if (node->children_head == NULL) ------------------ | Branch (166:7): [True: 97.6k, False: 1.95M] ------------------ 167| 97.6k| node->children_head = child; 168| | 169| 2.05M| if (node->children_tail != NULL) ------------------ | Branch (169:7): [True: 1.95M, False: 97.6k] ------------------ 170| 1.95M| node->children_tail->next_sibling = child; 171| | 172| 2.05M| child->prev_sibling = node->children_tail; 173| 2.05M| node->children_tail = child; 174| 2.05M|} yr_re_node_prepend_child: 180| 417|{ 181| 417| child->next_sibling = node->children_head; 182| | 183| 417| if (node->children_head != NULL) ------------------ | Branch (183:7): [True: 417, False: 0] ------------------ 184| 417| node->children_head->prev_sibling = child; 185| | 186| 417| node->children_head = child; 187| | 188| 417| if (node->children_tail == NULL) ------------------ | Branch (188:7): [True: 0, False: 417] ------------------ 189| 0| node->children_tail = child; 190| 417|} yr_re_ast_create: 193| 24.5k|{ 194| 24.5k| *re_ast = (RE_AST*) yr_malloc(sizeof(RE_AST)); 195| | 196| 24.5k| if (*re_ast == NULL) ------------------ | Branch (196:7): [True: 0, False: 24.5k] ------------------ 197| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 198| | 199| 24.5k| (*re_ast)->flags = 0; 200| 24.5k| (*re_ast)->root_node = NULL; 201| | 202| 24.5k| return ERROR_SUCCESS; ------------------ | | 40| 24.5k|#define ERROR_SUCCESS 0 ------------------ 203| 24.5k|} yr_re_ast_destroy: 206| 24.5k|{ 207| 24.5k| if (re_ast->root_node != NULL) ------------------ | Branch (207:7): [True: 24.0k, False: 492] ------------------ 208| 24.0k| yr_re_node_destroy(re_ast->root_node); 209| | 210| 24.5k| yr_free(re_ast); 211| 24.5k|} yr_re_parse: 218| 20.5k|{ 219| 20.5k| return yr_parse_re_string(re_string, re_ast, error); 220| 20.5k|} yr_re_parse_hex: 227| 1.07k|{ 228| 1.07k| return yr_parse_hex_string(hex_string, re_ast, error); 229| 1.07k|} yr_re_compile: 241| 994|{ 242| 994| RE_AST* re_ast; 243| 994| RE _re; 244| | 245| 994| FAIL_ON_ERROR(yr_re_parse(re_string, &re_ast, error)); ------------------ | | 131| 994| { \ | | 132| 994| int __error = (x); \ | | 133| 994| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 994|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 192, False: 802] | | ------------------ | | 134| 994| return __error; \ | | 135| 994| } ------------------ 246| | 247| 802| _re.flags = flags; 248| | 249| 802| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 802| { \ | | 140| 802| int __error = (x); \ | | 141| 802| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 802|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 0, False: 802] | | ------------------ | | 142| 802| { \ | | 143| 0| cleanup; \ | | 144| 0| return __error; \ | | 145| 0| } \ | | 146| 802| } ------------------ 250| 802| yr_arena_write_data(arena, YR_RE_CODE_SECTION, &_re, sizeof(_re), ref), 251| 802| yr_re_ast_destroy(re_ast)); 252| | 253| 802| FAIL_ON_ERROR_WITH_CLEANUP( ------------------ | | 139| 802| { \ | | 140| 802| int __error = (x); \ | | 141| 802| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 802|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (141:9): [True: 34, False: 768] | | ------------------ | | 142| 802| { \ | | 143| 34| cleanup; \ | | 144| 34| return __error; \ | | 145| 34| } \ | | 146| 802| } ------------------ 254| 802| yr_re_ast_emit_code(re_ast, arena, false), yr_re_ast_destroy(re_ast)); 255| | 256| 768| yr_re_ast_destroy(re_ast); 257| | 258| 768| return ERROR_SUCCESS; ------------------ | | 40| 768|#define ERROR_SUCCESS 0 ------------------ 259| 802|} yr_re_ast_extract_literal: 299| 23.2k|{ 300| 23.2k| SIZED_STRING* string; 301| 23.2k| RE_NODE* child; 302| | 303| 23.2k| int length = 0; 304| | 305| 23.2k| if (re_ast->root_node->type == RE_NODE_LITERAL) ------------------ | | 41| 23.2k|#define RE_NODE_LITERAL 1 ------------------ | Branch (305:7): [True: 325, False: 22.9k] ------------------ 306| 325| { 307| 325| length = 1; 308| 325| } 309| 22.9k| else if (re_ast->root_node->type == RE_NODE_CONCAT) ------------------ | | 44| 22.9k|#define RE_NODE_CONCAT 4 ------------------ | Branch (309:12): [True: 22.1k, False: 798] ------------------ 310| 22.1k| { 311| 22.1k| child = re_ast->root_node->children_tail; 312| | 313| 115k| while (child != NULL && child->type == RE_NODE_LITERAL) ------------------ | | 41| 99.7k|#define RE_NODE_LITERAL 1 ------------------ | Branch (313:12): [True: 99.7k, False: 15.7k] | Branch (313:29): [True: 93.3k, False: 6.36k] ------------------ 314| 93.3k| { 315| 93.3k| length++; 316| 93.3k| child = child->prev_sibling; 317| 93.3k| } 318| | 319| 22.1k| if (child != NULL) ------------------ | Branch (319:9): [True: 6.36k, False: 15.7k] ------------------ 320| 6.36k| return NULL; 321| 22.1k| } 322| 798| else 323| 798| { 324| 798| return NULL; 325| 798| } 326| | 327| 16.0k| string = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 328| | 329| 16.0k| if (string == NULL) ------------------ | Branch (329:7): [True: 0, False: 16.0k] ------------------ 330| 0| return NULL; 331| | 332| 16.0k| string->length = length; 333| 16.0k| string->flags = 0; 334| | 335| 16.0k| if (re_ast->root_node->type == RE_NODE_LITERAL) ------------------ | | 41| 16.0k|#define RE_NODE_LITERAL 1 ------------------ | Branch (335:7): [True: 325, False: 15.7k] ------------------ 336| 325| { 337| 325| string->c_string[0] = re_ast->root_node->value; 338| 325| } 339| 15.7k| else 340| 15.7k| { 341| 15.7k| child = re_ast->root_node->children_tail; 342| | 343| 104k| while (child != NULL) ------------------ | Branch (343:12): [True: 88.4k, False: 15.7k] ------------------ 344| 88.4k| { 345| 88.4k| string->c_string[--length] = child->value; 346| 88.4k| child = child->prev_sibling; 347| 88.4k| } 348| 15.7k| } 349| | 350| 16.0k| string->c_string[string->length] = '\0'; 351| | 352| 16.0k| return string; 353| 16.0k|} _yr_re_node_has_unbounded_quantifier_for_dot: 356| 159k|{ 357| 159k| RE_NODE* child; 358| | 359| 159k| if ((re_node->type == RE_NODE_STAR || re_node->type == RE_NODE_PLUS) && ------------------ | | 47| 319k|#define RE_NODE_STAR 7 ------------------ if ((re_node->type == RE_NODE_STAR || re_node->type == RE_NODE_PLUS) && ------------------ | | 48| 159k|#define RE_NODE_PLUS 8 ------------------ | Branch (359:8): [True: 340, False: 159k] | Branch (359:41): [True: 734, False: 158k] ------------------ 360| 159k| re_node->children_head->type == RE_NODE_ANY) ------------------ | | 43| 1.07k|#define RE_NODE_ANY 3 ------------------ | Branch (360:7): [True: 376, False: 698] ------------------ 361| 376| return true; 362| | 363| 159k| if (re_node->type == RE_NODE_RANGE_ANY && re_node->end == RE_MAX_RANGE) ------------------ | | 61| 318k|#define RE_NODE_RANGE_ANY 21 ------------------ if (re_node->type == RE_NODE_RANGE_ANY && re_node->end == RE_MAX_RANGE) ------------------ | | 39| 2.41k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (363:7): [True: 2.41k, False: 156k] | Branch (363:45): [True: 384, False: 2.02k] ------------------ 364| 384| return true; 365| | 366| 158k| if (re_node->type == RE_NODE_CONCAT) ------------------ | | 44| 158k|#define RE_NODE_CONCAT 4 ------------------ | Branch (366:7): [True: 35.2k, False: 123k] ------------------ 367| 35.2k| { 368| 35.2k| child = re_node->children_tail; 369| | 370| 173k| while (child != NULL) ------------------ | Branch (370:12): [True: 139k, False: 34.1k] ------------------ 371| 139k| { 372| 139k| if (_yr_re_node_has_unbounded_quantifier_for_dot(child)) ------------------ | Branch (372:11): [True: 1.01k, False: 138k] ------------------ 373| 1.01k| return true; 374| | 375| 138k| child = child->prev_sibling; 376| 138k| } 377| 35.2k| } 378| | 379| 157k| return false; 380| 158k|} yr_re_ast_has_unbounded_quantifier_for_dot: 389| 20.2k|{ 390| 20.2k| return _yr_re_node_has_unbounded_quantifier_for_dot(re_ast->root_node); 391| 20.2k|} yr_re_ast_split_at_chaining_point: 457| 23.2k|{ 458| 23.2k| RE_NODE* child; 459| 23.2k| RE_NODE* concat; 460| | 461| 23.2k| int result; 462| | 463| 23.2k| *remainder_re_ast = NULL; 464| 23.2k| *min_gap = 0; 465| 23.2k| *max_gap = 0; 466| | 467| 23.2k| if (re_ast->root_node->type != RE_NODE_CONCAT) ------------------ | | 44| 23.2k|#define RE_NODE_CONCAT 4 ------------------ | Branch (467:7): [True: 1.12k, False: 22.1k] ------------------ 468| 1.12k| return ERROR_SUCCESS; ------------------ | | 40| 1.12k|#define ERROR_SUCCESS 0 ------------------ 469| | 470| 22.1k| child = re_ast->root_node->children_head; 471| | 472| 150k| while (child != NULL) ------------------ | Branch (472:10): [True: 130k, False: 19.1k] ------------------ 473| 130k| { 474| 130k| if (!child->greedy && child->type == RE_NODE_RANGE_ANY && ------------------ | | 61| 135k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (474:9): [True: 4.49k, False: 126k] | Branch (474:27): [True: 4.09k, False: 407] ------------------ 475| 130k| child->prev_sibling != NULL && child->next_sibling != NULL && ------------------ | Branch (475:9): [True: 3.59k, False: 495] | Branch (475:40): [True: 3.43k, False: 163] ------------------ 476| 130k| (child->start > YR_STRING_CHAINING_THRESHOLD || ------------------ | | 143| 6.86k|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (476:10): [True: 514, False: 2.92k] ------------------ 477| 3.43k| child->end > YR_STRING_CHAINING_THRESHOLD)) ------------------ | | 143| 2.92k|#define YR_STRING_CHAINING_THRESHOLD 200 ------------------ | Branch (477:10): [True: 2.43k, False: 481] ------------------ 478| 2.95k| { 479| 2.95k| result = yr_re_ast_create(remainder_re_ast); 480| | 481| 2.95k| if (result != ERROR_SUCCESS) ------------------ | | 40| 2.95k|#define ERROR_SUCCESS 0 ------------------ | Branch (481:11): [True: 0, False: 2.95k] ------------------ 482| 0| return result; 483| | 484| 2.95k| concat = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 2.95k|#define RE_NODE_CONCAT 4 ------------------ 485| | 486| 2.95k| if (concat == NULL) ------------------ | Branch (486:11): [True: 0, False: 2.95k] ------------------ 487| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 488| | 489| 2.95k| concat->children_head = child->next_sibling; 490| 2.95k| concat->children_tail = re_ast->root_node->children_tail; 491| | 492| 2.95k| re_ast->root_node->children_tail = child->prev_sibling; 493| | 494| 2.95k| child->prev_sibling->next_sibling = NULL; 495| 2.95k| child->next_sibling->prev_sibling = NULL; 496| | 497| 2.95k| *min_gap = child->start; 498| 2.95k| *max_gap = child->end; 499| | 500| 2.95k| (*remainder_re_ast)->root_node = concat; 501| 2.95k| (*remainder_re_ast)->flags = re_ast->flags; 502| | 503| 2.95k| yr_re_node_destroy(child); 504| | 505| 2.95k| return ERROR_SUCCESS; ------------------ | | 40| 2.95k|#define ERROR_SUCCESS 0 ------------------ 506| 2.95k| } 507| | 508| 127k| child = child->next_sibling; 509| 127k| } 510| | 511| 19.1k| return ERROR_SUCCESS; ------------------ | | 40| 19.1k|#define ERROR_SUCCESS 0 ------------------ 512| 22.1k|} _yr_emit_inst: 518| 8.95M|{ 519| 8.95M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 8.95M| { \ | | 132| 8.95M| int __error = (x); \ | | 133| 8.95M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 8.95M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 8.95M] | | ------------------ | | 134| 8.95M| return __error; \ | | 135| 8.95M| } ------------------ 520| 8.95M| emit_context->arena, 521| 8.95M| YR_RE_CODE_SECTION, 522| 8.95M| &opcode, 523| 8.95M| sizeof(uint8_t), 524| 8.95M| instruction_ref)); 525| | 526| 8.95M| return ERROR_SUCCESS; ------------------ | | 40| 8.95M|#define ERROR_SUCCESS 0 ------------------ 527| 8.95M|} _yr_emit_inst_arg_uint8: 535| 15.6M|{ 536| 15.6M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 15.6M| { \ | | 132| 15.6M| int __error = (x); \ | | 133| 15.6M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.6M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 15.6M] | | ------------------ | | 134| 15.6M| return __error; \ | | 135| 15.6M| } ------------------ 537| 15.6M| emit_context->arena, 538| 15.6M| YR_RE_CODE_SECTION, 539| 15.6M| &opcode, 540| 15.6M| sizeof(uint8_t), 541| 15.6M| instruction_ref)); 542| | 543| 15.6M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 15.6M| { \ | | 132| 15.6M| int __error = (x); \ | | 133| 15.6M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.6M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 15.6M] | | ------------------ | | 134| 15.6M| return __error; \ | | 135| 15.6M| } ------------------ 544| 15.6M| emit_context->arena, 545| 15.6M| YR_RE_CODE_SECTION, 546| 15.6M| &argument, 547| 15.6M| sizeof(uint8_t), 548| 15.6M| argument_ref)); 549| | 550| 15.6M| return ERROR_SUCCESS; ------------------ | | 40| 15.6M|#define ERROR_SUCCESS 0 ------------------ 551| 15.6M|} _yr_emit_inst_arg_uint16: 559| 2.89k|{ 560| 2.89k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 2.89k| { \ | | 132| 2.89k| int __error = (x); \ | | 133| 2.89k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.89k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.89k] | | ------------------ | | 134| 2.89k| return __error; \ | | 135| 2.89k| } ------------------ 561| 2.89k| emit_context->arena, 562| 2.89k| YR_RE_CODE_SECTION, 563| 2.89k| &opcode, 564| 2.89k| sizeof(uint8_t), 565| 2.89k| instruction_ref)); 566| | 567| 2.89k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 2.89k| { \ | | 132| 2.89k| int __error = (x); \ | | 133| 2.89k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.89k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.89k] | | ------------------ | | 134| 2.89k| return __error; \ | | 135| 2.89k| } ------------------ 568| 2.89k| emit_context->arena, 569| 2.89k| YR_RE_CODE_SECTION, 570| 2.89k| &argument, 571| 2.89k| sizeof(uint16_t), 572| 2.89k| argument_ref)); 573| | 574| 2.89k| return ERROR_SUCCESS; ------------------ | | 40| 2.89k|#define ERROR_SUCCESS 0 ------------------ 575| 2.89k|} _yr_emit_inst_arg_int16: 607| 28.1k|{ 608| 28.1k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 28.1k| { \ | | 132| 28.1k| int __error = (x); \ | | 133| 28.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 28.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 28.1k] | | ------------------ | | 134| 28.1k| return __error; \ | | 135| 28.1k| } ------------------ 609| 28.1k| emit_context->arena, 610| 28.1k| YR_RE_CODE_SECTION, 611| 28.1k| &opcode, 612| 28.1k| sizeof(uint8_t), 613| 28.1k| instruction_ref)); 614| | 615| 28.1k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 28.1k| { \ | | 132| 28.1k| int __error = (x); \ | | 133| 28.1k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 28.1k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 28.1k] | | ------------------ | | 134| 28.1k| return __error; \ | | 135| 28.1k| } ------------------ 616| 28.1k| emit_context->arena, 617| 28.1k| YR_RE_CODE_SECTION, 618| 28.1k| &argument, 619| 28.1k| sizeof(int16_t), 620| 28.1k| argument_ref)); 621| | 622| 28.1k| return ERROR_SUCCESS; ------------------ | | 40| 28.1k|#define ERROR_SUCCESS 0 ------------------ 623| 28.1k|} _yr_emit_inst_arg_struct: 632| 4.35M|{ 633| 4.35M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 4.35M| { \ | | 132| 4.35M| int __error = (x); \ | | 133| 4.35M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.35M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 4.35M] | | ------------------ | | 134| 4.35M| return __error; \ | | 135| 4.35M| } ------------------ 634| 4.35M| emit_context->arena, 635| 4.35M| YR_RE_CODE_SECTION, 636| 4.35M| &opcode, 637| 4.35M| sizeof(uint8_t), 638| 4.35M| instruction_ref)); 639| | 640| 4.35M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 4.35M| { \ | | 132| 4.35M| int __error = (x); \ | | 133| 4.35M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.35M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 4.35M] | | ------------------ | | 134| 4.35M| return __error; \ | | 135| 4.35M| } ------------------ 641| 4.35M| emit_context->arena, 642| 4.35M| YR_RE_CODE_SECTION, 643| 4.35M| structure, 644| 4.35M| structure_size, 645| 4.35M| argument_ref)); 646| | 647| 4.35M| return ERROR_SUCCESS; ------------------ | | 40| 4.35M|#define ERROR_SUCCESS 0 ------------------ 648| 4.35M|} _yr_emit_split: 656| 33.7k|{ 657| 33.7k| assert(opcode == RE_OPCODE_SPLIT_A || opcode == RE_OPCODE_SPLIT_B); 658| | 659| 33.7k| if (emit_context->next_split_id == RE_MAX_SPLIT_ID) ------------------ | | 165| 33.7k|#define RE_MAX_SPLIT_ID 128 ------------------ | Branch (659:7): [True: 49, False: 33.6k] ------------------ 660| 49| return ERROR_REGULAR_EXPRESSION_TOO_COMPLEX; ------------------ | | 94| 49|#define ERROR_REGULAR_EXPRESSION_TOO_COMPLEX 49 ------------------ 661| | 662| 33.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 33.6k| { \ | | 132| 33.6k| int __error = (x); \ | | 133| 33.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 33.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 33.6k] | | ------------------ | | 134| 33.6k| return __error; \ | | 135| 33.6k| } ------------------ 663| 33.6k| emit_context->arena, 664| 33.6k| YR_RE_CODE_SECTION, 665| 33.6k| &opcode, 666| 33.6k| sizeof(uint8_t), 667| 33.6k| instruction_ref)); 668| | 669| 33.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 33.6k| { \ | | 132| 33.6k| int __error = (x); \ | | 133| 33.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 33.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 33.6k] | | ------------------ | | 134| 33.6k| return __error; \ | | 135| 33.6k| } ------------------ 670| 33.6k| emit_context->arena, 671| 33.6k| YR_RE_CODE_SECTION, 672| 33.6k| &emit_context->next_split_id, 673| 33.6k| sizeof(RE_SPLIT_ID_TYPE), 674| 33.6k| NULL)); 675| | 676| 33.6k| emit_context->next_split_id++; 677| | 678| 33.6k| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 33.6k| { \ | | 132| 33.6k| int __error = (x); \ | | 133| 33.6k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 33.6k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 33.6k] | | ------------------ | | 134| 33.6k| return __error; \ | | 135| 33.6k| } ------------------ 679| 33.6k| emit_context->arena, 680| 33.6k| YR_RE_CODE_SECTION, 681| 33.6k| &argument, 682| 33.6k| sizeof(int16_t), 683| 33.6k| argument_ref)); 684| | 685| 33.6k| return ERROR_SUCCESS; ------------------ | | 40| 33.6k|#define ERROR_SUCCESS 0 ------------------ 686| 33.6k|} yr_re_ast_emit_code: 1196| 15.0k|{ 1197| 15.0k| RE_EMIT_CONTEXT emit_context; 1198| | 1199| | // Emit code for matching the regular expressions forwards. 1200| 15.0k| emit_context.arena = arena; 1201| 15.0k| emit_context.next_split_id = 0; 1202| | 1203| 15.0k| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 15.0k| { \ | | 132| 30.1k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 7.09k, False: 7.96k] | | ------------------ | | 133| 15.0k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.0k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 104, False: 14.9k] | | ------------------ | | 134| 15.0k| return __error; \ | | 135| 15.0k| } ------------------ 1204| 15.0k| &emit_context, 1205| 15.0k| re_ast->root_node, 1206| 15.0k| backwards_code ? EMIT_BACKWARDS : 0, 1207| 15.0k| NULL)); 1208| | 1209| 14.9k| FAIL_ON_ERROR(_yr_emit_inst(&emit_context, RE_OPCODE_MATCH, NULL)); ------------------ | | 131| 14.9k| { \ | | 132| 14.9k| int __error = (x); \ | | 133| 14.9k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 14.9k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 14.9k] | | ------------------ | | 134| 14.9k| return __error; \ | | 135| 14.9k| } ------------------ 1210| | 1211| 14.9k| return ERROR_SUCCESS; ------------------ | | 40| 14.9k|#define ERROR_SUCCESS 0 ------------------ 1212| 14.9k|} re.c:_yr_re_emit: 693| 29.3M|{ 694| 29.3M| int16_t jmp_offset; 695| | 696| 29.3M| yr_arena_off_t bookmark_1 = 0; 697| 29.3M| yr_arena_off_t bookmark_2 = 0; 698| 29.3M| yr_arena_off_t bookmark_3 = 0; 699| 29.3M| yr_arena_off_t bookmark_4 = 0; 700| | 701| 29.3M| bool emit_split; 702| 29.3M| bool emit_repeat; 703| 29.3M| bool emit_prolog; 704| 29.3M| bool emit_epilog; 705| | 706| 29.3M| RE_REPEAT_ARGS repeat_args; 707| 29.3M| RE_REPEAT_ARGS* repeat_start_args_addr; 708| 29.3M| RE_REPEAT_ANY_ARGS repeat_any_args; 709| | 710| 29.3M| RE_NODE* child; 711| | 712| 29.3M| int16_t* split_offset_addr = NULL; 713| 29.3M| int16_t* jmp_offset_addr = NULL; 714| | 715| 29.3M| YR_ARENA_REF instruction_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 29.3M| (YR_ARENA_REF) { UINT32_MAX, UINT32_MAX } ------------------ 716| 29.3M| YR_ARENA_REF split_offset_ref; 717| 29.3M| YR_ARENA_REF jmp_instruction_ref; 718| 29.3M| YR_ARENA_REF jmp_offset_ref; 719| 29.3M| YR_ARENA_REF repeat_start_args_ref; 720| | 721| 29.3M| switch (re_node->type) ------------------ | Branch (721:11): [True: 5.44k, False: 29.3M] ------------------ 722| 29.3M| { 723| 15.6M| case RE_NODE_LITERAL: ------------------ | | 41| 15.6M|#define RE_NODE_LITERAL 1 ------------------ | Branch (723:3): [True: 15.6M, False: 13.7M] ------------------ 724| 15.6M| FAIL_ON_ERROR(_yr_emit_inst_arg_uint8( ------------------ | | 131| 15.6M| { \ | | 132| 15.6M| int __error = (x); \ | | 133| 15.6M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 15.6M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 15.6M] | | ------------------ | | 134| 15.6M| return __error; \ | | 135| 15.6M| } ------------------ 725| 15.6M| emit_context, 726| 15.6M| RE_OPCODE_LITERAL, 727| 15.6M| re_node->value, 728| 15.6M| &instruction_ref, 729| 15.6M| NULL)); 730| 15.6M| break; 731| | 732| 266| case RE_NODE_NOT_LITERAL: ------------------ | | 62| 266|#define RE_NODE_NOT_LITERAL 22 ------------------ | Branch (732:3): [True: 266, False: 29.3M] ------------------ 733| 266| FAIL_ON_ERROR(_yr_emit_inst_arg_uint8( ------------------ | | 131| 266| { \ | | 132| 266| int __error = (x); \ | | 133| 266| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 266|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 266] | | ------------------ | | 134| 266| return __error; \ | | 135| 266| } ------------------ 734| 266| emit_context, 735| 266| RE_OPCODE_NOT_LITERAL, 736| 266| re_node->value, 737| 266| &instruction_ref, 738| 266| NULL)); 739| 266| break; 740| | 741| 2.63k| case RE_NODE_MASKED_LITERAL: ------------------ | | 42| 2.63k|#define RE_NODE_MASKED_LITERAL 2 ------------------ | Branch (741:3): [True: 2.63k, False: 29.3M] ------------------ 742| 2.63k| FAIL_ON_ERROR(_yr_emit_inst_arg_uint16( ------------------ | | 131| 2.63k| { \ | | 132| 2.63k| int __error = (x); \ | | 133| 2.63k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.63k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.63k] | | ------------------ | | 134| 2.63k| return __error; \ | | 135| 2.63k| } ------------------ 743| 2.63k| emit_context, 744| 2.63k| RE_OPCODE_MASKED_LITERAL, 745| 2.63k| re_node->mask << 8 | re_node->value, 746| 2.63k| &instruction_ref, 747| 2.63k| NULL)); 748| 2.63k| break; 749| | 750| 260| case RE_NODE_MASKED_NOT_LITERAL: ------------------ | | 63| 260|#define RE_NODE_MASKED_NOT_LITERAL 23 ------------------ | Branch (750:3): [True: 260, False: 29.3M] ------------------ 751| 260| FAIL_ON_ERROR(_yr_emit_inst_arg_uint16( ------------------ | | 131| 260| { \ | | 132| 260| int __error = (x); \ | | 133| 260| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 260|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 260] | | ------------------ | | 134| 260| return __error; \ | | 135| 260| } ------------------ 752| 260| emit_context, 753| 260| RE_OPCODE_MASKED_NOT_LITERAL, 754| 260| re_node->mask << 8 | re_node->value, 755| 260| &instruction_ref, 756| 260| NULL)); 757| 260| break; 758| | 759| 304| case RE_NODE_WORD_CHAR: ------------------ | | 50| 304|#define RE_NODE_WORD_CHAR 10 ------------------ | Branch (759:3): [True: 304, False: 29.3M] ------------------ 760| 304| FAIL_ON_ERROR( ------------------ | | 131| 304| { \ | | 132| 304| int __error = (x); \ | | 133| 304| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 304|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 304] | | ------------------ | | 134| 304| return __error; \ | | 135| 304| } ------------------ 761| 304| _yr_emit_inst(emit_context, RE_OPCODE_WORD_CHAR, &instruction_ref)); 762| 304| break; 763| | 764| 310| case RE_NODE_NON_WORD_CHAR: ------------------ | | 51| 310|#define RE_NODE_NON_WORD_CHAR 11 ------------------ | Branch (764:3): [True: 310, False: 29.3M] ------------------ 765| 310| FAIL_ON_ERROR( ------------------ | | 131| 310| { \ | | 132| 310| int __error = (x); \ | | 133| 310| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 310|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 310] | | ------------------ | | 134| 310| return __error; \ | | 135| 310| } ------------------ 766| 310| _yr_emit_inst(emit_context, RE_OPCODE_NON_WORD_CHAR, &instruction_ref)); 767| 310| break; 768| | 769| 337| case RE_NODE_WORD_BOUNDARY: ------------------ | | 59| 337|#define RE_NODE_WORD_BOUNDARY 19 ------------------ | Branch (769:3): [True: 337, False: 29.3M] ------------------ 770| 337| FAIL_ON_ERROR( ------------------ | | 131| 337| { \ | | 132| 337| int __error = (x); \ | | 133| 337| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 337|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 337] | | ------------------ | | 134| 337| return __error; \ | | 135| 337| } ------------------ 771| 337| _yr_emit_inst(emit_context, RE_OPCODE_WORD_BOUNDARY, &instruction_ref)); 772| 337| break; 773| | 774| 260| case RE_NODE_NON_WORD_BOUNDARY: ------------------ | | 60| 260|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ | Branch (774:3): [True: 260, False: 29.3M] ------------------ 775| 260| FAIL_ON_ERROR(_yr_emit_inst( ------------------ | | 131| 260| { \ | | 132| 260| int __error = (x); \ | | 133| 260| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 260|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 260] | | ------------------ | | 134| 260| return __error; \ | | 135| 260| } ------------------ 776| 260| emit_context, RE_OPCODE_NON_WORD_BOUNDARY, &instruction_ref)); 777| 260| break; 778| | 779| 132| case RE_NODE_SPACE: ------------------ | | 52| 132|#define RE_NODE_SPACE 12 ------------------ | Branch (779:3): [True: 132, False: 29.3M] ------------------ 780| 132| FAIL_ON_ERROR( ------------------ | | 131| 132| { \ | | 132| 132| int __error = (x); \ | | 133| 132| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 132|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 132] | | ------------------ | | 134| 132| return __error; \ | | 135| 132| } ------------------ 781| 132| _yr_emit_inst(emit_context, RE_OPCODE_SPACE, &instruction_ref)); 782| 132| break; 783| | 784| 264| case RE_NODE_NON_SPACE: ------------------ | | 53| 264|#define RE_NODE_NON_SPACE 13 ------------------ | Branch (784:3): [True: 264, False: 29.3M] ------------------ 785| 264| FAIL_ON_ERROR( ------------------ | | 131| 264| { \ | | 132| 264| int __error = (x); \ | | 133| 264| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 264|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 264] | | ------------------ | | 134| 264| return __error; \ | | 135| 264| } ------------------ 786| 264| _yr_emit_inst(emit_context, RE_OPCODE_NON_SPACE, &instruction_ref)); 787| 264| break; 788| | 789| 291| case RE_NODE_DIGIT: ------------------ | | 54| 291|#define RE_NODE_DIGIT 14 ------------------ | Branch (789:3): [True: 291, False: 29.3M] ------------------ 790| 291| FAIL_ON_ERROR( ------------------ | | 131| 291| { \ | | 132| 291| int __error = (x); \ | | 133| 291| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 291|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 291] | | ------------------ | | 134| 291| return __error; \ | | 135| 291| } ------------------ 791| 291| _yr_emit_inst(emit_context, RE_OPCODE_DIGIT, &instruction_ref)); 792| 291| break; 793| | 794| 400| case RE_NODE_NON_DIGIT: ------------------ | | 55| 400|#define RE_NODE_NON_DIGIT 15 ------------------ | Branch (794:3): [True: 400, False: 29.3M] ------------------ 795| 400| FAIL_ON_ERROR( ------------------ | | 131| 400| { \ | | 132| 400| int __error = (x); \ | | 133| 400| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 400|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 400] | | ------------------ | | 134| 400| return __error; \ | | 135| 400| } ------------------ 796| 400| _yr_emit_inst(emit_context, RE_OPCODE_NON_DIGIT, &instruction_ref)); 797| 400| break; 798| | 799| 254k| case RE_NODE_ANY: ------------------ | | 43| 254k|#define RE_NODE_ANY 3 ------------------ | Branch (799:3): [True: 254k, False: 29.0M] ------------------ 800| 254k| FAIL_ON_ERROR(_yr_emit_inst(emit_context, RE_OPCODE_ANY, &instruction_ref)); ------------------ | | 131| 254k| { \ | | 132| 254k| int __error = (x); \ | | 133| 254k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 254k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 254k] | | ------------------ | | 134| 254k| return __error; \ | | 135| 254k| } ------------------ 801| 254k| break; 802| | 803| 4.27M| case RE_NODE_CLASS: ------------------ | | 49| 4.27M|#define RE_NODE_CLASS 9 ------------------ | Branch (803:3): [True: 4.27M, False: 25.0M] ------------------ 804| 4.27M| FAIL_ON_ERROR( ------------------ | | 131| 4.27M| { \ | | 132| 4.27M| int __error = (x); \ | | 133| 4.27M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.27M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 4.27M] | | ------------------ | | 134| 4.27M| return __error; \ | | 135| 4.27M| } ------------------ 805| 4.27M| _yr_emit_inst(emit_context, RE_OPCODE_CLASS, &instruction_ref)); 806| | 807| 4.27M| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 131| 4.27M| { \ | | 132| 4.27M| int __error = (x); \ | | 133| 4.27M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.27M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 4.27M] | | ------------------ | | 134| 4.27M| return __error; \ | | 135| 4.27M| } ------------------ 808| 4.27M| emit_context->arena, 809| 4.27M| YR_RE_CODE_SECTION, 810| 4.27M| re_node->re_class, 811| 4.27M| sizeof(*re_node->re_class), 812| 4.27M| NULL)); 813| 4.27M| break; 814| | 815| 372| case RE_NODE_ANCHOR_START: ------------------ | | 57| 372|#define RE_NODE_ANCHOR_START 17 ------------------ | Branch (815:3): [True: 372, False: 29.3M] ------------------ 816| 372| FAIL_ON_ERROR(_yr_emit_inst( ------------------ | | 131| 372| { \ | | 132| 372| int __error = (x); \ | | 133| 372| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 372|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 372] | | ------------------ | | 134| 372| return __error; \ | | 135| 372| } ------------------ 817| 372| emit_context, RE_OPCODE_MATCH_AT_START, &instruction_ref)); 818| 372| break; 819| | 820| 4.41M| case RE_NODE_ANCHOR_END: ------------------ | | 58| 4.41M|#define RE_NODE_ANCHOR_END 18 ------------------ | Branch (820:3): [True: 4.41M, False: 24.9M] ------------------ 821| 4.41M| FAIL_ON_ERROR( ------------------ | | 131| 4.41M| { \ | | 132| 4.41M| int __error = (x); \ | | 133| 4.41M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 4.41M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 4.41M] | | ------------------ | | 134| 4.41M| return __error; \ | | 135| 4.41M| } ------------------ 822| 4.41M| _yr_emit_inst(emit_context, RE_OPCODE_MATCH_AT_END, &instruction_ref)); 823| 4.41M| break; 824| | 825| 2.55M| case RE_NODE_CONCAT: ------------------ | | 44| 2.55M|#define RE_NODE_CONCAT 4 ------------------ | Branch (825:3): [True: 2.55M, False: 26.8M] ------------------ 826| 2.55M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 2.55M| { \ | | 132| 5.10M| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 62.2k, False: 2.48M] | | ------------------ | | 133| 2.55M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.55M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 1.21k, False: 2.55M] | | ------------------ | | 134| 2.55M| return __error; \ | | 135| 2.55M| } ------------------ 827| 2.55M| emit_context, 828| 2.55M| (flags & EMIT_BACKWARDS) ? re_node->children_tail 829| 2.55M| : re_node->children_head, 830| 2.55M| flags, 831| 2.55M| &instruction_ref)); 832| | 833| 2.55M| if (flags & EMIT_BACKWARDS) ------------------ | | 55| 2.55M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (833:9): [True: 62.2k, False: 2.48M] ------------------ 834| 62.2k| child = re_node->children_tail->prev_sibling; 835| 2.48M| else 836| 2.48M| child = re_node->children_head->next_sibling; 837| | 838| 22.7M| while (child != NULL) ------------------ | Branch (838:12): [True: 20.1M, False: 2.55M] ------------------ 839| 20.1M| { 840| 20.1M| FAIL_ON_ERROR(_yr_re_emit(emit_context, child, flags, NULL)); ------------------ | | 131| 20.1M| { \ | | 132| 20.1M| int __error = (x); \ | | 133| 20.1M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 20.1M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 314, False: 20.1M] | | ------------------ | | 134| 20.1M| return __error; \ | | 135| 20.1M| } ------------------ 841| | 842| 20.1M| child = (flags & EMIT_BACKWARDS) ? child->prev_sibling ------------------ | | 55| 20.1M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (842:15): [True: 1.07M, False: 19.0M] ------------------ 843| 20.1M| : child->next_sibling; 844| 20.1M| } 845| 2.55M| break; 846| | 847| 2.55M| case RE_NODE_PLUS: ------------------ | | 48| 2.90k|#define RE_NODE_PLUS 8 ------------------ | Branch (847:3): [True: 2.90k, False: 29.3M] ------------------ 848| | // Code for e+ looks like: 849| | // 850| | // L1: code for e 851| | // split L1, L2 852| | // L2: 853| | // 854| 2.90k| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 2.90k| { \ | | 132| 2.90k| int __error = (x); \ | | 133| 2.90k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.90k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 51, False: 2.84k] | | ------------------ | | 134| 2.90k| return __error; \ | | 135| 2.90k| } ------------------ 855| 2.90k| emit_context, re_node->children_head, flags, &instruction_ref)); 856| | 857| 2.84k| bookmark_1 = yr_arena_get_current_offset( 858| 2.84k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.84k|#define YR_RE_CODE_SECTION 7 ------------------ 859| | 860| 2.84k| if (instruction_ref.offset - bookmark_1 < INT16_MIN) ------------------ | Branch (860:9): [True: 8, False: 2.84k] ------------------ 861| 8| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 8|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 862| | 863| 2.84k| jmp_offset = (int16_t) (instruction_ref.offset - bookmark_1); 864| | 865| 2.84k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 131| 2.84k| { \ | | 132| 5.68k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 2.62k, False: 218] | | ------------------ | | 133| 2.84k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.84k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 10, False: 2.83k] | | ------------------ | | 134| 2.84k| return __error; \ | | 135| 2.84k| } ------------------ 866| 2.84k| emit_context, 867| 2.84k| re_node->greedy ? RE_OPCODE_SPLIT_B : RE_OPCODE_SPLIT_A, 868| 2.84k| jmp_offset, 869| 2.84k| NULL, 870| 2.84k| NULL)); 871| | 872| 2.83k| break; 873| | 874| 2.88k| case RE_NODE_STAR: ------------------ | | 47| 2.88k|#define RE_NODE_STAR 7 ------------------ | Branch (874:3): [True: 2.88k, False: 29.3M] ------------------ 875| | // Code for e* looks like: 876| | // 877| | // L1: split L1, L2 878| | // code for e 879| | // jmp L1 880| | // L2: 881| 2.88k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 131| 2.88k| { \ | | 132| 5.76k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 1.10k, False: 1.77k] | | ------------------ | | 133| 2.88k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.88k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 21, False: 2.86k] | | ------------------ | | 134| 2.88k| return __error; \ | | 135| 2.88k| } ------------------ 882| 2.88k| emit_context, 883| 2.88k| re_node->greedy ? RE_OPCODE_SPLIT_A : RE_OPCODE_SPLIT_B, 884| 2.88k| 0, 885| 2.88k| &instruction_ref, 886| 2.88k| &split_offset_ref)); 887| | 888| 2.86k| FAIL_ON_ERROR( ------------------ | | 131| 2.86k| { \ | | 132| 2.86k| int __error = (x); \ | | 133| 2.86k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.86k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 12, False: 2.84k] | | ------------------ | | 134| 2.86k| return __error; \ | | 135| 2.86k| } ------------------ 889| 2.86k| _yr_re_emit(emit_context, re_node->children_head, flags, NULL)); 890| | 891| 2.84k| bookmark_1 = yr_arena_get_current_offset( 892| 2.84k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.84k|#define YR_RE_CODE_SECTION 7 ------------------ 893| | 894| 2.84k| if (instruction_ref.offset - bookmark_1 < INT16_MIN) ------------------ | Branch (894:9): [True: 4, False: 2.84k] ------------------ 895| 4| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 4|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 896| | 897| 2.84k| jmp_offset = (int16_t) (instruction_ref.offset - bookmark_1); 898| | 899| | // Emit jump with offset set to 0. 900| | 901| 2.84k| FAIL_ON_ERROR(_yr_emit_inst_arg_int16( ------------------ | | 131| 2.84k| { \ | | 132| 2.84k| int __error = (x); \ | | 133| 2.84k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.84k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.84k] | | ------------------ | | 134| 2.84k| return __error; \ | | 135| 2.84k| } ------------------ 902| 2.84k| emit_context, RE_OPCODE_JUMP, jmp_offset, NULL, NULL)); 903| | 904| 2.84k| bookmark_1 = yr_arena_get_current_offset( 905| 2.84k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.84k|#define YR_RE_CODE_SECTION 7 ------------------ 906| | 907| 2.84k| if (bookmark_1 - instruction_ref.offset > INT16_MAX) ------------------ | Branch (907:9): [True: 7, False: 2.83k] ------------------ 908| 7| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 7|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 909| | 910| 2.83k| jmp_offset = (int16_t) (bookmark_1 - instruction_ref.offset); 911| | 912| | // Update split offset. 913| 2.83k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 914| 2.83k| emit_context->arena, &split_offset_ref); 915| | 916| 2.83k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 917| 2.83k| break; 918| | 919| 25.8k| case RE_NODE_ALT: ------------------ | | 45| 25.8k|#define RE_NODE_ALT 5 ------------------ | Branch (919:3): [True: 25.8k, False: 29.3M] ------------------ 920| | // Code for e1|e2 looks like: 921| | // 922| | // split L1, L2 923| | // L1: code for e1 924| | // jmp L3 925| | // L2: code for e2 926| | // L3: 927| | 928| | // Emit a split instruction with offset set to 0 temporarily. Offset 929| | // will be updated after we know the size of the code generated for 930| | // the left node (e1). 931| | 932| 25.8k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 131| 25.8k| { \ | | 132| 25.8k| int __error = (x); \ | | 133| 25.8k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 25.8k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 11, False: 25.8k] | | ------------------ | | 134| 25.8k| return __error; \ | | 135| 25.8k| } ------------------ 933| 25.8k| emit_context, 934| 25.8k| RE_OPCODE_SPLIT_A, 935| 25.8k| 0, 936| 25.8k| &instruction_ref, 937| 25.8k| &split_offset_ref)); 938| | 939| 25.8k| FAIL_ON_ERROR( ------------------ | | 131| 25.8k| { \ | | 132| 25.8k| int __error = (x); \ | | 133| 25.8k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 25.8k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 562, False: 25.2k] | | ------------------ | | 134| 25.8k| return __error; \ | | 135| 25.8k| } ------------------ 940| 25.8k| _yr_re_emit(emit_context, re_node->children_head, flags, NULL)); 941| | 942| | // Emit jump with offset set to 0. 943| | 944| 25.2k| FAIL_ON_ERROR(_yr_emit_inst_arg_int16( ------------------ | | 131| 25.2k| { \ | | 132| 25.2k| int __error = (x); \ | | 133| 25.2k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 25.2k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 25.2k] | | ------------------ | | 134| 25.2k| return __error; \ | | 135| 25.2k| } ------------------ 945| 25.2k| emit_context, 946| 25.2k| RE_OPCODE_JUMP, 947| 25.2k| 0, 948| 25.2k| &jmp_instruction_ref, 949| 25.2k| &jmp_offset_ref)); 950| | 951| 25.2k| bookmark_1 = yr_arena_get_current_offset( 952| 25.2k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 25.2k|#define YR_RE_CODE_SECTION 7 ------------------ 953| | 954| 25.2k| if (bookmark_1 - instruction_ref.offset > INT16_MAX) ------------------ | Branch (954:9): [True: 19, False: 25.2k] ------------------ 955| 19| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 19|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 956| | 957| 25.2k| jmp_offset = (int16_t) (bookmark_1 - instruction_ref.offset); 958| | 959| | // Update split offset. 960| 25.2k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 961| 25.2k| emit_context->arena, &split_offset_ref); 962| | 963| 25.2k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 964| | 965| 25.2k| FAIL_ON_ERROR( ------------------ | | 131| 25.2k| { \ | | 132| 25.2k| int __error = (x); \ | | 133| 25.2k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 25.2k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 50, False: 25.1k] | | ------------------ | | 134| 25.2k| return __error; \ | | 135| 25.2k| } ------------------ 966| 25.2k| _yr_re_emit(emit_context, re_node->children_tail, flags, NULL)); 967| | 968| 25.1k| bookmark_1 = yr_arena_get_current_offset( 969| 25.1k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 25.1k|#define YR_RE_CODE_SECTION 7 ------------------ 970| | 971| 25.1k| if (bookmark_1 - jmp_instruction_ref.offset > INT16_MAX) ------------------ | Branch (971:9): [True: 8, False: 25.1k] ------------------ 972| 8| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 8|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 973| | 974| 25.1k| jmp_offset = (int16_t) (bookmark_1 - jmp_instruction_ref.offset); 975| | 976| | // Update offset for jmp instruction. 977| 25.1k| jmp_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 978| 25.1k| emit_context->arena, &jmp_offset_ref); 979| | 980| 25.1k| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 981| 25.1k| break; 982| | 983| 3.13k| case RE_NODE_RANGE_ANY: ------------------ | | 61| 3.13k|#define RE_NODE_RANGE_ANY 21 ------------------ | Branch (983:3): [True: 3.13k, False: 29.3M] ------------------ 984| 3.13k| repeat_any_args.min = re_node->start; 985| 3.13k| repeat_any_args.max = re_node->end; 986| | 987| 3.13k| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 131| 3.13k| { \ | | 132| 6.27k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 856, False: 2.28k] | | ------------------ | | 133| 3.13k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 3.13k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 3.13k] | | ------------------ | | 134| 3.13k| return __error; \ | | 135| 3.13k| } ------------------ 988| 3.13k| emit_context, 989| 3.13k| re_node->greedy ? RE_OPCODE_REPEAT_ANY_GREEDY 990| 3.13k| : RE_OPCODE_REPEAT_ANY_UNGREEDY, 991| 3.13k| &repeat_any_args, 992| 3.13k| sizeof(repeat_any_args), 993| 3.13k| &instruction_ref, 994| 3.13k| NULL)); 995| | 996| 3.13k| break; 997| | 998| 2.19M| case RE_NODE_RANGE: ------------------ | | 46| 2.19M|#define RE_NODE_RANGE 6 ------------------ | Branch (998:3): [True: 2.19M, False: 27.1M] ------------------ 999| | // Code for e{n,m} looks like: 1000| | // 1001| | // code for e --- prolog 1002| | // repeat_start n, m, L1 --+ 1003| | // L0: code for e | repeat 1004| | // repeat_end n, m, L0 --+ 1005| | // L1: split L2, L3 --- split 1006| | // L2: code for e --- epilog 1007| | // L3: 1008| | // 1009| | // Not all sections (prolog, repeat, split and epilog) are generated in all 1010| | // cases, it depends on the values of n and m. The following table shows 1011| | // which sections are generated for the first few values of n and m. 1012| | // 1013| | // n,m prolog repeat split epilog 1014| | // (min,max) 1015| | // --------------------------------------- 1016| | // 0,0 - - - - 1017| | // 0,1 - - X X 1018| | // 0,2 - 0,1 X X 1019| | // 0,3 - 0,2 X X 1020| | // 0,M - 0,M-1 X X 1021| | // 1022| | // 1,1 X - - - 1023| | // 1,2 X - X X 1024| | // 1,3 X 0,1 X X 1025| | // 1,4 X 1,2 X X 1026| | // 1,M X 1,M-2 X X 1027| | // 1028| | // 2,2 X - - X 1029| | // 2,3 X 1,1 X X 1030| | // 2,4 X 1,2 X X 1031| | // 2,M X 1,M-2 X X 1032| | // 1033| | // 3,3 X 1,1 - X 1034| | // 3,4 X 2,2 X X 1035| | // 3,M X 2,M-2 X X 1036| | // 1037| | // 4,4 X 2,2 - X 1038| | // 4,5 X 3,3 X X 1039| | // 4,M X 3,M-2 X X 1040| | // 1041| | // The code can't consists simply in the repeat section, the prolog and 1042| | // epilog are required because we can't have atoms pointing to code inside 1043| | // the repeat loop. Atoms' forwards_code will point to code in the prolog 1044| | // and backwards_code will point to code in the epilog (or in prolog if 1045| | // epilog wasn't generated, like in n=1,m=1) 1046| | 1047| 2.19M| emit_prolog = re_node->start > 0; 1048| 2.19M| emit_repeat = re_node->end > re_node->start + 1 || re_node->end > 2; ------------------ | Branch (1048:19): [True: 406, False: 2.19M] | Branch (1048:56): [True: 2.17M, False: 16.7k] ------------------ 1049| 2.19M| emit_split = re_node->end > re_node->start; 1050| 2.19M| emit_epilog = re_node->end > re_node->start || re_node->end > 1; ------------------ | Branch (1050:19): [True: 2.34k, False: 2.19M] | Branch (1050:52): [True: 2.19M, False: 70] ------------------ 1051| | 1052| 2.19M| if (emit_prolog) ------------------ | Branch (1052:9): [True: 2.19M, False: 2.28k] ------------------ 1053| 2.19M| { 1054| 2.19M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 2.19M| { \ | | 132| 2.19M| int __error = (x); \ | | 133| 2.19M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.19M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 304, False: 2.19M] | | ------------------ | | 134| 2.19M| return __error; \ | | 135| 2.19M| } ------------------ 1055| 2.19M| emit_context, re_node->children_head, flags, &instruction_ref)); 1056| 2.19M| } 1057| | 1058| 2.19M| if (emit_repeat) ------------------ | Branch (1058:9): [True: 2.17M, False: 16.7k] ------------------ 1059| 2.17M| { 1060| 2.17M| repeat_args.min = re_node->start; 1061| 2.17M| repeat_args.max = re_node->end; 1062| | 1063| 2.17M| if (emit_prolog) ------------------ | Branch (1063:11): [True: 2.17M, False: 344] ------------------ 1064| 2.17M| { 1065| 2.17M| repeat_args.max--; 1066| 2.17M| repeat_args.min--; 1067| 2.17M| } 1068| | 1069| 2.17M| if (emit_split) ------------------ | Branch (1069:11): [True: 406, False: 2.17M] ------------------ 1070| 406| { 1071| 406| repeat_args.max--; 1072| 406| } 1073| 2.17M| else 1074| 2.17M| { 1075| 2.17M| repeat_args.min--; 1076| 2.17M| repeat_args.max--; 1077| 2.17M| } 1078| | 1079| 2.17M| repeat_args.offset = 0; 1080| | 1081| 2.17M| bookmark_1 = yr_arena_get_current_offset( 1082| 2.17M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1083| | 1084| 2.17M| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 131| 2.17M| { \ | | 132| 8.70M| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 2.17M, False: 221] | | | Branch (132:20): [True: 2.17M, False: 344] | | ------------------ | | 133| 2.17M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.17M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.17M] | | ------------------ | | 134| 2.17M| return __error; \ | | 135| 2.17M| } ------------------ 1085| 2.17M| emit_context, 1086| 2.17M| re_node->greedy ? RE_OPCODE_REPEAT_START_GREEDY 1087| 2.17M| : RE_OPCODE_REPEAT_START_UNGREEDY, 1088| 2.17M| &repeat_args, 1089| 2.17M| sizeof(repeat_args), 1090| 2.17M| emit_prolog ? NULL : &instruction_ref, 1091| 2.17M| &repeat_start_args_ref)); 1092| | 1093| 2.17M| bookmark_2 = yr_arena_get_current_offset( 1094| 2.17M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1095| | 1096| 2.17M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 2.17M| { \ | | 132| 2.17M| int __error = (x); \ | | 133| 2.17M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.17M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 211, False: 2.17M] | | ------------------ | | 134| 2.17M| return __error; \ | | 135| 2.17M| } ------------------ 1097| 2.17M| emit_context, 1098| 2.17M| re_node->children_head, 1099| 2.17M| flags | EMIT_DONT_SET_FORWARDS_CODE | EMIT_DONT_SET_BACKWARDS_CODE, 1100| 2.17M| NULL)); 1101| | 1102| 2.17M| bookmark_3 = yr_arena_get_current_offset( 1103| 2.17M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1104| | 1105| 2.17M| if (bookmark_2 - bookmark_3 < INT32_MIN) ------------------ | Branch (1105:11): [True: 0, False: 2.17M] ------------------ 1106| 0| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 0|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1107| | 1108| 2.17M| repeat_args.offset = (int32_t) (bookmark_2 - bookmark_3); 1109| | 1110| 2.17M| FAIL_ON_ERROR(_yr_emit_inst_arg_struct( ------------------ | | 131| 2.17M| { \ | | 132| 4.35M| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 2.17M, False: 221] | | ------------------ | | 133| 2.17M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.17M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 2.17M] | | ------------------ | | 134| 2.17M| return __error; \ | | 135| 2.17M| } ------------------ 1111| 2.17M| emit_context, 1112| 2.17M| re_node->greedy ? RE_OPCODE_REPEAT_END_GREEDY 1113| 2.17M| : RE_OPCODE_REPEAT_END_UNGREEDY, 1114| 2.17M| &repeat_args, 1115| 2.17M| sizeof(repeat_args), 1116| 2.17M| NULL, 1117| 2.17M| NULL)); 1118| | 1119| 2.17M| bookmark_4 = yr_arena_get_current_offset( 1120| 2.17M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1121| | 1122| 2.17M| repeat_start_args_addr = (RE_REPEAT_ARGS*) yr_arena_ref_to_ptr( 1123| 2.17M| emit_context->arena, &repeat_start_args_ref); 1124| | 1125| 2.17M| if (bookmark_4 - bookmark_1 > INT32_MAX) ------------------ | Branch (1125:11): [True: 0, False: 2.17M] ------------------ 1126| 0| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 0|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1127| | 1128| 2.17M| repeat_start_args_addr->offset = (int32_t) (bookmark_4 - bookmark_1); 1129| 2.17M| } 1130| | 1131| 2.19M| if (emit_split) ------------------ | Branch (1131:9): [True: 2.18k, False: 2.19M] ------------------ 1132| 2.18k| { 1133| 2.18k| bookmark_1 = yr_arena_get_current_offset( 1134| 2.18k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.18k|#define YR_RE_CODE_SECTION 7 ------------------ 1135| | 1136| 2.18k| FAIL_ON_ERROR(_yr_emit_split( ------------------ | | 131| 2.18k| { \ | | 132| 4.36k| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 1.98k, False: 200] | | ------------------ | | 133| 2.18k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.18k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 7, False: 2.17k] | | ------------------ | | 134| 2.18k| return __error; \ | | 135| 2.18k| } ------------------ 1137| 2.18k| emit_context, 1138| 2.18k| re_node->greedy ? RE_OPCODE_SPLIT_A : RE_OPCODE_SPLIT_B, 1139| 2.18k| 0, 1140| 2.18k| NULL, 1141| 2.18k| &split_offset_ref)); 1142| 2.17k| } 1143| | 1144| 2.19M| if (emit_epilog) ------------------ | Branch (1144:9): [True: 2.19M, False: 65] ------------------ 1145| 2.19M| { 1146| 2.19M| FAIL_ON_ERROR(_yr_re_emit( ------------------ | | 131| 2.19M| { \ | | 132| 10.9M| int __error = (x); \ | | ------------------ | | | Branch (132:20): [True: 2.19M, False: 2.11k] | | | Branch (132:20): [True: 2.19M, False: 2.11k] | | | Branch (132:20): [True: 182, False: 1.93k] | | ------------------ | | 133| 2.19M| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2.19M|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 99, False: 2.19M] | | ------------------ | | 134| 2.19M| return __error; \ | | 135| 2.19M| } ------------------ 1147| 2.19M| emit_context, 1148| 2.19M| re_node->children_head, 1149| 2.19M| emit_prolog ? flags | EMIT_DONT_SET_FORWARDS_CODE : flags, 1150| 2.19M| emit_prolog || emit_repeat ? NULL : &instruction_ref)); 1151| 2.19M| } 1152| | 1153| 2.19M| if (emit_split) ------------------ | Branch (1153:9): [True: 2.14k, False: 2.19M] ------------------ 1154| 2.14k| { 1155| 2.14k| bookmark_2 = yr_arena_get_current_offset( 1156| 2.14k| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 2.14k|#define YR_RE_CODE_SECTION 7 ------------------ 1157| | 1158| 2.14k| if (bookmark_2 - bookmark_1 > INT16_MAX) ------------------ | Branch (1158:11): [True: 9, False: 2.13k] ------------------ 1159| 9| return ERROR_REGULAR_EXPRESSION_TOO_LARGE; ------------------ | | 90| 9|#define ERROR_REGULAR_EXPRESSION_TOO_LARGE 45 ------------------ 1160| | 1161| 2.13k| split_offset_addr = (int16_t*) yr_arena_ref_to_ptr( 1162| 2.13k| emit_context->arena, &split_offset_ref); 1163| | 1164| 2.13k| jmp_offset = (int16_t) (bookmark_2 - bookmark_1); 1165| | 1166| 2.13k| memcpy(split_offset_addr, &jmp_offset, sizeof(jmp_offset)); 1167| 2.13k| } 1168| | 1169| 2.19M| break; 1170| 29.3M| } 1171| | 1172| 29.3M| if (flags & EMIT_BACKWARDS) ------------------ | | 55| 29.3M|#define EMIT_BACKWARDS 0x01 ------------------ | Branch (1172:7): [True: 1.17M, False: 28.1M] ------------------ 1173| 1.17M| { 1174| 1.17M| if (!(flags & EMIT_DONT_SET_BACKWARDS_CODE)) ------------------ | | 57| 1.17M|#define EMIT_DONT_SET_BACKWARDS_CODE 0x04 ------------------ | Branch (1174:9): [True: 1.17M, False: 53] ------------------ 1175| 1.17M| { 1176| 1.17M| re_node->backward_code_ref.buffer_id = YR_RE_CODE_SECTION; ------------------ | | 64| 1.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1177| 1.17M| re_node->backward_code_ref.offset = yr_arena_get_current_offset( 1178| 1.17M| emit_context->arena, YR_RE_CODE_SECTION); ------------------ | | 64| 1.17M|#define YR_RE_CODE_SECTION 7 ------------------ 1179| 1.17M| } 1180| 1.17M| } 1181| 28.1M| else 1182| 28.1M| { 1183| 28.1M| if (!(flags & EMIT_DONT_SET_FORWARDS_CODE)) ------------------ | | 56| 28.1M|#define EMIT_DONT_SET_FORWARDS_CODE 0x02 ------------------ | Branch (1183:9): [True: 1.44M, False: 26.7M] ------------------ 1184| 1.44M| { 1185| 1.44M| re_node->forward_code_ref = instruction_ref; 1186| 1.44M| } 1187| 28.1M| } 1188| | 1189| 29.3M| if (code_ref != NULL) ------------------ | Branch (1189:7): [True: 4.74M, False: 24.6M] ------------------ 1190| 4.74M| *code_ref = instruction_ref; 1191| | 1192| 29.3M| return ERROR_SUCCESS; ------------------ | | 40| 29.3M|#define ERROR_SUCCESS 0 ------------------ 1193| 29.3M|} re_yyparse: 1009| 20.5k|{ 1010| |/* Lookahead token kind. */ 1011| 20.5k|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| 20.5k|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 418| 20.5k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1018| 20.5k|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 418| 20.5k|# define YY_INITIAL_VALUE(Value) Value ------------------ 1019| | 1020| | /* Number of syntax errors so far. */ 1021| 20.5k| int yynerrs = 0; 1022| | 1023| 20.5k| yy_state_fast_t yystate = 0; 1024| | /* Number of tokens to shift before error messages enabled. */ 1025| 20.5k| 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| 20.5k| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 325| 20.5k|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 925| 20.5k|# define YYINITDEPTH 200 ------------------ 1032| | 1033| | /* The state stack: array, bottom, top. */ 1034| 20.5k| yy_state_t yyssa[YYINITDEPTH]; 1035| 20.5k| yy_state_t *yyss = yyssa; 1036| 20.5k| yy_state_t *yyssp = yyss; 1037| | 1038| | /* The semantic value stack: array, bottom, top. */ 1039| 20.5k| YYSTYPE yyvsa[YYINITDEPTH]; 1040| 20.5k| YYSTYPE *yyvs = yyvsa; 1041| 20.5k| YYSTYPE *yyvsp = yyvs; 1042| | 1043| 20.5k| int yyn; 1044| | /* The return value of yyparse. */ 1045| 20.5k| int yyresult; 1046| | /* Lookahead symbol kind. */ 1047| 20.5k| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1048| | /* The variables used to return semantic value and location from the 1049| | action routines. */ 1050| 20.5k| YYSTYPE yyval; 1051| | 1052| | 1053| | 1054| 20.5k|#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| 20.5k| int yylen = 0; 1059| | 1060| 20.5k| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 916| 20.5k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1061| | 1062| 20.5k| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 48| 20.5k|#define yychar re_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 73| 20.5k|#define YYEMPTY -2 ------------------ 1063| | 1064| 20.5k| goto yysetstate; 1065| | 1066| | 1067| |/*------------------------------------------------------------. 1068| || yynewstate -- push a new state, which is found in yystate. | 1069| |`------------------------------------------------------------*/ 1070| 8.16M|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| 8.16M| yyssp++; 1074| | 1075| | 1076| |/*--------------------------------------------------------------------. 1077| || yysetstate -- set current state (the top of the stack) to yystate. | 1078| |`--------------------------------------------------------------------*/ 1079| 8.18M|yysetstate: 1080| 8.18M| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 916| 8.18M|# define YYDPRINTF(Args) ((void) 0) ------------------ 1081| 8.18M| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 441| 8.18M|#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| 8.18M| YY_IGNORE_USELESS_CAST_BEGIN 1083| 8.18M| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 116| 8.18M|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1084| 8.18M| YY_IGNORE_USELESS_CAST_END 1085| 8.18M| YY_STACK_PRINT (yyss, yyssp); 1086| | 1087| 8.18M| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1087:7): [True: 208, False: 8.18M] ------------------ 1088| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1089| | YYNOMEM; 1090| |#else 1091| 208| { 1092| | /* Get the current used size of the three stacks, in elements. */ 1093| 208| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 325| 208|# 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| 208| if (YYMAXDEPTH <= yystacksize) ------------------ | | 936| 208|# define YYMAXDEPTH 10000 ------------------ | Branch (1116:11): [True: 0, False: 208] ------------------ 1117| 0| YYNOMEM; ------------------ | | 767| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1118| 208| yystacksize *= 2; 1119| 208| if (YYMAXDEPTH < yystacksize) ------------------ | | 936| 208|# define YYMAXDEPTH 10000 ------------------ | Branch (1119:11): [True: 3, False: 205] ------------------ 1120| 3| yystacksize = YYMAXDEPTH; ------------------ | | 936| 3|# define YYMAXDEPTH 10000 ------------------ 1121| | 1122| 208| { 1123| 208| yy_state_t *yyss1 = yyss; 1124| 208| union yyalloc *yyptr = 1125| 208| YY_CAST (union yyalloc *, ------------------ | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1126| 208| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 1127| 208| if (! yyptr) ------------------ | Branch (1127:13): [True: 0, False: 208] ------------------ 1128| 0| YYNOMEM; ------------------ | | 767| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 1129| 208| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 538| 208| do \ | | 539| 208| { \ | | 540| 208| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 325| 208|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 541| 208| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 556| 208| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 542| 208| Stack = &yyptr->Stack_alloc; \ | | 543| 208| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 522| 208|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 544| 208| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 545| 208| } \ | | 546| 208| while (0) | | ------------------ | | | Branch (546:12): [Folded - Ignored] | | ------------------ ------------------ 1130| 208| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 538| 208| do \ | | 539| 208| { \ | | 540| 208| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 325| 208|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 541| 208| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 556| 208| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 542| 208| Stack = &yyptr->Stack_alloc; \ | | 543| 208| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 522| 208|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 544| 208| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 358| 208|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 116| 208|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 545| 208| } \ | | 546| 208| while (0) | | ------------------ | | | Branch (546:12): [Folded - Ignored] | | ------------------ ------------------ 1131| 208|# undef YYSTACK_RELOCATE 1132| 208| if (yyss1 != yyssa) ------------------ | Branch (1132:13): [True: 132, False: 76] ------------------ 1133| 132| YYSTACK_FREE (yyss1); ------------------ | | 483| 132|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 90| 132|#define YYFREE yr_free | | ------------------ ------------------ 1134| 208| } 1135| 0|# endif 1136| | 1137| 0| yyssp = yyss + yysize - 1; 1138| 208| yyvsp = yyvs + yysize - 1; 1139| | 1140| 208| YY_IGNORE_USELESS_CAST_BEGIN 1141| 208| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 916| 208|# define YYDPRINTF(Args) ((void) 0) ------------------ 1142| 208| YY_CAST (long, yystacksize))); 1143| 208| YY_IGNORE_USELESS_CAST_END 1144| | 1145| 208| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1145:11): [True: 0, False: 208] ------------------ 1146| 0| YYABORT; ------------------ | | 765| 0|#define YYABORT goto yyabortlab ------------------ 1147| 208| } 1148| 8.18M|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 1149| | 1150| | 1151| 8.18M| if (yystate == YYFINAL) ------------------ | | 571| 8.18M|#define YYFINAL 22 ------------------ | Branch (1151:7): [True: 20.5k, False: 8.16M] ------------------ 1152| 20.5k| YYACCEPT; ------------------ | | 764| 20.5k|#define YYACCEPT goto yyacceptlab ------------------ 1153| | 1154| 8.16M| goto yybackup; 1155| | 1156| | 1157| |/*-----------. 1158| || yybackup. | 1159| |`-----------*/ 1160| 8.16M|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| 8.16M| yyn = yypact[yystate]; 1166| 8.16M| if (yypact_value_is_default (yyn)) ------------------ | | 669| 8.16M| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 666| 8.16M|#define YYPACT_NINF (-12) | | ------------------ | | | Branch (669:3): [True: 3.96M, False: 4.20M] | | ------------------ ------------------ 1167| 3.96M| 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| 4.20M| if (yychar == YYEMPTY) ------------------ | | 48| 4.20M|#define yychar re_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 73| 4.20M|#define YYEMPTY -2 ------------------ | Branch (1172:7): [True: 2.12M, False: 2.07M] ------------------ 1173| 2.12M| { 1174| 2.12M| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 916| 2.12M|# define YYDPRINTF(Args) ((void) 0) ------------------ 1175| 2.12M| yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 48| 2.12M|#define yychar re_yychar ------------------ yychar = yylex (&yylval, yyscanner, lex_env); ------------------ | | 45| 2.12M|#define yylex re_yylex ------------------ 1176| 2.12M| } 1177| | 1178| 4.20M| if (yychar <= YYEOF) ------------------ | | 48| 4.20M|#define yychar re_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 74| 4.20M|#define YYEOF 0 ------------------ | Branch (1178:7): [True: 81.1k, False: 4.11M] ------------------ 1179| 81.1k| { 1180| 81.1k| yychar = YYEOF; ------------------ | | 48| 81.1k|#define yychar re_yychar ------------------ yychar = YYEOF; ------------------ | | 74| 81.1k|#define YYEOF 0 ------------------ 1181| 81.1k| yytoken = YYSYMBOL_YYEOF; 1182| 81.1k| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 916| 81.1k|# define YYDPRINTF(Args) ((void) 0) ------------------ 1183| 81.1k| } 1184| 4.11M| else if (yychar == YYerror) ------------------ | | 48| 4.11M|#define yychar re_yychar ------------------ else if (yychar == YYerror) ------------------ | | 75| 4.11M|#define YYerror 256 ------------------ | Branch (1184:12): [True: 0, False: 4.11M] ------------------ 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; ------------------ | | 48| 0|#define yychar re_yychar ------------------ yychar = YYUNDEF; ------------------ | | 76| 0|#define YYUNDEF 257 ------------------ 1191| 0| yytoken = YYSYMBOL_YYerror; 1192| 0| goto yyerrlab1; 1193| 0| } 1194| 4.11M| else 1195| 4.11M| { 1196| 4.11M| yytoken = YYTRANSLATE (yychar); ------------------ | | 591| 4.11M| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 585| 4.11M|#define YYMAXUTOK 269 | | ------------------ | | | Branch (591:4): [True: 4.11M, False: 0] | | | Branch (591:18): [True: 4.11M, False: 0] | | ------------------ | | 592| 4.11M| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 116| 4.11M|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 593| 4.11M| : YYSYMBOL_YYUNDEF) ------------------ 1197| 4.11M| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1198| 4.11M| } 1199| | 1200| | /* If the proper action on seeing token YYTOKEN is to reduce or to 1201| | detect an error, take that action. */ 1202| 4.20M| yyn += yytoken; 1203| 4.20M| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 573| 4.16M|#define YYLAST 45 ------------------ | Branch (1203:7): [True: 39.3k, False: 4.16M] | Branch (1203:18): [True: 268, False: 4.16M] | Branch (1203:34): [True: 2.03M, False: 2.12M] ------------------ 1204| 2.07M| goto yydefault; 1205| 2.12M| yyn = yytable[yyn]; 1206| 2.12M| if (yyn <= 0) ------------------ | Branch (1206:7): [True: 0, False: 2.12M] ------------------ 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.12M| if (yyerrstatus) ------------------ | Branch (1216:7): [True: 281, False: 2.12M] ------------------ 1217| 281| yyerrstatus--; 1218| | 1219| | /* Shift the lookahead token. */ 1220| 2.12M| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1221| 2.12M| yystate = yyn; 1222| 2.12M| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1223| 2.12M| *++yyvsp = yylval; 1224| 2.12M| YY_IGNORE_MAYBE_UNINITIALIZED_END 1225| | 1226| | /* Discard the shifted token. */ 1227| 2.12M| yychar = YYEMPTY; ------------------ | | 48| 2.12M|#define yychar re_yychar ------------------ yychar = YYEMPTY; ------------------ | | 73| 2.12M|#define YYEMPTY -2 ------------------ 1228| 2.12M| goto yynewstate; 1229| | 1230| | 1231| |/*-----------------------------------------------------------. 1232| || yydefault -- do the default action for the current state. | 1233| |`-----------------------------------------------------------*/ 1234| 6.03M|yydefault: 1235| 6.03M| yyn = yydefact[yystate]; 1236| 6.03M| if (yyn == 0) ------------------ | Branch (1236:7): [True: 1.34k, False: 6.03M] ------------------ 1237| 1.34k| goto yyerrlab; 1238| 6.03M| goto yyreduce; 1239| | 1240| | 1241| |/*-----------------------------. 1242| || yyreduce -- do a reduction. | 1243| |`-----------------------------*/ 1244| 6.03M|yyreduce: 1245| | /* yyn is the number of a rule to reduce with. */ 1246| 6.03M| 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| 6.03M| yyval = yyvsp[1-yylen]; 1257| | 1258| | 1259| 6.03M| YY_REDUCE_PRINT (yyn); 1260| 6.03M| switch (yyn) 1261| 6.03M| { 1262| 20.3k| case 2: /* re: alternative */ ------------------ | Branch (1262:3): [True: 20.3k, False: 6.01M] ------------------ 1263| 20.3k|#line 107 "re_grammar.y" 1264| 20.3k| { 1265| 20.3k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 51| 20.3k|#define yyget_extra re_yyget_extra ------------------ 1266| 20.3k| re_ast->root_node = (yyvsp[0].re_node); 1267| 20.3k| } 1268| 20.3k|#line 1269 "re_grammar.c" 1269| 20.3k| break; 1270| | 1271| 68.8k| case 4: /* alternative: concatenation */ ------------------ | Branch (1271:3): [True: 68.8k, False: 5.96M] ------------------ 1272| 68.8k|#line 116 "re_grammar.y" 1273| 68.8k| { 1274| 68.8k| (yyval.re_node) = (yyvsp[0].re_node); 1275| 68.8k| } 1276| 68.8k|#line 1277 "re_grammar.c" 1277| 68.8k| break; 1278| | 1279| 9.48k| case 5: /* alternative: alternative '|' concatenation */ ------------------ | Branch (1279:3): [True: 9.48k, False: 6.02M] ------------------ 1280| 9.48k|#line 120 "re_grammar.y" 1281| 9.48k| { 1282| 9.48k| mark_as_not_fast_regexp(); ------------------ | | 93| 9.48k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 9.48k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 9.48k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1283| | 1284| 9.48k| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 9.48k|#define RE_NODE_ALT 5 ------------------ 1285| | 1286| 9.48k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 9.48k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 9.48k] | | ------------------ | | 104| 9.48k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1287| 9.48k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 103| 9.48k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 9.48k] | | ------------------ | | 104| 9.48k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1288| | 1289| 9.48k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 9.48k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 9.48k] | | ------------------ | | 97| 9.48k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1290| | 1291| 9.48k| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1292| 9.48k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1293| 9.48k| } 1294| 0|#line 1295 "re_grammar.c" 1295| 0| break; 1296| | 1297| 2.99k| case 6: /* alternative: alternative '|' */ ------------------ | Branch (1297:3): [True: 2.99k, False: 6.03M] ------------------ 1298| 2.99k|#line 134 "re_grammar.y" 1299| 2.99k| { 1300| 2.99k| RE_NODE* node; 1301| | 1302| 2.99k| mark_as_not_fast_regexp(); ------------------ | | 93| 2.99k| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 2.99k|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 2.99k|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1303| | 1304| 2.99k| node = yr_re_node_create(RE_NODE_EMPTY); ------------------ | | 56| 2.99k|#define RE_NODE_EMPTY 16 ------------------ 1305| | 1306| 2.99k| destroy_node_if(node == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 2.99k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 2.99k] | | ------------------ | | 104| 2.99k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1307| 2.99k| fail_if(node == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 2.99k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 2.99k] | | ------------------ | | 97| 2.99k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1308| | 1309| 2.99k| (yyval.re_node) = yr_re_node_create(RE_NODE_ALT); ------------------ | | 45| 2.99k|#define RE_NODE_ALT 5 ------------------ 1310| | 1311| 2.99k| destroy_node_if((yyval.re_node) == NULL, node); ------------------ | | 103| 2.99k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 2.99k] | | ------------------ | | 104| 2.99k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1312| 2.99k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 2.99k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 2.99k] | | ------------------ | | 104| 2.99k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1313| | 1314| 2.99k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 2.99k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 2.99k] | | ------------------ | | 97| 2.99k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1315| | 1316| 2.99k| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1317| 2.99k| yr_re_node_append_child((yyval.re_node), node); 1318| 2.99k| } 1319| 0|#line 1320 "re_grammar.c" 1320| 0| break; 1321| | 1322| 79.8k| case 7: /* concatenation: repeat */ ------------------ | Branch (1322:3): [True: 79.8k, False: 5.95M] ------------------ 1323| 79.8k|#line 158 "re_grammar.y" 1324| 79.8k| { 1325| 79.8k| (yyval.re_node) = yr_re_node_create(RE_NODE_CONCAT); ------------------ | | 44| 79.8k|#define RE_NODE_CONCAT 4 ------------------ 1326| | 1327| 79.8k| destroy_node_if((yyval.re_node) == NULL, (yyvsp[0].re_node)); ------------------ | | 103| 79.8k| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 79.8k] | | ------------------ | | 104| 79.8k| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1328| 79.8k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 79.8k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 79.8k] | | ------------------ | | 97| 79.8k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1329| | 1330| 79.8k| yr_re_node_append_child((yyval.re_node), (yyvsp[0].re_node)); 1331| 79.8k| } 1332| 0|#line 1333 "re_grammar.c" 1333| 0| break; 1334| | 1335| 1.89M| case 8: /* concatenation: concatenation repeat */ ------------------ | Branch (1335:3): [True: 1.89M, False: 4.13M] ------------------ 1336| 1.89M|#line 167 "re_grammar.y" 1337| 1.89M| { 1338| 1.89M| yr_re_node_append_child((yyvsp[-1].re_node), (yyvsp[0].re_node)); 1339| 1.89M| (yyval.re_node) = (yyvsp[-1].re_node); 1340| 1.89M| } 1341| 1.89M|#line 1342 "re_grammar.c" 1342| 1.89M| break; 1343| | 1344| 346| case 9: /* repeat: single '*' */ ------------------ | Branch (1344:3): [True: 346, False: 6.03M] ------------------ 1345| 346|#line 175 "re_grammar.y" 1346| 346| { 1347| 346| RE_AST* re_ast; 1348| | 1349| 346| mark_as_not_fast_regexp(); ------------------ | | 93| 346| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 346|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 346|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1350| | 1351| 346| re_ast = yyget_extra(yyscanner); ------------------ | | 51| 346|#define yyget_extra re_yyget_extra ------------------ 1352| 346| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 346|#define RE_FLAGS_GREEDY 0x400 ------------------ 1353| | 1354| 346| (yyval.re_node) = yr_re_node_create(RE_NODE_STAR); ------------------ | | 47| 346|#define RE_NODE_STAR 7 ------------------ 1355| | 1356| 346| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 346| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 346] | | ------------------ | | 104| 346| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1357| 346| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 346| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 346] | | ------------------ | | 97| 346| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1358| | 1359| 346| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1360| 346| } 1361| 0|#line 1362 "re_grammar.c" 1362| 0| break; 1363| | 1364| 246| case 10: /* repeat: single '*' '?' */ ------------------ | Branch (1364:3): [True: 246, False: 6.03M] ------------------ 1365| 246|#line 191 "re_grammar.y" 1366| 246| { 1367| 246| RE_AST* re_ast; 1368| | 1369| 246| mark_as_not_fast_regexp(); ------------------ | | 93| 246| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 246|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 246|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1370| | 1371| 246| re_ast = yyget_extra(yyscanner); ------------------ | | 51| 246|#define yyget_extra re_yyget_extra ------------------ 1372| 246| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 246|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1373| | 1374| 246| (yyval.re_node) = yr_re_node_create(RE_NODE_STAR); ------------------ | | 47| 246|#define RE_NODE_STAR 7 ------------------ 1375| | 1376| 246| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 246| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 246] | | ------------------ | | 104| 246| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1377| 246| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 246| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 246] | | ------------------ | | 97| 246| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1378| | 1379| 246| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1380| | 1381| 246| (yyval.re_node)->greedy = false; 1382| 246| } 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: 6.03M] ------------------ 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 | | ------------------ | | | | 51| 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); ------------------ | | 51| 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| 160| case 12: /* repeat: single '+' '?' */ ------------------ | Branch (1406:3): [True: 160, False: 6.03M] ------------------ 1407| 160|#line 225 "re_grammar.y" 1408| 160| { 1409| 160| RE_AST* re_ast; 1410| | 1411| 160| mark_as_not_fast_regexp(); ------------------ | | 93| 160| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 160|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 160|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1412| | 1413| 160| re_ast = yyget_extra(yyscanner); ------------------ | | 51| 160|#define yyget_extra re_yyget_extra ------------------ 1414| 160| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 160|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1415| | 1416| 160| (yyval.re_node) = yr_re_node_create(RE_NODE_PLUS); ------------------ | | 48| 160|#define RE_NODE_PLUS 8 ------------------ 1417| | 1418| 160| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 160| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 160] | | ------------------ | | 104| 160| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1419| 160| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 160| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 160] | | ------------------ | | 97| 160| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1420| | 1421| 160| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1422| 160| (yyval.re_node)->greedy = false; 1423| 160| } 1424| 0|#line 1425 "re_grammar.c" 1425| 0| break; 1426| | 1427| 587| case 13: /* repeat: single '?' */ ------------------ | Branch (1427:3): [True: 587, False: 6.03M] ------------------ 1428| 587|#line 242 "re_grammar.y" 1429| 587| { 1430| 587| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 51| 587|#define yyget_extra re_yyget_extra ------------------ 1431| 587| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 587|#define RE_FLAGS_GREEDY 0x400 ------------------ 1432| | 1433| 587| if ((yyvsp[-1].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 587|#define RE_NODE_ANY 3 ------------------ | Branch (1433:13): [True: 130, False: 457] ------------------ 1434| 130| { 1435| 130| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 130|#define RE_NODE_RANGE_ANY 21 ------------------ 1436| 130| destroy_node_if(true, (yyvsp[-1].re_node)); ------------------ | | 103| 130| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 130| { \ | | 105| 130| yr_re_node_destroy(node); \ | | 106| 130| } \ ------------------ 1437| 130| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 130| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 130] | | ------------------ | | 97| 130| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1438| 130| } 1439| 457| else 1440| 457| { 1441| 457| mark_as_not_fast_regexp(); ------------------ | | 93| 457| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 457|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 457|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1442| 457| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 457|#define RE_NODE_RANGE 6 ------------------ 1443| 457| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 457| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 457] | | ------------------ | | 104| 457| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1444| 457| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 457| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 457] | | ------------------ | | 97| 457| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1445| 457| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1446| 457| } 1447| | 1448| 587| (yyval.re_node)->start = 0; 1449| 587| (yyval.re_node)->end = 1; 1450| 587| } 1451| 0|#line 1452 "re_grammar.c" 1452| 0| break; 1453| | 1454| 624| case 14: /* repeat: single '?' '?' */ ------------------ | Branch (1454:3): [True: 624, False: 6.03M] ------------------ 1455| 624|#line 265 "re_grammar.y" 1456| 624| { 1457| 624| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 51| 624|#define yyget_extra re_yyget_extra ------------------ 1458| 624| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 624|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1459| | 1460| 624| if ((yyvsp[-2].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 624|#define RE_NODE_ANY 3 ------------------ | Branch (1460:13): [True: 445, False: 179] ------------------ 1461| 445| { 1462| 445| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 445|#define RE_NODE_RANGE_ANY 21 ------------------ 1463| 445| destroy_node_if(true, (yyvsp[-2].re_node)); ------------------ | | 103| 445| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 445| { \ | | 105| 445| yr_re_node_destroy(node); \ | | 106| 445| } \ ------------------ 1464| 445| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 445| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 445] | | ------------------ | | 97| 445| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1465| 445| } 1466| 179| else 1467| 179| { 1468| 179| mark_as_not_fast_regexp(); ------------------ | | 93| 179| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 179|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 179|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1469| 179| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 179|#define RE_NODE_RANGE 6 ------------------ 1470| 179| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 179| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 179] | | ------------------ | | 104| 179| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1471| 179| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 179| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 179] | | ------------------ | | 97| 179| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1472| 179| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1473| 179| } 1474| | 1475| 624| (yyval.re_node)->start = 0; 1476| 624| (yyval.re_node)->end = 1; 1477| 624| (yyval.re_node)->greedy = false; 1478| 624| } 1479| 0|#line 1480 "re_grammar.c" 1480| 0| break; 1481| | 1482| 1.21k| case 15: /* repeat: single _RANGE_ */ ------------------ | Branch (1482:3): [True: 1.21k, False: 6.03M] ------------------ 1483| 1.21k|#line 289 "re_grammar.y" 1484| 1.21k| { 1485| 1.21k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 51| 1.21k|#define yyget_extra re_yyget_extra ------------------ 1486| 1.21k| re_ast->flags |= RE_FLAGS_GREEDY; ------------------ | | 101| 1.21k|#define RE_FLAGS_GREEDY 0x400 ------------------ 1487| | 1488| 1.21k| if ((yyvsp[-1].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 1.21k|#define RE_NODE_ANY 3 ------------------ | Branch (1488:13): [True: 298, False: 914] ------------------ 1489| 298| { 1490| 298| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 298|#define RE_NODE_RANGE_ANY 21 ------------------ 1491| 298| destroy_node_if(true, (yyvsp[-1].re_node)); ------------------ | | 103| 298| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 298| { \ | | 105| 298| yr_re_node_destroy(node); \ | | 106| 298| } \ ------------------ 1492| 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| } \ ------------------ 1493| 298| } 1494| 914| else 1495| 914| { 1496| 914| mark_as_not_fast_regexp(); ------------------ | | 93| 914| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 914|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 914|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1497| 914| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 914|#define RE_NODE_RANGE 6 ------------------ 1498| 914| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-1].re_node)); ------------------ | | 103| 914| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 914] | | ------------------ | | 104| 914| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1499| 914| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 914| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 914] | | ------------------ | | 97| 914| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1500| 914| yr_re_node_append_child((yyval.re_node), (yyvsp[-1].re_node)); 1501| 914| } 1502| | 1503| 1.21k| (yyval.re_node)->start = (yyvsp[0].range) & 0xFFFF;; 1504| 1.21k| (yyval.re_node)->end = (yyvsp[0].range) >> 16;; 1505| 1.21k| } 1506| 0|#line 1507 "re_grammar.c" 1507| 0| break; 1508| | 1509| 2.50k| case 16: /* repeat: single _RANGE_ '?' */ ------------------ | Branch (1509:3): [True: 2.50k, False: 6.03M] ------------------ 1510| 2.50k|#line 312 "re_grammar.y" 1511| 2.50k| { 1512| 2.50k| RE_AST* re_ast = yyget_extra(yyscanner); ------------------ | | 51| 2.50k|#define yyget_extra re_yyget_extra ------------------ 1513| 2.50k| re_ast->flags |= RE_FLAGS_UNGREEDY; ------------------ | | 102| 2.50k|#define RE_FLAGS_UNGREEDY 0x800 ------------------ 1514| | 1515| 2.50k| if ((yyvsp[-2].re_node)->type == RE_NODE_ANY) ------------------ | | 43| 2.50k|#define RE_NODE_ANY 3 ------------------ | Branch (1515:13): [True: 2.32k, False: 179] ------------------ 1516| 2.32k| { 1517| 2.32k| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE_ANY); ------------------ | | 61| 2.32k|#define RE_NODE_RANGE_ANY 21 ------------------ 1518| 2.32k| destroy_node_if(true, (yyvsp[-2].re_node)); ------------------ | | 103| 2.32k| if (x) \ | | ------------------ | | | Branch (103:9): [Folded - Ignored] | | ------------------ | | 104| 2.32k| { \ | | 105| 2.32k| yr_re_node_destroy(node); \ | | 106| 2.32k| } \ ------------------ 1519| 2.32k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 2.32k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 2.32k] | | ------------------ | | 97| 2.32k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1520| 2.32k| } 1521| 179| else 1522| 179| { 1523| 179| mark_as_not_fast_regexp(); ------------------ | | 93| 179| ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 51| 179|#define yyget_extra re_yyget_extra | | ------------------ | | ((RE_AST*) yyget_extra(yyscanner))->flags &= ~RE_FLAGS_FAST_REGEXP | | ------------------ | | | | 94| 179|#define RE_FLAGS_FAST_REGEXP 0x02 | | ------------------ ------------------ 1524| 179| (yyval.re_node) = yr_re_node_create(RE_NODE_RANGE); ------------------ | | 46| 179|#define RE_NODE_RANGE 6 ------------------ 1525| 179| destroy_node_if((yyval.re_node) == NULL, (yyvsp[-2].re_node)); ------------------ | | 103| 179| if (x) \ | | ------------------ | | | Branch (103:9): [True: 0, False: 179] | | ------------------ | | 104| 179| { \ | | 105| 0| yr_re_node_destroy(node); \ | | 106| 0| } \ ------------------ 1526| 179| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 179| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 179] | | ------------------ | | 97| 179| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1527| 179| yr_re_node_append_child((yyval.re_node), (yyvsp[-2].re_node)); 1528| 179| } 1529| | 1530| 2.50k| (yyval.re_node)->start = (yyvsp[-1].range) & 0xFFFF;; 1531| 2.50k| (yyval.re_node)->end = (yyvsp[-1].range) >> 16;; 1532| 2.50k| (yyval.re_node)->greedy = false; 1533| 2.50k| } 1534| 0|#line 1535 "re_grammar.c" 1535| 0| break; 1536| | 1537| 1.97M| case 17: /* repeat: single */ ------------------ | Branch (1537:3): [True: 1.97M, False: 4.06M] ------------------ 1538| 1.97M|#line 336 "re_grammar.y" 1539| 1.97M| { 1540| 1.97M| (yyval.re_node) = (yyvsp[0].re_node); 1541| 1.97M| } 1542| 1.97M|#line 1543 "re_grammar.c" 1543| 1.97M| break; 1544| | 1545| 129| case 18: /* repeat: _WORD_BOUNDARY_ */ ------------------ | Branch (1545:3): [True: 129, False: 6.03M] ------------------ 1546| 129|#line 340 "re_grammar.y" 1547| 129| { 1548| 129| (yyval.re_node) = yr_re_node_create(RE_NODE_WORD_BOUNDARY); ------------------ | | 59| 129|#define RE_NODE_WORD_BOUNDARY 19 ------------------ 1549| | 1550| 129| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 129| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 129] | | ------------------ | | 97| 129| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1551| 129| } 1552| 0|#line 1553 "re_grammar.c" 1553| 0| break; 1554| | 1555| 150| case 19: /* repeat: _NON_WORD_BOUNDARY_ */ ------------------ | Branch (1555:3): [True: 150, False: 6.03M] ------------------ 1556| 150|#line 346 "re_grammar.y" 1557| 150| { 1558| 150| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_WORD_BOUNDARY); ------------------ | | 60| 150|#define RE_NODE_NON_WORD_BOUNDARY 20 ------------------ 1559| | 1560| 150| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 150| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 150] | | ------------------ | | 97| 150| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1561| 150| } 1562| 0|#line 1563 "re_grammar.c" 1563| 0| break; 1564| | 1565| 236| case 20: /* repeat: '^' */ ------------------ | Branch (1565:3): [True: 236, False: 6.03M] ------------------ 1566| 236|#line 352 "re_grammar.y" 1567| 236| { 1568| 236| (yyval.re_node) = yr_re_node_create(RE_NODE_ANCHOR_START); ------------------ | | 57| 236|#define RE_NODE_ANCHOR_START 17 ------------------ 1569| | 1570| 236| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 236| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 236] | | ------------------ | | 97| 236| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1571| 236| } 1572| 0|#line 1573 "re_grammar.c" 1573| 0| break; 1574| | 1575| 1.16k| case 21: /* repeat: '$' */ ------------------ | Branch (1575:3): [True: 1.16k, False: 6.03M] ------------------ 1576| 1.16k|#line 358 "re_grammar.y" 1577| 1.16k| { 1578| 1.16k| (yyval.re_node) = yr_re_node_create(RE_NODE_ANCHOR_END); ------------------ | | 58| 1.16k|#define RE_NODE_ANCHOR_END 18 ------------------ 1579| | 1580| 1.16k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 1.16k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 1.16k] | | ------------------ | | 97| 1.16k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1581| 1.16k| } 1582| 0|#line 1583 "re_grammar.c" 1583| 0| break; 1584| | 1585| 48.3k| case 22: /* single: '(' alternative ')' */ ------------------ | Branch (1585:3): [True: 48.3k, False: 5.98M] ------------------ 1586| 48.3k|#line 367 "re_grammar.y" 1587| 48.3k| { 1588| 48.3k| (yyval.re_node) = (yyvsp[-1].re_node); 1589| 48.3k| } 1590| 48.3k|#line 1591 "re_grammar.c" 1591| 48.3k| break; 1592| | 1593| 9.96k| case 23: /* single: '.' */ ------------------ | Branch (1593:3): [True: 9.96k, False: 6.02M] ------------------ 1594| 9.96k|#line 371 "re_grammar.y" 1595| 9.96k| { 1596| 9.96k| (yyval.re_node) = yr_re_node_create(RE_NODE_ANY); ------------------ | | 43| 9.96k|#define RE_NODE_ANY 3 ------------------ 1597| | 1598| 9.96k| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 9.96k| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 9.96k] | | ------------------ | | 97| 9.96k| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1599| | 1600| 9.96k| (yyval.re_node)->value = 0x00; 1601| 9.96k| (yyval.re_node)->mask = 0x00; 1602| 9.96k| } 1603| 0|#line 1604 "re_grammar.c" 1604| 0| break; 1605| | 1606| 1.91M| case 24: /* single: _CHAR_ */ ------------------ | Branch (1606:3): [True: 1.91M, False: 4.12M] ------------------ 1607| 1.91M|#line 380 "re_grammar.y" 1608| 1.91M| { 1609| 1.91M| (yyval.re_node) = yr_re_node_create(RE_NODE_LITERAL); ------------------ | | 41| 1.91M|#define RE_NODE_LITERAL 1 ------------------ 1610| | 1611| 1.91M| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 1.91M| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 1.91M] | | ------------------ | | 97| 1.91M| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1612| | 1613| 1.91M| (yyval.re_node)->value = (yyvsp[0].integer); 1614| 1.91M| (yyval.re_node)->mask = 0xFF; 1615| 1.91M| } 1616| 0|#line 1617 "re_grammar.c" 1617| 0| break; 1618| | 1619| 173| case 25: /* single: _WORD_CHAR_ */ ------------------ | Branch (1619:3): [True: 173, False: 6.03M] ------------------ 1620| 173|#line 389 "re_grammar.y" 1621| 173| { 1622| 173| (yyval.re_node) = yr_re_node_create(RE_NODE_WORD_CHAR); ------------------ | | 50| 173|#define RE_NODE_WORD_CHAR 10 ------------------ 1623| | 1624| 173| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 173| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 173] | | ------------------ | | 97| 173| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1625| 173| } 1626| 0|#line 1627 "re_grammar.c" 1627| 0| break; 1628| | 1629| 140| case 26: /* single: _NON_WORD_CHAR_ */ ------------------ | Branch (1629:3): [True: 140, False: 6.03M] ------------------ 1630| 140|#line 395 "re_grammar.y" 1631| 140| { 1632| 140| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_WORD_CHAR); ------------------ | | 51| 140|#define RE_NODE_NON_WORD_CHAR 11 ------------------ 1633| | 1634| 140| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 140| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 140] | | ------------------ | | 97| 140| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1635| 140| } 1636| 0|#line 1637 "re_grammar.c" 1637| 0| break; 1638| | 1639| 144| case 27: /* single: _SPACE_ */ ------------------ | Branch (1639:3): [True: 144, False: 6.03M] ------------------ 1640| 144|#line 401 "re_grammar.y" 1641| 144| { 1642| 144| (yyval.re_node) = yr_re_node_create(RE_NODE_SPACE); ------------------ | | 52| 144|#define RE_NODE_SPACE 12 ------------------ 1643| | 1644| 144| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 144| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 144] | | ------------------ | | 97| 144| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1645| 144| } 1646| 0|#line 1647 "re_grammar.c" 1647| 0| break; 1648| | 1649| 146| case 28: /* single: _NON_SPACE_ */ ------------------ | Branch (1649:3): [True: 146, False: 6.03M] ------------------ 1650| 146|#line 407 "re_grammar.y" 1651| 146| { 1652| 146| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_SPACE); ------------------ | | 53| 146|#define RE_NODE_NON_SPACE 13 ------------------ 1653| | 1654| 146| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 146| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 146] | | ------------------ | | 97| 146| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1655| 146| } 1656| 0|#line 1657 "re_grammar.c" 1657| 0| break; 1658| | 1659| 159| case 29: /* single: _DIGIT_ */ ------------------ | Branch (1659:3): [True: 159, False: 6.03M] ------------------ 1660| 159|#line 413 "re_grammar.y" 1661| 159| { 1662| 159| (yyval.re_node) = yr_re_node_create(RE_NODE_DIGIT); ------------------ | | 54| 159|#define RE_NODE_DIGIT 14 ------------------ 1663| | 1664| 159| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 159| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 159] | | ------------------ | | 97| 159| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1665| 159| } 1666| 0|#line 1667 "re_grammar.c" 1667| 0| break; 1668| | 1669| 145| case 30: /* single: _NON_DIGIT_ */ ------------------ | Branch (1669:3): [True: 145, False: 6.03M] ------------------ 1670| 145|#line 419 "re_grammar.y" 1671| 145| { 1672| 145| (yyval.re_node) = yr_re_node_create(RE_NODE_NON_DIGIT); ------------------ | | 55| 145|#define RE_NODE_NON_DIGIT 15 ------------------ 1673| | 1674| 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| } \ ------------------ 1675| 145| } 1676| 0|#line 1677 "re_grammar.c" 1677| 0| break; 1678| | 1679| 588| case 31: /* single: _CLASS_ */ ------------------ | Branch (1679:3): [True: 588, False: 6.03M] ------------------ 1680| 588|#line 425 "re_grammar.y" 1681| 588| { 1682| 588| (yyval.re_node) = yr_re_node_create(RE_NODE_CLASS); ------------------ | | 49| 588|#define RE_NODE_CLASS 9 ------------------ 1683| | 1684| 588| fail_if((yyval.re_node) == NULL, ERROR_INSUFFICIENT_MEMORY); ------------------ | | 96| 588| if (x) \ | | ------------------ | | | Branch (96:9): [True: 0, False: 588] | | ------------------ | | 97| 588| { \ | | 98| 0| lex_env->last_error = error; \ | | 99| 0| YYABORT; \ | | ------------------ | | | | 765| 0|#define YYABORT goto yyabortlab | | ------------------ | | 100| 0| } \ ------------------ 1685| | 1686| 588| (yyval.re_node)->re_class = (yyvsp[0].re_class); 1687| 588| } 1688| 0|#line 1689 "re_grammar.c" 1689| 0| break; 1690| | 1691| | 1692| 0|#line 1693 "re_grammar.c" 1693| | 1694| 1.34k| default: break; ------------------ | Branch (1694:7): [True: 1.34k, False: 6.03M] ------------------ 1695| 6.03M| } 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| 6.03M| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 1708| | 1709| 6.03M| YYPOPSTACK (yylen); ------------------ | | 1054| 6.03M|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1710| 6.03M| yylen = 0; 1711| | 1712| 6.03M| *++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| 6.03M| { 1718| 6.03M| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 576| 6.03M|#define YYNTOKENS 24 ------------------ 1719| 6.03M| const int yyi = yypgoto[yylhs] + *yyssp; 1720| 6.03M| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 573| 12.0M|#define YYLAST 45 ------------------ | Branch (1720:16): [True: 5.99M, False: 41.9k] | Branch (1720:28): [True: 5.99M, False: 0] | Branch (1720:45): [True: 3.28M, False: 2.71M] ------------------ 1721| 6.03M| ? yytable[yyi] 1722| 6.03M| : yydefgoto[yylhs]); 1723| 6.03M| } 1724| | 1725| 6.03M| goto yynewstate; 1726| | 1727| | 1728| |/*--------------------------------------. 1729| || yyerrlab -- here on detecting error. | 1730| |`--------------------------------------*/ 1731| 1.34k|yyerrlab: 1732| | /* Make sure we have latest lookahead translation. See comments at 1733| | user semantic actions for why this is necessary. */ 1734| 1.34k| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 48| 1.34k|#define yychar re_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 73| 1.34k|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 591| 2.68k| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 585| 1.34k|#define YYMAXUTOK 269 | | ------------------ | | | Branch (591:4): [True: 1.34k, False: 0] | | | Branch (591:18): [True: 1.34k, False: 0] | | ------------------ | | 592| 2.68k| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 116| 1.34k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 593| 2.68k| : YYSYMBOL_YYUNDEF) ------------------ | Branch (1734:13): [True: 0, False: 1.34k] ------------------ 1735| | /* If not already recovering from an error, report this error. */ 1736| 1.34k| if (!yyerrstatus) ------------------ | Branch (1736:7): [True: 281, False: 1.06k] ------------------ 1737| 281| { 1738| 281| ++yynerrs; ------------------ | | 50| 281|#define yynerrs re_yynerrs ------------------ 1739| 281| yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 46| 281|#define yyerror re_yyerror ------------------ yyerror (yyscanner, lex_env, YY_("syntax error")); ------------------ | | 375| 281|# define YY_(Msgid) Msgid ------------------ 1740| 281| } 1741| | 1742| 1.34k| if (yyerrstatus == 3) ------------------ | Branch (1742:7): [True: 1.06k, False: 281] ------------------ 1743| 1.06k| { 1744| | /* If just tried and failed to reuse lookahead token after an 1745| | error, discard it. */ 1746| | 1747| 1.06k| if (yychar <= YYEOF) ------------------ | | 48| 1.06k|#define yychar re_yychar ------------------ if (yychar <= YYEOF) ------------------ | | 74| 1.06k|#define YYEOF 0 ------------------ | Branch (1747:11): [True: 0, False: 1.06k] ------------------ 1748| 0| { 1749| | /* Return failure if at end of input. */ 1750| 0| if (yychar == YYEOF) ------------------ | | 48| 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| 1.06k| else 1754| 1.06k| { 1755| 1.06k| yydestruct ("Error: discarding", 1756| 1.06k| yytoken, &yylval, yyscanner, lex_env); 1757| 1.06k| yychar = YYEMPTY; ------------------ | | 48| 1.06k|#define yychar re_yychar ------------------ yychar = YYEMPTY; ------------------ | | 73| 1.06k|#define YYEMPTY -2 ------------------ 1758| 1.06k| } 1759| 1.06k| } 1760| | 1761| | /* Else will try to reuse lookahead token after shifting the error 1762| | token. */ 1763| 1.34k| goto yyerrlab1; 1764| | 1765| | 1766| |/*---------------------------------------------------. 1767| || yyerrorlab -- error raised explicitly by YYERROR. | 1768| |`---------------------------------------------------*/ 1769| 1.34k|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; ------------------ | | 50| 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| 1.34k|yyerrlab1: 1789| 1.34k| yyerrstatus = 3; /* Each real token shifted decrements this. */ 1790| | 1791| | /* Pop stack until we find a state that shifts the error token. */ 1792| 1.34k| for (;;) 1793| 57.4k| { 1794| 57.4k| yyn = yypact[yystate]; 1795| 57.4k| if (!yypact_value_is_default (yyn)) ------------------ | | 669| 57.4k| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 666| 57.4k|#define YYPACT_NINF (-12) | | ------------------ ------------------ | Branch (1795:11): [True: 57.4k, False: 0] ------------------ 1796| 57.4k| { 1797| 57.4k| yyn += YYSYMBOL_YYerror; 1798| 57.4k| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 573| 114k|#define YYLAST 45 ------------------ | Branch (1798:15): [True: 57.4k, False: 10] | Branch (1798:27): [True: 57.4k, False: 0] | Branch (1798:44): [True: 1.34k, False: 56.1k] ------------------ 1799| 1.34k| { 1800| 1.34k| yyn = yytable[yyn]; 1801| 1.34k| if (0 < yyn) ------------------ | Branch (1801:19): [True: 1.34k, False: 0] ------------------ 1802| 1.34k| break; 1803| 1.34k| } 1804| 57.4k| } 1805| | 1806| | /* Pop the current state because it cannot handle the error token. */ 1807| 56.1k| if (yyssp == yyss) ------------------ | Branch (1807:11): [True: 0, False: 56.1k] ------------------ 1808| 0| YYABORT; ------------------ | | 765| 0|#define YYABORT goto yyabortlab ------------------ 1809| | 1810| | 1811| 56.1k| yydestruct ("Error: popping", 1812| 56.1k| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, lex_env); ------------------ | | 640| 56.1k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 116| 56.1k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1813| 56.1k| YYPOPSTACK (1); ------------------ | | 1054| 56.1k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1814| 56.1k| yystate = *yyssp; 1815| 56.1k| YY_STACK_PRINT (yyss, yyssp); 1816| 56.1k| } 1817| | 1818| 1.34k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1819| 1.34k| *++yyvsp = yylval; 1820| 1.34k| YY_IGNORE_MAYBE_UNINITIALIZED_END 1821| | 1822| | 1823| | /* Shift the error token. */ 1824| 1.34k| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 1825| | 1826| 1.34k| yystate = yyn; 1827| 1.34k| goto yynewstate; 1828| | 1829| | 1830| |/*-------------------------------------. 1831| || yyacceptlab -- YYACCEPT comes here. | 1832| |`-------------------------------------*/ 1833| 20.5k|yyacceptlab: 1834| 20.5k| yyresult = 0; 1835| 20.5k| 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")); ------------------ | | 46| 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| 20.5k|yyreturnlab: 1859| 20.5k| if (yychar != YYEMPTY) ------------------ | | 48| 20.5k|#define yychar re_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 73| 20.5k|#define YYEMPTY -2 ------------------ | Branch (1859:7): [True: 0, False: 20.5k] ------------------ 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| 20.5k| YYPOPSTACK (yylen); ------------------ | | 1054| 20.5k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1870| 20.5k| YY_STACK_PRINT (yyss, yyssp); 1871| 61.6k| while (yyssp != yyss) ------------------ | Branch (1871:10): [True: 41.0k, False: 20.5k] ------------------ 1872| 41.0k| { 1873| 41.0k| yydestruct ("Cleanup: popping", 1874| 41.0k| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, lex_env); ------------------ | | 640| 41.0k|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 116| 41.0k|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 1875| 41.0k| YYPOPSTACK (1); ------------------ | | 1054| 41.0k|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 1876| 41.0k| } 1877| 20.5k|#ifndef yyoverflow 1878| 20.5k| if (yyss != yyssa) ------------------ | Branch (1878:7): [True: 76, False: 20.4k] ------------------ 1879| 76| YYSTACK_FREE (yyss); ------------------ | | 483| 76|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 90| 76|#define YYFREE yr_free | | ------------------ ------------------ 1880| 20.5k|#endif 1881| | 1882| 20.5k| return yyresult; 1883| 1.34k|} re_grammar.c:yydestruct: 951| 98.3k|{ 952| 98.3k| YY_USE (yyvaluep); ------------------ | | 398| 98.3k|# define YY_USE(E) ((void) (E)) ------------------ 953| 98.3k| YY_USE (yyscanner); ------------------ | | 398| 98.3k|# define YY_USE(E) ((void) (E)) ------------------ 954| 98.3k| YY_USE (lex_env); ------------------ | | 398| 98.3k|# define YY_USE(E) ((void) (E)) ------------------ 955| 98.3k| if (!yymsg) ------------------ | Branch (955:7): [True: 0, False: 98.3k] ------------------ 956| 0| yymsg = "Deleting"; 957| 98.3k| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 958| | 959| 98.3k| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 960| 98.3k| switch (yykind) 961| 98.3k| { 962| 257| case YYSYMBOL__CLASS_: /* _CLASS_ */ ------------------ | Branch (962:5): [True: 257, False: 98.0k] ------------------ 963| 257|#line 98 "re_grammar.y" 964| 257| { yr_free(((*yyvaluep).re_class)); ((*yyvaluep).re_class) = NULL; } 965| 257|#line 966 "re_grammar.c" 966| 257| break; 967| | 968| 184| case YYSYMBOL_alternative: /* alternative */ ------------------ | Branch (968:5): [True: 184, False: 98.1k] ------------------ 969| 184|#line 99 "re_grammar.y" 970| 184| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 971| 184|#line 972 "re_grammar.c" 972| 184| break; 973| | 974| 1.56k| case YYSYMBOL_concatenation: /* concatenation */ ------------------ | Branch (974:5): [True: 1.56k, False: 96.7k] ------------------ 975| 1.56k|#line 100 "re_grammar.y" 976| 1.56k| { yr_re_node_destroy(((*yyvaluep).re_node)); ((*yyvaluep).re_node) = NULL; } 977| 1.56k|#line 978 "re_grammar.c" 978| 1.56k| break; 979| | 980| 0| case YYSYMBOL_repeat: /* repeat */ ------------------ | Branch (980:5): [True: 0, False: 98.3k] ------------------ 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: 98.3k] ------------------ 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| 96.2k| default: ------------------ | Branch (992:7): [True: 96.2k, False: 2.00k] ------------------ 993| 96.2k| break; 994| 98.3k| } 995| 98.3k| YY_IGNORE_MAYBE_UNINITIALIZED_END 996| 98.3k|} re_yylex: 1035| 2.12M|{ 1036| 2.12M| yy_state_type yy_current_state; 1037| 2.12M| char *yy_cp, *yy_bp; 1038| 2.12M| int yy_act; 1039| 2.12M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1040| | 1041| 2.12M| yylval = yylval_param; ------------------ | | 854| 2.12M| # define yylval yyg->yylval_r ------------------ 1042| | 1043| 2.12M| if ( !yyg->yy_init ) ------------------ | Branch (1043:7): [True: 20.5k, False: 2.10M] ------------------ 1044| 20.5k| { 1045| 20.5k| yyg->yy_init = 1; 1046| | 1047| |#ifdef YY_USER_INIT 1048| | YY_USER_INIT; 1049| |#endif 1050| | 1051| 20.5k| if ( ! yyg->yy_start ) ------------------ | Branch (1051:8): [True: 20.5k, False: 0] ------------------ 1052| 20.5k| yyg->yy_start = 1; /* first start state */ 1053| | 1054| 20.5k| if ( ! yyin ) ------------------ | | 344| 20.5k|#define yyin yyg->yyin_r ------------------ | Branch (1054:8): [True: 20.5k, False: 0] ------------------ 1055| 20.5k| yyin = stdin; ------------------ | | 344| 20.5k|#define yyin yyg->yyin_r ------------------ 1056| | 1057| 20.5k| if ( ! yyout ) ------------------ | | 345| 20.5k|#define yyout yyg->yyout_r ------------------ | Branch (1057:8): [True: 20.5k, False: 0] ------------------ 1058| 20.5k| yyout = stdout; ------------------ | | 345| 20.5k|#define yyout yyg->yyout_r ------------------ 1059| | 1060| 20.5k| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ | Branch (1060:8): [True: 0, False: 20.5k] ------------------ 1061| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 1062| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1063| 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 ------------------ 1064| 0| } 1065| | 1066| 20.5k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 20.5k|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 1067| 20.5k| } 1068| | 1069| 2.12M| { 1070| 2.12M|#line 111 "re_lexer.l" 1071| | 1072| | 1073| 2.12M|#line 1074 "re_lexer.c" 1074| | 1075| 2.13M| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1075:23): [Folded - Ignored] ------------------ 1076| 2.13M| { 1077| 2.13M| yy_cp = yyg->yy_c_buf_p; 1078| | 1079| | /* Support of yytext. */ 1080| 2.13M| *yy_cp = yyg->yy_hold_char; 1081| | 1082| | /* yy_bp points to the position in yy_ch_buf of the start of 1083| | * the current run. 1084| | */ 1085| 2.13M| yy_bp = yy_cp; 1086| | 1087| 2.13M| yy_current_state = yyg->yy_start; 1088| 2.13M|yy_match: 1089| 2.13M| do 1090| 4.31M| { 1091| 4.31M| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 4.31M|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1092| 4.31M| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1092:9): [True: 2.16M, False: 2.14M] ------------------ 1093| 2.16M| { 1094| 2.16M| yyg->yy_last_accepting_state = yy_current_state; 1095| 2.16M| yyg->yy_last_accepting_cpos = yy_cp; 1096| 2.16M| } 1097| 7.69M| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1097:12): [True: 3.37M, False: 4.31M] ------------------ 1098| 3.37M| { 1099| 3.37M| yy_current_state = (int) yy_def[yy_current_state]; 1100| 3.37M| if ( yy_current_state >= 45 ) ------------------ | Branch (1100:10): [True: 1.24M, False: 2.13M] ------------------ 1101| 1.24M| yy_c = yy_meta[yy_c]; 1102| 3.37M| } 1103| 4.31M| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1104| 4.31M| ++yy_cp; 1105| 4.31M| } 1106| 4.31M| while ( yy_current_state != 44 ); ------------------ | Branch (1106:11): [True: 2.18M, False: 2.13M] ------------------ 1107| 2.13M| yy_cp = yyg->yy_last_accepting_cpos; 1108| 2.13M| yy_current_state = yyg->yy_last_accepting_state; 1109| | 1110| 2.15M|yy_find_action: 1111| 2.15M| yy_act = yy_accept[yy_current_state]; 1112| | 1113| 2.15M| YY_DO_BEFORE_ACTION; ------------------ | | 578| 2.15M| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 2.15M|#define yytext_ptr yytext_r | | ------------------ | | 579| 2.15M| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 2.15M|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 2.15M| yyg->yy_hold_char = *yy_cp; \ | | 581| 2.15M| *yy_cp = '\0'; \ | | 582| 2.15M| yyg->yy_c_buf_p = yy_cp; ------------------ 1114| | 1115| 2.15M| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 4.31M|#define YY_END_OF_BUFFER 30 ------------------ | Branch (1115:8): [True: 2.11M, False: 42.3k] | Branch (1115:38): [True: 1.22M, False: 893k] ------------------ 1116| 1.22M| { 1117| 1.22M| int yyl; 1118| 2.44M| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 2.44M|#define yyleng yyg->yyleng_r ------------------ | Branch (1118:19): [True: 1.22M, False: 1.22M] ------------------ 1119| 1.22M| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 1.22M|#define yytext yyg->yytext_r ------------------ | Branch (1119:10): [True: 0, False: 1.22M] ------------------ 1120| | 1121| 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] | | ------------------ ------------------ 1122| 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] | | ------------------ ------------------ 1123| 0| }while(0) ------------------ | Branch (1123:12): [Folded - Ignored] ------------------ 1124| 1.22M|; 1125| 1.22M| } 1126| | 1127| 2.17M|do_action: /* This label is used only to access EOF actions. */ 1128| | 1129| 2.17M| switch ( yy_act ) 1130| 2.17M| { /* beginning of action switch */ 1131| 1.64k| case 0: /* must back up */ ------------------ | Branch (1131:4): [True: 1.64k, False: 2.17M] ------------------ 1132| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1133| 1.64k| *yy_cp = yyg->yy_hold_char; 1134| 1.64k| yy_cp = yyg->yy_last_accepting_cpos; 1135| 1.64k| yy_current_state = yyg->yy_last_accepting_state; 1136| 1.64k| goto yy_find_action; 1137| | 1138| 2.98k|case 1: ------------------ | Branch (1138:1): [True: 2.98k, False: 2.17M] ------------------ 1139| 2.98k|YY_RULE_SETUP 1140| 2.98k|#line 113 "re_lexer.l" 1141| 2.98k|{ 1142| | 1143| | // Examples: {3,8} {0,5} {,5} {7,} 1144| | 1145| 2.98k| int hi_bound; 1146| 2.98k| int lo_bound = atoi(yytext + 1); ------------------ | | 348| 2.98k|#define yytext yyg->yytext_r ------------------ 1147| | 1148| 2.98k| char* comma = strchr(yytext, ','); ------------------ | | 348| 2.98k|#define yytext yyg->yytext_r ------------------ 1149| | 1150| 2.98k| if (comma - yytext == strlen(yytext) - 2) ------------------ | | 348| 2.98k|#define yytext yyg->yytext_r ------------------ if (comma - yytext == strlen(yytext) - 2) ------------------ | | 348| 2.98k|#define yytext yyg->yytext_r ------------------ | Branch (1150:7): [True: 2.72k, False: 262] ------------------ 1151| | // if comma is followed by the closing curly bracket 1152| | // (example: {2,}) set high bound value to maximum. 1153| 2.72k| hi_bound = RE_MAX_RANGE; ------------------ | | 39| 2.72k|#define RE_MAX_RANGE INT16_MAX ------------------ 1154| 262| else 1155| 262| hi_bound = atoi(comma + 1); 1156| | 1157| 2.98k| if (hi_bound > RE_MAX_RANGE) ------------------ | | 39| 2.98k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (1157:7): [True: 0, False: 2.98k] ------------------ 1158| 0| { 1159| 0| yyerror(yyscanner, lex_env, "repeat interval too large"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1160| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1161| 0| } 1162| | 1163| 2.98k| if (hi_bound < lo_bound || hi_bound < 0 || lo_bound < 0) ------------------ | Branch (1163:7): [True: 4, False: 2.98k] | Branch (1163:30): [True: 0, False: 2.98k] | Branch (1163:46): [True: 0, False: 2.98k] ------------------ 1164| 4| { 1165| 4| yyerror(yyscanner, lex_env, "bad repeat interval"); ------------------ | | 46| 4|#define yyerror re_yyerror ------------------ 1166| 4| yyterminate(); ------------------ | | 989| 4|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 4|#define YY_NULL 0 | | ------------------ ------------------ 1167| 4| } 1168| | 1169| 2.98k| if (hi_bound == 0 && lo_bound == 0) ------------------ | Branch (1169:7): [True: 0, False: 2.98k] | Branch (1169:24): [True: 0, False: 0] ------------------ 1170| 0| { 1171| 0| yyerror(yyscanner, lex_env, "bad repeat interval"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1172| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1173| 0| } 1174| | 1175| 2.98k| yylval->range = (hi_bound << 16) | lo_bound; ------------------ | | 854| 2.98k| # define yylval yyg->yylval_r ------------------ 1176| | 1177| 2.98k| return _RANGE_; ------------------ | | 79| 2.98k|#define _RANGE_ 260 ------------------ 1178| 2.98k|} 1179| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1180| 1.00k|case 2: ------------------ | Branch (1180:1): [True: 1.00k, False: 2.17M] ------------------ 1181| 1.00k|YY_RULE_SETUP 1182| 1.00k|#line 153 "re_lexer.l" 1183| 1.00k|{ 1184| | 1185| | // Example: {10} 1186| | 1187| 1.00k| int value = atoi(yytext + 1); ------------------ | | 348| 1.00k|#define yytext yyg->yytext_r ------------------ 1188| | 1189| | // atoi can return a negative value if the input string represents a number 1190| | // too large to fit in an integer. 1191| | 1192| 1.00k| if (value > RE_MAX_RANGE || value < 0) ------------------ | | 39| 2.00k|#define RE_MAX_RANGE INT16_MAX ------------------ | Branch (1192:7): [True: 0, False: 1.00k] | Branch (1192:31): [True: 1, False: 1.00k] ------------------ 1193| 1| { 1194| 1| yyerror(yyscanner, lex_env, "repeat interval too large"); ------------------ | | 46| 1|#define yyerror re_yyerror ------------------ 1195| 1| yyterminate(); ------------------ | | 989| 1|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1|#define YY_NULL 0 | | ------------------ ------------------ 1196| 1| } 1197| | 1198| 1.00k| if (value == 0) ------------------ | Branch (1198:7): [True: 0, False: 1.00k] ------------------ 1199| 0| { 1200| 0| yyerror(yyscanner, lex_env, "bad repeat interval"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1201| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1202| 0| } 1203| | 1204| 1.00k| yylval->range = (value << 16) | value; ------------------ | | 854| 1.00k| # define yylval yyg->yylval_r ------------------ 1205| | 1206| 1.00k| return _RANGE_; ------------------ | | 79| 1.00k|#define _RANGE_ 260 ------------------ 1207| 1.00k|} 1208| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1209| 128|case 3: ------------------ | Branch (1209:1): [True: 128, False: 2.17M] ------------------ 1210| 128|YY_RULE_SETUP 1211| 128|#line 180 "re_lexer.l" 1212| 128|{ 1213| | 1214| | // Start of a negated character class. Example: [^abcd] 1215| | 1216| 128| BEGIN(char_class); ------------------ | | 357| 128|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 800| 128|#define char_class 1 ------------------ 1217| 128| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 70| 128|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1218| 128| LEX_ENV->re_class.negated = true; ------------------ | | 70| 128|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1219| 128|} 1220| 128| YY_BREAK ------------------ | | 1026| 128|#define YY_BREAK /*LINTED*/break; ------------------ 1221| 128|case 4: ------------------ | Branch (1221:1): [True: 128, False: 2.17M] ------------------ 1222| 128|YY_RULE_SETUP 1223| 128|#line 189 "re_lexer.l" 1224| 128|{ 1225| | 1226| | // Start of character negated class containing a ]. 1227| | // Example: [^]abc] this must be interpreted as a class 1228| | // not matching ], a, b, nor c 1229| | 1230| 128| BEGIN(char_class); ------------------ | | 357| 128|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 800| 128|#define char_class 1 ------------------ 1231| 128| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 70| 128|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1232| 128| LEX_ENV->re_class.negated = true; ------------------ | | 70| 128|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1233| 128| LEX_ENV->re_class.bitmap[']' / 8] |= 1 << ']' % 8; ------------------ | | 70| 128|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1234| 128|} 1235| 128| YY_BREAK ------------------ | | 1026| 128|#define YY_BREAK /*LINTED*/break; ------------------ 1236| 256|case 5: ------------------ | Branch (1236:1): [True: 256, False: 2.17M] ------------------ 1237| 256|YY_RULE_SETUP 1238| 256|#line 202 "re_lexer.l" 1239| 256|{ 1240| | 1241| | // Start of character class containing a ]. 1242| | // Example: []abc] this must be interpreted as a class 1243| | // matching ], a, b, or c. 1244| | 1245| 256| BEGIN(char_class); ------------------ | | 357| 256|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 800| 256|#define char_class 1 ------------------ 1246| 256| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 70| 256|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1247| 256| LEX_ENV->re_class.negated = false; ------------------ | | 70| 256|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1248| 256| LEX_ENV->re_class.bitmap[']' / 8] |= 1 << ']' % 8; ------------------ | | 70| 256|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1249| 256|} 1250| 256| YY_BREAK ------------------ | | 1026| 256|#define YY_BREAK /*LINTED*/break; ------------------ 1251| 542|case 6: ------------------ | Branch (1251:1): [True: 542, False: 2.17M] ------------------ 1252| 542|YY_RULE_SETUP 1253| 542|#line 215 "re_lexer.l" 1254| 542|{ 1255| | 1256| | // Start of character class. Example: [abcd] 1257| | 1258| 542| BEGIN(char_class); ------------------ | | 357| 542|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(char_class); ------------------ | | 800| 542|#define char_class 1 ------------------ 1259| 542| memset(LEX_ENV->re_class.bitmap, 0, 32); ------------------ | | 70| 542|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1260| 542| LEX_ENV->re_class.negated = false; ------------------ | | 70| 542|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1261| 542|} 1262| 542| YY_BREAK ------------------ | | 1026| 542|#define YY_BREAK /*LINTED*/break; ------------------ 1263| 1.22M|case 7: ------------------ | Branch (1263:1): [True: 1.22M, False: 956k] ------------------ 1264| |/* rule 7 can match eol */ 1265| 1.22M|YY_RULE_SETUP 1266| 1.22M|#line 225 "re_lexer.l" 1267| 1.22M|{ 1268| | 1269| | // Any non-special character is passed as a CHAR token to the scanner. 1270| | 1271| 1.22M| yylval->integer = yytext[0]; ------------------ | | 854| 1.22M| # define yylval yyg->yylval_r ------------------ yylval->integer = yytext[0]; ------------------ | | 348| 1.22M|#define yytext yyg->yytext_r ------------------ 1272| 1.22M| return _CHAR_; ------------------ | | 77| 1.22M|#define _CHAR_ 258 ------------------ 1273| 1.00k|} 1274| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1275| 173|case 8: ------------------ | Branch (1275:1): [True: 173, False: 2.17M] ------------------ 1276| 173|YY_RULE_SETUP 1277| 173|#line 234 "re_lexer.l" 1278| 173|{ 1279| 173| return _WORD_CHAR_; ------------------ | | 81| 173|#define _WORD_CHAR_ 262 ------------------ 1280| 1.00k|} 1281| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1282| 140|case 9: ------------------ | Branch (1282:1): [True: 140, False: 2.17M] ------------------ 1283| 140|YY_RULE_SETUP 1284| 140|#line 239 "re_lexer.l" 1285| 140|{ 1286| 140| return _NON_WORD_CHAR_; ------------------ | | 82| 140|#define _NON_WORD_CHAR_ 263 ------------------ 1287| 1.00k|} 1288| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1289| 144|case 10: ------------------ | Branch (1289:1): [True: 144, False: 2.17M] ------------------ 1290| 144|YY_RULE_SETUP 1291| 144|#line 244 "re_lexer.l" 1292| 144|{ 1293| 144| return _SPACE_; ------------------ | | 83| 144|#define _SPACE_ 264 ------------------ 1294| 1.00k|} 1295| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1296| 146|case 11: ------------------ | Branch (1296:1): [True: 146, False: 2.17M] ------------------ 1297| 146|YY_RULE_SETUP 1298| 146|#line 249 "re_lexer.l" 1299| 146|{ 1300| 146| return _NON_SPACE_; ------------------ | | 84| 146|#define _NON_SPACE_ 265 ------------------ 1301| 1.00k|} 1302| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1303| 159|case 12: ------------------ | Branch (1303:1): [True: 159, False: 2.17M] ------------------ 1304| 159|YY_RULE_SETUP 1305| 159|#line 254 "re_lexer.l" 1306| 159|{ 1307| 159| return _DIGIT_; ------------------ | | 85| 159|#define _DIGIT_ 266 ------------------ 1308| 1.00k|} 1309| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1310| 145|case 13: ------------------ | Branch (1310:1): [True: 145, False: 2.17M] ------------------ 1311| 145|YY_RULE_SETUP 1312| 145|#line 259 "re_lexer.l" 1313| 145|{ 1314| 145| return _NON_DIGIT_; ------------------ | | 86| 145|#define _NON_DIGIT_ 267 ------------------ 1315| 1.00k|} 1316| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1317| 129|case 14: ------------------ | Branch (1317:1): [True: 129, False: 2.17M] ------------------ 1318| 129|YY_RULE_SETUP 1319| 129|#line 264 "re_lexer.l" 1320| 129|{ 1321| 129| return _WORD_BOUNDARY_; ------------------ | | 87| 129|#define _WORD_BOUNDARY_ 268 ------------------ 1322| 1.00k|} 1323| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1324| 150|case 15: ------------------ | Branch (1324:1): [True: 150, False: 2.17M] ------------------ 1325| 150|YY_RULE_SETUP 1326| 150|#line 268 "re_lexer.l" 1327| 150|{ 1328| 150| return _NON_WORD_BOUNDARY_; ------------------ | | 88| 150|#define _NON_WORD_BOUNDARY_ 269 ------------------ 1329| 1.00k|} 1330| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1331| 0|case 16: ------------------ | Branch (1331:1): [True: 0, False: 2.17M] ------------------ 1332| 0|YY_RULE_SETUP 1333| 0|#line 273 "re_lexer.l" 1334| 0|{ 1335| | 1336| 0| yyerror(yyscanner, lex_env, "backreferences are not allowed"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1337| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1338| 1.00k|} 1339| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1340| 695k|case 17: ------------------ | Branch (1340:1): [True: 695k, False: 1.48M] ------------------ 1341| 695k|YY_RULE_SETUP 1342| 695k|#line 280 "re_lexer.l" 1343| 695k|{ 1344| | 1345| 695k| uint8_t c; 1346| | 1347| 695k| if (read_escaped_char(yyscanner, &c)) ------------------ | Branch (1347:7): [True: 695k, False: 9] ------------------ 1348| 695k| { 1349| 695k| yylval->integer = c; ------------------ | | 854| 695k| # define yylval yyg->yylval_r ------------------ 1350| 695k| return _CHAR_; ------------------ | | 77| 695k|#define _CHAR_ 258 ------------------ 1351| 695k| } 1352| 9| else 1353| 9| { 1354| 9| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 46| 9|#define yyerror re_yyerror ------------------ 1355| 9| yyterminate(); ------------------ | | 989| 9|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 9|#define YY_NULL 0 | | ------------------ ------------------ 1356| 9| } 1357| 695k|} 1358| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1359| 845|case 18: ------------------ | Branch (1359:1): [True: 845, False: 2.17M] ------------------ 1360| 845|YY_RULE_SETUP 1361| 845|#line 297 "re_lexer.l" 1362| 845|{ 1363| | 1364| | // End of character class. 1365| 845| yylval->re_class = (RE_CLASS*) yr_malloc(sizeof(RE_CLASS)); ------------------ | | 854| 845| # define yylval yyg->yylval_r ------------------ 1366| 845| memcpy(yylval->re_class->bitmap, LEX_ENV->re_class.bitmap, 32); ------------------ | | 854| 845| # define yylval yyg->yylval_r ------------------ memcpy(yylval->re_class->bitmap, LEX_ENV->re_class.bitmap, 32); ------------------ | | 70| 845|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1367| | 1368| 845| yylval->re_class->negated = LEX_ENV->re_class.negated; ------------------ | | 854| 845| # define yylval yyg->yylval_r ------------------ yylval->re_class->negated = LEX_ENV->re_class.negated; ------------------ | | 70| 845|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1369| | 1370| 845| BEGIN(INITIAL); ------------------ | | 357| 845|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 799| 845|#define INITIAL 0 ------------------ 1371| 845| return _CLASS_; ------------------ | | 80| 845|#define _CLASS_ 261 ------------------ 1372| 695k|} 1373| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1374| 850|case 19: ------------------ | Branch (1374:1): [True: 850, False: 2.17M] ------------------ 1375| |/* rule 19 can match eol */ 1376| 850|YY_RULE_SETUP 1377| 850|#line 311 "re_lexer.l" 1378| 850|{ 1379| | 1380| | // A range inside a character class. The regexp is... 1381| | // 1382| | // ( \x{hex_digit}{2} Hex digit (i.e: \x01) ... 1383| | // | \. ...or any escaped character (i.e. \\, \-) ... 1384| | // | [^]\] ...or any character except ] and \ ... 1385| | // ) 1386| | // - ... followed by - 1387| | // [^]] ... followed by any character except ] 1388| | // 1389| | // Some examples: 1390| | // 1391| | // [abc0-9] 1392| | // ^-^ matching range 0-9 1393| | // 1394| | // [a-za-] 1395| | // ^-^- matching range a-z 1396| | // 1397| | // [\.-a] 1398| | // ^--^- matching range \.-a 1399| | // 1400| | 1401| 850| uint16_t c; 1402| 850| uint8_t start = yytext[0]; ------------------ | | 348| 850|#define yytext yyg->yytext_r ------------------ 1403| 850| uint8_t end = yytext[2]; ------------------ | | 348| 850|#define yytext yyg->yytext_r ------------------ 1404| | 1405| 850| if (start == '\\') ------------------ | Branch (1405:7): [True: 422, False: 428] ------------------ 1406| 422| { 1407| 422| if (!escaped_char_value(yytext, &start)) ------------------ | | 348| 422|#define yytext yyg->yytext_r ------------------ | Branch (1407:9): [True: 0, False: 422] ------------------ 1408| 0| { 1409| 0| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1410| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1411| 0| } 1412| | 1413| 422| if (yytext[1] == 'x') ------------------ | | 348| 422|#define yytext yyg->yytext_r ------------------ | Branch (1413:9): [True: 179, False: 243] ------------------ 1414| 179| end = yytext[5]; ------------------ | | 348| 179|#define yytext yyg->yytext_r ------------------ 1415| 243| else 1416| 243| end = yytext[3]; ------------------ | | 348| 243|#define yytext yyg->yytext_r ------------------ 1417| 422| } 1418| | 1419| 850| if (end == '\\') ------------------ | Branch (1419:7): [True: 300, False: 550] ------------------ 1420| 300| { 1421| 300| if (!read_escaped_char(yyscanner, &end)) ------------------ | Branch (1421:9): [True: 27, False: 273] ------------------ 1422| 27| { 1423| 27| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 46| 27|#define yyerror re_yyerror ------------------ 1424| 27| yyterminate(); ------------------ | | 989| 27|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 27|#define YY_NULL 0 | | ------------------ ------------------ 1425| 27| } 1426| 300| } 1427| | 1428| 823| if (end < start) ------------------ | Branch (1428:7): [True: 94, False: 729] ------------------ 1429| 94| { 1430| 94| yyerror(yyscanner, lex_env, "bad character range"); ------------------ | | 46| 94|#define yyerror re_yyerror ------------------ 1431| 94| yyterminate(); ------------------ | | 989| 94|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 94|#define YY_NULL 0 | | ------------------ ------------------ 1432| 94| } 1433| | 1434| 47.0k| for (c = start; c <= end; c++) ------------------ | Branch (1434:19): [True: 46.2k, False: 729] ------------------ 1435| 46.2k| { 1436| 46.2k| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 70| 46.2k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1437| 46.2k| } 1438| 729|} 1439| 729| YY_BREAK ------------------ | | 1026| 729|#define YY_BREAK /*LINTED*/break; ------------------ 1440| 699|case 20: ------------------ | Branch (1440:1): [True: 699, False: 2.17M] ------------------ 1441| 699|YY_RULE_SETUP 1442| 699|#line 374 "re_lexer.l" 1443| 699|{ 1444| | 1445| 23.0k| for (int i = 0; i < 32; i++) ------------------ | Branch (1445:19): [True: 22.3k, False: 699] ------------------ 1446| 22.3k| LEX_ENV->re_class.bitmap[i] |= word_chars[i]; ------------------ | | 70| 22.3k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1447| 699|} 1448| 699| YY_BREAK ------------------ | | 1026| 699|#define YY_BREAK /*LINTED*/break; ------------------ 1449| 712|case 21: ------------------ | Branch (1449:1): [True: 712, False: 2.17M] ------------------ 1450| 712|YY_RULE_SETUP 1451| 712|#line 381 "re_lexer.l" 1452| 712|{ 1453| | 1454| 23.4k| for (int i = 0; i < 32; i++) ------------------ | Branch (1454:19): [True: 22.7k, False: 712] ------------------ 1455| 22.7k| LEX_ENV->re_class.bitmap[i] |= ~word_chars[i]; ------------------ | | 70| 22.7k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1456| 712|} 1457| 712| YY_BREAK ------------------ | | 1026| 712|#define YY_BREAK /*LINTED*/break; ------------------ 1458| 722|case 22: ------------------ | Branch (1458:1): [True: 722, False: 2.17M] ------------------ 1459| 722|YY_RULE_SETUP 1460| 722|#line 388 "re_lexer.l" 1461| 722|{ 1462| | 1463| 23.8k| for (int i = 0; i < 32; i++) ------------------ | Branch (1463:19): [True: 23.1k, False: 722] ------------------ 1464| 23.1k| LEX_ENV->re_class.bitmap[i] |= space_chars[i]; ------------------ | | 70| 23.1k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1465| 722|} 1466| 722| YY_BREAK ------------------ | | 1026| 722|#define YY_BREAK /*LINTED*/break; ------------------ 1467| 703|case 23: ------------------ | Branch (1467:1): [True: 703, False: 2.17M] ------------------ 1468| 703|YY_RULE_SETUP 1469| 703|#line 395 "re_lexer.l" 1470| 703|{ 1471| | 1472| 23.1k| for (int i = 0; i < 32; i++) ------------------ | Branch (1472:19): [True: 22.4k, False: 703] ------------------ 1473| 22.4k| LEX_ENV->re_class.bitmap[i] |= ~space_chars[i]; ------------------ | | 70| 22.4k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1474| 703|} 1475| 703| YY_BREAK ------------------ | | 1026| 703|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 299|case 24: ------------------ | Branch (1476:1): [True: 299, False: 2.17M] ------------------ 1477| 299|YY_RULE_SETUP 1478| 299|#line 402 "re_lexer.l" 1479| 299|{ 1480| | 1481| 3.28k| for (char c = '0'; c <= '9'; c++) ------------------ | Branch (1481:22): [True: 2.99k, False: 299] ------------------ 1482| 2.99k| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 70| 2.99k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1483| 299|} 1484| 299| YY_BREAK ------------------ | | 1026| 299|#define YY_BREAK /*LINTED*/break; ------------------ 1485| 726|case 25: ------------------ | Branch (1485:1): [True: 726, False: 2.17M] ------------------ 1486| 726|YY_RULE_SETUP 1487| 726|#line 409 "re_lexer.l" 1488| 726|{ 1489| | 1490| 23.9k| for (int i = 0; i < 32; i++) ------------------ | Branch (1490:19): [True: 23.2k, False: 726] ------------------ 1491| 23.2k| { 1492| | // digits 0-7 are in the sixth byte of the vector, let that byte alone 1493| 23.2k| if (i == 6) ------------------ | Branch (1493:9): [True: 726, False: 22.5k] ------------------ 1494| 726| continue; 1495| | 1496| | // digits 8 and 9 are the lowest two bits in the seventh byte of the 1497| | // vector, let those bits alone. 1498| 22.5k| if (i == 7) ------------------ | Branch (1498:9): [True: 726, False: 21.7k] ------------------ 1499| 726| LEX_ENV->re_class.bitmap[i] |= 0xFC; ------------------ | | 70| 726|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1500| 21.7k| else 1501| 21.7k| LEX_ENV->re_class.bitmap[i] = 0xFF; ------------------ | | 70| 21.7k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1502| 22.5k| } 1503| 726|} 1504| 726| YY_BREAK ------------------ | | 1026| 726|#define YY_BREAK /*LINTED*/break; ------------------ 1505| 525|case 26: ------------------ | Branch (1505:1): [True: 525, False: 2.17M] ------------------ 1506| 525|YY_RULE_SETUP 1507| 525|#line 427 "re_lexer.l" 1508| 525|{ 1509| | 1510| 525| uint8_t c; 1511| | 1512| 525| if (read_escaped_char(yyscanner, &c)) ------------------ | Branch (1512:7): [True: 498, False: 27] ------------------ 1513| 498| { 1514| 498| LEX_ENV->re_class.bitmap[c / 8] |= 1 << c % 8; ------------------ | | 70| 498|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ 1515| 498| } 1516| 27| else 1517| 27| { 1518| 27| yyerror(yyscanner, lex_env, "illegal escape sequence"); ------------------ | | 46| 27|#define yyerror re_yyerror ------------------ 1519| 27| yyterminate(); ------------------ | | 989| 27|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 27|#define YY_NULL 0 | | ------------------ ------------------ 1520| 27| } 1521| 525|} 1522| 498| YY_BREAK ------------------ | | 1026| 498|#define YY_BREAK /*LINTED*/break; ------------------ 1523| 3.48k|case 27: ------------------ | Branch (1523:1): [True: 3.48k, False: 2.17M] ------------------ 1524| 3.48k|YY_RULE_SETUP 1525| 3.48k|#line 443 "re_lexer.l" 1526| 3.48k|{ 1527| | 1528| 3.48k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 3.48k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 3.46k|#define yytext yyg->yytext_r ------------------ | Branch (1528:7): [True: 3.46k, False: 22] | Branch (1528:26): [True: 3.46k, False: 0] ------------------ 1529| 3.46k| { 1530| | // A character class (i.e: [0-9a-f]) is represented by a 256-bits vector, 1531| | // here we set to 1 the vector's bit corresponding to the input character. 1532| | 1533| 3.46k| LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 70| 3.46k|#define LEX_ENV ((RE_LEX_ENVIRONMENT*) lex_env) ------------------ LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 348| 3.46k|#define yytext yyg->yytext_r ------------------ LEX_ENV->re_class.bitmap[yytext[0] / 8] |= 1 << yytext[0] % 8; ------------------ | | 348| 3.46k|#define yytext yyg->yytext_r ------------------ 1534| 3.46k| } 1535| 22| else 1536| 22| { 1537| 22| yyerror(yyscanner, lex_env, "non-ascii character"); ------------------ | | 46| 22|#define yyerror re_yyerror ------------------ 1538| 22| yyterminate(); ------------------ | | 989| 22|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 22|#define YY_NULL 0 | | ------------------ ------------------ 1539| 22| } 1540| 3.48k|} 1541| 3.46k| YY_BREAK ------------------ | | 1026| 3.46k|#define YY_BREAK /*LINTED*/break; ------------------ 1542| 3.46k|case YY_STATE_EOF(char_class): ------------------ | | 365| 39|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 39|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ | Branch (1542:1): [True: 39, False: 2.17M] ------------------ 1543| 39|#line 460 "re_lexer.l" 1544| 39|{ 1545| | 1546| | // End of regexp reached while scanning a character class. 1547| | 1548| 39| yyerror(yyscanner, lex_env, "missing terminating ] for character class"); ------------------ | | 46| 39|#define yyerror re_yyerror ------------------ 1549| 39| yyterminate(); ------------------ | | 989| 39|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 39|#define YY_NULL 0 | | ------------------ ------------------ 1550| 3.48k|} 1551| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1552| 180k|case 28: ------------------ | Branch (1552:1): [True: 180k, False: 1.99M] ------------------ 1553| 180k|YY_RULE_SETUP 1554| 180k|#line 469 "re_lexer.l" 1555| 180k|{ 1556| | 1557| 180k| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 180k|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 180k|#define yytext yyg->yytext_r ------------------ | Branch (1557:7): [True: 180k, False: 0] | Branch (1557:26): [True: 180k, False: 0] ------------------ 1558| 180k| { 1559| 180k| return yytext[0]; ------------------ | | 348| 180k|#define yytext yyg->yytext_r ------------------ 1560| 180k| } 1561| 0| else 1562| 0| { 1563| 0| yyerror(yyscanner, lex_env, "non-ascii character"); ------------------ | | 46| 0|#define yyerror re_yyerror ------------------ 1564| 0| yyterminate(); ------------------ | | 989| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1565| 0| } 1566| 180k|} 1567| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1568| 20.3k|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 20.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 20.3k|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ | Branch (1568:1): [True: 20.3k, False: 2.15M] ------------------ 1569| 20.3k|#line 483 "re_lexer.l" 1570| 20.3k|{ 1571| | 1572| 20.3k| yyterminate(); ------------------ | | 989| 20.3k|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 20.3k|#define YY_NULL 0 | | ------------------ ------------------ 1573| 180k|} 1574| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1575| 0|case 29: ------------------ | Branch (1575:1): [True: 0, False: 2.17M] ------------------ 1576| 0|YY_RULE_SETUP 1577| 0|#line 488 "re_lexer.l" 1578| 0|ECHO; ------------------ | | 945| 0|#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 348| 0|#define yytext yyg->yytext_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 347| 0|#define yyleng yyg->yyleng_r | | ------------------ | | #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) | | ------------------ | | | | 345| 0|#define yyout yyg->yyout_r | | ------------------ | | | Branch (945:23): [True: 0, False: 0] | | | Branch (945:80): [Folded - Ignored] | | ------------------ ------------------ 1579| 0| YY_BREAK ------------------ | | 1026| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1580| 0|#line 1581 "re_lexer.c" 1581| | 1582| 42.3k| case YY_END_OF_BUFFER: ------------------ | | 584| 42.3k|#define YY_END_OF_BUFFER 30 ------------------ | Branch (1582:2): [True: 42.3k, False: 2.13M] ------------------ 1583| 42.3k| { 1584| | /* Amount of text matched not including the EOB char. */ 1585| 42.3k| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 42.3k|#define yytext_ptr yytext_r ------------------ 1586| | 1587| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1588| 42.3k| *yy_cp = yyg->yy_hold_char; 1589| 42.3k| YY_RESTORE_YY_MORE_OFFSET 1590| | 1591| 42.3k| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 42.3k|#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| 42.3k|#define YY_BUFFER_NEW 0 ------------------ | Branch (1591:8): [True: 20.3k, False: 21.9k] ------------------ 1592| 20.3k| { 1593| | /* We're scanning a new file or input source. It's 1594| | * possible that this happened because the user 1595| | * just pointed yyin at a new source and called 1596| | * yylex(). If so, then we have to assure 1597| | * consistency between YY_CURRENT_BUFFER and our 1598| | * globals. Here is the right place to do so, because 1599| | * this is the first action (other than possibly a 1600| | * back-up) that will match for the new input source. 1601| | */ 1602| 20.3k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 20.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1603| 20.3k| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 20.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 20.3k|#define yyin yyg->yyin_r ------------------ 1604| 20.3k| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 20.3k|#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| 20.3k|#define YY_BUFFER_NORMAL 1 ------------------ 1605| 20.3k| } 1606| | 1607| | /* Note that here we test for yy_c_buf_p "<=" to the position 1608| | * of the first EOB in the buffer, since yy_c_buf_p will 1609| | * already have been incremented past the NUL character 1610| | * (since all states make transitions on EOB to the 1611| | * end-of-buffer state). Contrast this with the test 1612| | * in input(). 1613| | */ 1614| 42.3k| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 42.3k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1614:8): [True: 0, False: 42.3k] ------------------ 1615| 0| { /* This was really a NUL. */ 1616| 0| yy_state_type yy_next_state; 1617| | 1618| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1619| | 1620| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1621| | 1622| | /* Okay, we're now positioned to make the NUL 1623| | * transition. We couldn't have 1624| | * yy_get_previous_state() go ahead and do it 1625| | * for us because it doesn't know how to deal 1626| | * with the possibility of jamming (and we don't 1627| | * want to build jamming into it because then it 1628| | * will run more slowly). 1629| | */ 1630| | 1631| 0| yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); 1632| | 1633| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 703| 0|#define YY_MORE_ADJ 0 ------------------ 1634| | 1635| 0| if ( yy_next_state ) ------------------ | Branch (1635:9): [True: 0, False: 0] ------------------ 1636| 0| { 1637| | /* Consume the NUL. */ 1638| 0| yy_cp = ++yyg->yy_c_buf_p; 1639| 0| yy_current_state = yy_next_state; 1640| 0| goto yy_match; 1641| 0| } 1642| | 1643| 0| else 1644| 0| { 1645| 0| yy_cp = yyg->yy_last_accepting_cpos; 1646| 0| yy_current_state = yyg->yy_last_accepting_state; 1647| 0| goto yy_find_action; 1648| 0| } 1649| 0| } 1650| | 1651| 42.3k| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1651:17): [True: 0, False: 42.3k] ------------------ 1652| 42.3k| { 1653| 20.3k| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 20.3k|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1653:4): [True: 20.3k, False: 22.0k] ------------------ 1654| 20.3k| { 1655| 20.3k| yyg->yy_did_buffer_switch_on_eof = 0; 1656| | 1657| 20.3k| if ( yywrap( yyscanner ) ) ------------------ | | 206| 20.3k|#define yywrap re_yywrap | | ------------------ | | | | 561| 20.3k|#define re_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1658| 20.3k| { 1659| | /* Note: because we've taken care in 1660| | * yy_get_next_buffer() to have set up 1661| | * yytext, we can now set up 1662| | * yy_c_buf_p so that if some total 1663| | * hoser (like flex itself) wants to 1664| | * call the scanner after we return the 1665| | * YY_NULL, it'll still work - another 1666| | * YY_NULL will get returned. 1667| | */ 1668| 20.3k| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 20.3k|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 703| 20.3k|#define YY_MORE_ADJ 0 ------------------ 1669| | 1670| 20.3k| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 20.3k|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 20.3k|#define YY_END_OF_BUFFER 30 | | ------------------ ------------------ 1671| 20.3k| goto do_action; 1672| 20.3k| } 1673| | 1674| 0| else 1675| 0| { 1676| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1676:11): [True: 0, False: 0] ------------------ 1677| 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 | | ------------------ ------------------ 1678| 0| } 1679| 0| break; 1680| 20.3k| } 1681| | 1682| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1682:4): [True: 0, False: 42.3k] ------------------ 1683| 0| yyg->yy_c_buf_p = 1684| 0| yyg->yytext_ptr + yy_amount_of_matched_text; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1685| | 1686| 0| yy_current_state = yy_get_previous_state( yyscanner ); 1687| | 1688| 0| yy_cp = yyg->yy_c_buf_p; 1689| 0| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 703| 0|#define YY_MORE_ADJ 0 ------------------ 1690| 0| goto yy_match; 1691| | 1692| 22.0k| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 22.0k|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1692:4): [True: 22.0k, False: 20.3k] ------------------ 1693| 22.0k| yyg->yy_c_buf_p = 1694| 22.0k| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 22.0k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1695| | 1696| 22.0k| yy_current_state = yy_get_previous_state( yyscanner ); 1697| | 1698| 22.0k| yy_cp = yyg->yy_c_buf_p; 1699| 22.0k| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 22.0k|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 703| 22.0k|#define YY_MORE_ADJ 0 ------------------ 1700| 22.0k| goto yy_find_action; 1701| 42.3k| } 1702| 0| break; 1703| 42.3k| } 1704| | 1705| 0| default: ------------------ | Branch (1705:2): [True: 0, False: 2.17M] ------------------ 1706| 0| YY_FATAL_ERROR( ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1707| 2.17M| "fatal flex scanner internal error--no action found" ); 1708| 2.17M| } /* end of action switch */ 1709| 2.17M| } /* end of scanning one token */ 1710| 2.12M| } /* end of user's declarations */ 1711| 2.12M|} /* end of yylex */ re_yyrestart: 2009| 39|{ 2010| 39| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2011| | 2012| 39| if ( ! YY_CURRENT_BUFFER ){ ------------------ | | 509| 39|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 39, False: 0] | | ------------------ | | 510| 39| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 39| : NULL) ------------------ | Branch (2012:7): [True: 0, False: 39] ------------------ 2013| 0| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 0|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 2014| 0| YY_CURRENT_BUFFER_LVALUE = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2015| 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 ------------------ 2016| 0| } 2017| | 2018| 39| yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 50| 39|#define yy_init_buffer re_yy_init_buffer ------------------ yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); ------------------ | | 509| 39|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 39, False: 0] | | ------------------ | | 510| 39| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 39| : NULL) ------------------ 2019| 39| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 39|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2020| 39|} re_yy_switch_to_buffer: 2027| 20.5k|{ 2028| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2029| | 2030| | /* TODO. We should be able to replace this entire function body 2031| | * with 2032| | * yypop_buffer_state(); 2033| | * yypush_buffer_state(new_buffer); 2034| | */ 2035| 20.5k| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 20.5k|#define yyensure_buffer_stack re_yyensure_buffer_stack ------------------ 2036| 20.5k| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ | Branch (2036:7): [True: 0, False: 20.5k] ------------------ 2037| 0| return; 2038| | 2039| 20.5k| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 20.5k] | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ 2040| 0| { 2041| | /* Flush out information for old buffer. */ 2042| 0| *yyg->yy_c_buf_p = yyg->yy_hold_char; 2043| 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] ------------------ 2044| 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] ------------------ 2045| 0| } 2046| | 2047| 20.5k| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 20.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2048| 20.5k| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 20.5k|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2049| | 2050| | /* We don't actually know whether we did this switch during 2051| | * EOF (yywrap()) processing, but the only time this flag 2052| | * is looked at is after yywrap() is called, so it's safe 2053| | * to go ahead and always set it. 2054| | */ 2055| 20.5k| yyg->yy_did_buffer_switch_on_eof = 1; 2056| 20.5k|} re_yy_delete_buffer: 2102| 20.5k|{ 2103| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2104| | 2105| 20.5k| if ( ! b ) ------------------ | Branch (2105:7): [True: 0, False: 20.5k] ------------------ 2106| 0| return; 2107| | 2108| 20.5k| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ | Branch (2108:7): [True: 20.5k, False: 0] ------------------ 2109| 20.5k| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 20.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2110| | 2111| 20.5k| if ( b->yy_is_our_buffer ) ------------------ | Branch (2111:7): [True: 20.5k, False: 0] ------------------ 2112| 20.5k| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 20.5k|#define yyfree re_yyfree ------------------ 2113| | 2114| 20.5k| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 20.5k|#define yyfree re_yyfree ------------------ 2115| 20.5k|} re_yy_flush_buffer: 2151| 39|{ 2152| 39| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2153| 39| if ( ! b ) ------------------ | Branch (2153:7): [True: 0, False: 39] ------------------ 2154| 0| return; 2155| | 2156| 39| b->yy_n_chars = 0; 2157| | 2158| | /* We always need two end-of-buffer characters. The first causes 2159| | * a transition to the end-of-buffer state. The second causes 2160| | * a jam in that state. 2161| | */ 2162| 39| b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 39|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2163| 39| b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 39|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2164| | 2165| 39| b->yy_buf_pos = &b->yy_ch_buf[0]; 2166| | 2167| 39| b->yy_at_bol = 1; 2168| 39| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 39|#define YY_BUFFER_NEW 0 ------------------ 2169| | 2170| 39| if ( b == YY_CURRENT_BUFFER ) ------------------ | | 509| 39|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 39, False: 0] | | ------------------ | | 510| 39| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 39| : NULL) ------------------ | Branch (2170:7): [True: 39, False: 0] ------------------ 2171| 39| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 39|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2172| 39|} re_yypop_buffer_state: 2212| 20.5k|{ 2213| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2214| 20.5k| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ | Branch (2214:6): [True: 20.5k, False: 0] ------------------ 2215| 20.5k| return; 2216| | 2217| 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) ------------------ 2218| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2219| 0| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2219:6): [True: 0, False: 0] ------------------ 2220| 0| --yyg->yy_buffer_stack_top; 2221| | 2222| 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) ------------------ 2223| 0| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 0|#define yy_load_buffer_state re_yy_load_buffer_state ------------------ 2224| 0| yyg->yy_did_buffer_switch_on_eof = 1; 2225| 0| } 2226| 0|} re_yy_scan_buffer: 2282| 20.5k|{ 2283| 20.5k| YY_BUFFER_STATE b; 2284| | 2285| 20.5k| if ( size < 2 || ------------------ | Branch (2285:7): [True: 0, False: 20.5k] ------------------ 2286| 20.5k| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 41.0k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2286:7): [True: 0, False: 20.5k] ------------------ 2287| 20.5k| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 20.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2287:7): [True: 0, False: 20.5k] ------------------ 2288| | /* They forgot to leave room for the EOB's. */ 2289| 0| return NULL; 2290| | 2291| 20.5k| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 20.5k|#define yyalloc re_yyalloc ------------------ 2292| 20.5k| if ( ! b ) ------------------ | Branch (2292:7): [True: 0, False: 20.5k] ------------------ 2293| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2294| | 2295| 20.5k| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2296| 20.5k| b->yy_buf_pos = b->yy_ch_buf = base; 2297| 20.5k| b->yy_is_our_buffer = 0; 2298| 20.5k| b->yy_input_file = NULL; 2299| 20.5k| b->yy_n_chars = b->yy_buf_size; 2300| 20.5k| b->yy_is_interactive = 0; 2301| 20.5k| b->yy_at_bol = 1; 2302| 20.5k| b->yy_fill_buffer = 0; 2303| 20.5k| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 20.5k|#define YY_BUFFER_NEW 0 ------------------ 2304| | 2305| 20.5k| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 20.5k|#define yy_switch_to_buffer re_yy_switch_to_buffer ------------------ 2306| | 2307| 20.5k| return b; 2308| 20.5k|} re_yy_scan_string: 2319| 20.5k|{ 2320| | 2321| 20.5k| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 20.5k|#define yy_scan_bytes re_yy_scan_bytes ------------------ 2322| 20.5k|} re_yy_scan_bytes: 2332| 20.5k|{ 2333| 20.5k| YY_BUFFER_STATE b; 2334| 20.5k| char *buf; 2335| 20.5k| yy_size_t n; 2336| 20.5k| int i; 2337| | 2338| | /* Get memory for full buffer, including space for trailing EOB's. */ 2339| 20.5k| n = (yy_size_t) (_yybytes_len + 2); 2340| 20.5k| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 20.5k|#define yyalloc re_yyalloc ------------------ 2341| 20.5k| if ( ! buf ) ------------------ | Branch (2341:7): [True: 0, False: 20.5k] ------------------ 2342| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2343| | 2344| 4.17M| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (2344:15): [True: 4.15M, False: 20.5k] ------------------ 2345| 4.15M| buf[i] = yybytes[i]; 2346| | 2347| 20.5k| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 20.5k|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2348| | 2349| 20.5k| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 20.5k|#define yy_scan_buffer re_yy_scan_buffer ------------------ 2350| 20.5k| if ( ! b ) ------------------ | Branch (2350:7): [True: 0, False: 20.5k] ------------------ 2351| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2352| | 2353| | /* It's okay to grow etc. this buffer, and we should throw it 2354| | * away when we're done. 2355| | */ 2356| 20.5k| b->yy_is_our_buffer = 1; 2357| | 2358| 20.5k| return b; 2359| 20.5k|} re_yyget_extra: 2396| 43.5k|{ 2397| 43.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2398| 43.5k| return yyextra; ------------------ | | 346| 43.5k|#define yyextra yyg->yyextra_r ------------------ 2399| 43.5k|} re_yyset_extra: 2469| 20.5k|{ 2470| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2471| 20.5k| yyextra = user_defined ; ------------------ | | 346| 20.5k|#define yyextra yyg->yyextra_r ------------------ 2472| 20.5k|} re_yylex_init: 2555| 20.5k|{ 2556| 20.5k| if (ptr_yy_globals == NULL){ ------------------ | Branch (2556:9): [True: 0, False: 20.5k] ------------------ 2557| 0| errno = EINVAL; 2558| 0| return 1; 2559| 0| } 2560| | 2561| 20.5k| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 20.5k|#define yyalloc re_yyalloc ------------------ 2562| | 2563| 20.5k| if (*ptr_yy_globals == NULL){ ------------------ | Branch (2563:9): [True: 0, False: 20.5k] ------------------ 2564| 0| errno = ENOMEM; 2565| 0| return 1; 2566| 0| } 2567| | 2568| | /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ 2569| 20.5k| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 2570| | 2571| 20.5k| return yy_init_globals ( *ptr_yy_globals ); 2572| 20.5k|} re_yylex_destroy: 2643| 20.5k|{ 2644| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2645| | 2646| | /* Pop the buffer stack, destroying each element. */ 2647| 41.0k| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 41.0k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 20.5k, False: 20.5k] | | | Branch (509:29): [True: 41.0k, False: 0] | | ------------------ | | 510| 41.0k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 41.0k| : NULL) ------------------ 2648| 20.5k| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 20.5k|#define yy_delete_buffer re_yy_delete_buffer ------------------ yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 509| 20.5k|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 20.5k, False: 0] | | ------------------ | | 510| 20.5k| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 20.5k| : NULL) ------------------ 2649| 20.5k| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 20.5k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2650| 20.5k| yypop_buffer_state(yyscanner); ------------------ | | 80| 20.5k|#define yypop_buffer_state re_yypop_buffer_state ------------------ 2651| 20.5k| } 2652| | 2653| | /* Destroy the stack itself. */ 2654| 20.5k| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 20.5k|#define yyfree re_yyfree ------------------ 2655| 20.5k| yyg->yy_buffer_stack = NULL; 2656| | 2657| | /* Destroy the start condition stack. */ 2658| 20.5k| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 20.5k|#define yyfree re_yyfree ------------------ 2659| 20.5k| yyg->yy_start_stack = NULL; 2660| | 2661| | /* Reset the globals. This is important in a non-reentrant scanner so the next time 2662| | * yylex() is called, initialization will occur. */ 2663| 20.5k| yy_init_globals( yyscanner); 2664| | 2665| | /* Destroy the main struct (reentrant only). */ 2666| 20.5k| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 20.5k|#define yyfree re_yyfree ------------------ 2667| 20.5k| yyscanner = NULL; 2668| 20.5k| return 0; 2669| 20.5k|} re_yyalloc: 2699| 82.1k|{ 2700| 82.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2701| 82.1k| (void)yyg; 2702| 82.1k| return malloc(size); 2703| 82.1k|} re_yyfree: 2721| 102k|{ 2722| 102k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2723| 102k| (void)yyg; 2724| 102k| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 2725| 102k|} escaped_char_value: 2735| 697k|{ 2736| 697k| unsigned int hex_value; 2737| 697k| char hex[3]; 2738| | 2739| 697k| assert(text[0] == '\\'); 2740| | 2741| 697k| switch(text[1]) 2742| 697k| { 2743| 658k| case 'x': ------------------ | Branch (2743:3): [True: 658k, False: 38.2k] ------------------ 2744| 658k| if (!isxdigit(text[2]) || !isxdigit(text[3])) ------------------ | Branch (2744:9): [True: 5, False: 658k] | Branch (2744:31): [True: 1, False: 658k] ------------------ 2745| 6| return 0; 2746| 658k| hex[0] = text[2]; 2747| 658k| hex[1] = text[3]; 2748| 658k| hex[2] = '\0'; 2749| 658k| sscanf(hex, "%x", &hex_value); 2750| 658k| *value = (uint8_t) hex_value; 2751| 658k| break; 2752| | 2753| 128| case 'n': ------------------ | Branch (2753:3): [True: 128, False: 697k] ------------------ 2754| 128| *value = '\n'; 2755| 128| break; 2756| | 2757| 129| case 't': ------------------ | Branch (2757:3): [True: 129, False: 697k] ------------------ 2758| 129| *value = '\t'; 2759| 129| break; 2760| | 2761| 132| case 'r': ------------------ | Branch (2761:3): [True: 132, False: 697k] ------------------ 2762| 132| *value = '\r'; 2763| 132| break; 2764| | 2765| 136| case 'f': ------------------ | Branch (2765:3): [True: 136, False: 697k] ------------------ 2766| 136| *value = '\f'; 2767| 136| break; 2768| | 2769| 130| case 'a': ------------------ | Branch (2769:3): [True: 130, False: 697k] ------------------ 2770| 130| *value = '\a'; 2771| 130| break; 2772| | 2773| 37.5k| default: ------------------ | Branch (2773:3): [True: 37.5k, False: 659k] ------------------ 2774| 37.5k| *value = text[1]; 2775| 697k| } 2776| | 2777| 697k| return 1; 2778| 697k|} read_escaped_char: 2791| 696k|{ 2792| 696k| char text[4] = {0, 0, 0, 0}; 2793| | 2794| 696k| text[0] = '\\'; 2795| 696k| text[1] = RE_YY_INPUT(yyscanner); ------------------ | | 2784| 696k|#define RE_YY_INPUT input ------------------ 2796| | 2797| 696k| if (text[1] == EOF || text[1] == 0) ------------------ | Branch (2797:7): [True: 9, False: 696k] | Branch (2797:25): [True: 0, False: 696k] ------------------ 2798| 9| return 0; 2799| | 2800| 696k| if (text[1] == 'x') ------------------ | Branch (2800:7): [True: 658k, False: 37.9k] ------------------ 2801| 658k| { 2802| 658k| text[2] = RE_YY_INPUT(yyscanner); ------------------ | | 2784| 658k|#define RE_YY_INPUT input ------------------ 2803| | 2804| 658k| if (text[2] == EOF || text[2] == 0) ------------------ | Branch (2804:9): [True: 1, False: 658k] | Branch (2804:27): [True: 39, False: 658k] ------------------ 2805| 40| return 0; 2806| | 2807| 658k| text[3] = RE_YY_INPUT(yyscanner); ------------------ | | 2784| 658k|#define RE_YY_INPUT input ------------------ 2808| | 2809| 658k| if (text[3] == EOF || text[3] == 0) ------------------ | Branch (2809:9): [True: 8, False: 658k] | Branch (2809:27): [True: 0, False: 658k] ------------------ 2810| 8| return 0; 2811| 658k| } 2812| | 2813| 696k| return escaped_char_value(text, escaped_char); 2814| 696k|} re_yyerror: 2838| 504|{ 2839| | // if lex_env->last_error was set to some error code before 2840| | // don't overwrite it, we are interested in the first error, not in 2841| | // subsequent errors like "syntax error, unexpected $end" caused by 2842| | // early parser termination. 2843| | 2844| 504| if (lex_env->last_error == ERROR_SUCCESS) ------------------ | | 40| 504|#define ERROR_SUCCESS 0 ------------------ | Branch (2844:7): [True: 290, False: 214] ------------------ 2845| 290| { 2846| 290| lex_env->last_error = ERROR_INVALID_REGULAR_EXPRESSION; ------------------ | | 54| 290|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ 2847| | 2848| 290| strlcpy( 2849| 290| lex_env->last_error_message, 2850| 290| error_message, 2851| 290| sizeof(lex_env->last_error_message)); 2852| 290| } 2853| 504|} yr_parse_re_string: 2860| 20.5k|{ 2861| 20.5k| yyscan_t yyscanner; 2862| 20.5k| jmp_buf recovery_trampoline; 2863| 20.5k| RE_LEX_ENVIRONMENT lex_env; 2864| | 2865| 20.5k| lex_env.last_error = ERROR_SUCCESS; ------------------ | | 40| 20.5k|#define ERROR_SUCCESS 0 ------------------ 2866| 20.5k| lex_env.last_error_message[0] = '\0'; 2867| | 2868| 20.5k| yr_thread_storage_set_value( 2869| 20.5k| &yr_yyfatal_trampoline_tls, 2870| 20.5k| &recovery_trampoline); 2871| | 2872| | // setjmp returns a non-zero value only when we are returning to this 2873| | // point via a call to longjmp to the recovery trampoline. 2874| 20.5k| if (setjmp(recovery_trampoline) != 0) ------------------ | Branch (2874:7): [True: 0, False: 20.5k] ------------------ 2875| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 2876| | 2877| 20.5k| FAIL_ON_ERROR(yr_re_ast_create(re_ast)); ------------------ | | 131| 20.5k| { \ | | 132| 20.5k| int __error = (x); \ | | 133| 20.5k| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 20.5k|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (133:9): [True: 0, False: 20.5k] | | ------------------ | | 134| 20.5k| return __error; \ | | 135| 20.5k| } ------------------ 2878| | 2879| 20.5k| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 20.5k|#define yylex_init re_yylex_init ------------------ | Branch (2879:7): [True: 0, False: 20.5k] ------------------ 2880| 0| { 2881| 0| yr_re_ast_destroy(*re_ast); 2882| 0| *re_ast = NULL; 2883| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 2884| 0| } 2885| | 2886| 20.5k| yyset_extra(*re_ast, yyscanner); ------------------ | | 140| 20.5k|#define yyset_extra re_yyset_extra ------------------ 2887| 20.5k| yy_scan_string(re_string, yyscanner); ------------------ | | 38| 20.5k|#define yy_scan_string re_yy_scan_string ------------------ 2888| 20.5k| yyparse(yyscanner, &lex_env); ------------------ | | 44| 20.5k|#define yyparse re_yyparse ------------------ 2889| 20.5k| yylex_destroy(yyscanner); ------------------ | | 116| 20.5k|#define yylex_destroy re_yylex_destroy ------------------ 2890| | 2891| 20.5k| if (lex_env.last_error != ERROR_SUCCESS) ------------------ | | 40| 20.5k|#define ERROR_SUCCESS 0 ------------------ | Branch (2891:7): [True: 290, False: 20.2k] ------------------ 2892| 290| { 2893| 290| yr_re_ast_destroy(*re_ast); 2894| 290| *re_ast = NULL; 2895| | 2896| 290| strlcpy( 2897| 290| error->message, 2898| 290| lex_env.last_error_message, 2899| 290| sizeof(error->message)); 2900| | 2901| 290| return lex_env.last_error; 2902| 290| } 2903| | 2904| 20.2k| return ERROR_SUCCESS; ------------------ | | 40| 20.2k|#define ERROR_SUCCESS 0 ------------------ 2905| 20.5k|} re_lexer.c:yy_get_next_buffer: 1721| 42.4k|{ 1722| 42.4k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1723| 42.4k| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 42.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1724| 42.4k| char *source = yyg->yytext_ptr; ------------------ | | 567| 42.4k|#define yytext_ptr yytext_r ------------------ 1725| 42.4k| int number_to_move, i; 1726| 42.4k| int ret_val; 1727| | 1728| 42.4k| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 42.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1728:7): [True: 0, False: 42.4k] ------------------ 1729| 0| YY_FATAL_ERROR( ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1730| 42.4k| "fatal flex scanner internal error--end of buffer missed" ); 1731| | 1732| 42.4k| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 42.4k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1732:7): [True: 42.4k, False: 0] ------------------ 1733| 42.4k| { /* Don't try to fill the buffer, so this is an EOF. */ 1734| 42.4k| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 42.4k|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 703| 42.4k|#define YY_MORE_ADJ 0 ------------------ | Branch (1734:8): [True: 20.3k, False: 22.0k] ------------------ 1735| 20.3k| { 1736| | /* We matched a single character, the EOB, so 1737| | * treat this as a final EOF. 1738| | */ 1739| 20.3k| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 20.3k|#define EOB_ACT_END_OF_FILE 1 ------------------ 1740| 20.3k| } 1741| | 1742| 22.0k| else 1743| 22.0k| { 1744| | /* We matched some text prior to the EOB, first 1745| | * process it. 1746| | */ 1747| 22.0k| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 22.0k|#define EOB_ACT_LAST_MATCH 2 ------------------ 1748| 22.0k| } 1749| 42.4k| } 1750| | 1751| | /* Try to read more data. */ 1752| | 1753| | /* First move last chars to start of buffer. */ 1754| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1755| | 1756| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (1756:15): [True: 0, False: 0] ------------------ 1757| 0| *(dest++) = *(source++); 1758| | 1759| 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 (1759:7): [True: 0, False: 0] ------------------ 1760| | /* don't do the read, it's not guaranteed to return an EOF, 1761| | * just force an EOF 1762| | */ 1763| 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] ------------------ 1764| | 1765| 0| else 1766| 0| { 1767| 0| int num_to_read = 1768| 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] ------------------ 1769| | 1770| 0| while ( num_to_read <= 0 ) ------------------ | Branch (1770:11): [True: 0, False: 0] ------------------ 1771| 0| { /* Not enough room in the buffer - grow it. */ 1772| | 1773| | /* just a shorter name for the current buffer */ 1774| 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] ------------------ 1775| | 1776| 0| int yy_c_buf_p_offset = 1777| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 1778| | 1779| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (1779:9): [True: 0, False: 0] ------------------ 1780| 0| { 1781| 0| int new_size = b->yy_buf_size * 2; 1782| | 1783| 0| if ( new_size <= 0 ) ------------------ | Branch (1783:10): [True: 0, False: 0] ------------------ 1784| 0| b->yy_buf_size += b->yy_buf_size / 8; 1785| 0| else 1786| 0| b->yy_buf_size *= 2; 1787| | 1788| 0| b->yy_ch_buf = (char *) 1789| | /* Include room in for 2 EOB chars. */ 1790| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 230| 0|#define yyrealloc re_yyrealloc ------------------ 1791| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 1792| 0| } 1793| 0| else 1794| | /* Can't grow it, we don't own it. */ 1795| 0| b->yy_ch_buf = NULL; 1796| | 1797| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (1797:9): [True: 0, False: 0] ------------------ 1798| 0| YY_FATAL_ERROR( ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1799| 0| "fatal error - scanner input buffer overflow" ); 1800| | 1801| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1802| | 1803| 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] ------------------ 1804| 0| number_to_move - 1; 1805| | 1806| 0| } 1807| | 1808| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 936| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (1808:8): [True: 0, False: 0] ------------------ 1809| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 936| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 1810| | 1811| | /* Read in more data. */ 1812| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 953| 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 (953:7): [True: 0, False: 0] | | ------------------ | | 954| 0| { \ | | 955| 0| int c = '*'; \ | | 956| 0| int n; \ | | 957| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (957:16): [True: 0, False: 0] | | ------------------ | | 958| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (958:9): [True: 0, False: 0] | | | Branch (958:38): [True: 0, False: 0] | | ------------------ | | 959| 0| buf[n] = (char) c; \ | | 960| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (960:8): [True: 0, False: 0] | | ------------------ | | 961| 0| buf[n++] = (char) c; \ | | 962| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (962:8): [True: 0, False: 0] | | | Branch (962:20): [True: 0, False: 0] | | ------------------ | | 963| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) | | ------------------ | | 964| 0| result = n; \ | | 965| 0| } \ | | 966| 0| else \ | | 967| 0| { \ | | 968| 0| errno=0; \ | | 969| 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 (969:11): [True: 0, False: 0] | | | Branch (969:78): [True: 0, False: 0] | | ------------------ | | 970| 0| { \ | | 971| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (971:8): [True: 0, False: 0] | | ------------------ | | 972| 0| { \ | | 973| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) | | ------------------ | | 974| 0| break; \ | | 975| 0| } \ | | 976| 0| errno=0; \ | | 977| 0| clearerr(yyin); \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | 978| 0| } \ | | 979| 0| }\ ------------------ 1813| 0| yyg->yy_n_chars, num_to_read ); 1814| | 1815| 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] ------------------ 1816| 0| } 1817| | 1818| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (1818:7): [True: 0, False: 0] ------------------ 1819| 0| { 1820| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 703| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (1820:8): [True: 0, False: 0] ------------------ 1821| 0| { 1822| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 398| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 1823| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart re_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ 1824| 0| } 1825| | 1826| 0| else 1827| 0| { 1828| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 399| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 1829| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 1830| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 1831| 0| } 1832| 0| } 1833| | 1834| 0| else 1835| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 1836| | 1837| 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 (1837:6): [True: 0, False: 0] ------------------ 1838| | /* Extend the array by 50%, plus the number we really need. */ 1839| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 1840| 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 ------------------ 1841| 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] ------------------ 1842| 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 (1842:8): [True: 0, False: 0] ------------------ 1843| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 1844| | /* "- 2" to take care of EOB's */ 1845| 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] ------------------ 1846| 0| } 1847| | 1848| 0| yyg->yy_n_chars += number_to_move; 1849| 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 ------------------ 1850| 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 ------------------ 1851| | 1852| 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] ------------------ 1853| | 1854| 0| return ret_val; 1855| 42.4k|} re_lexer.c:yy_get_previous_state: 1860| 22.0k|{ 1861| 22.0k| yy_state_type yy_current_state; 1862| 22.0k| char *yy_cp; 1863| 22.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1864| | 1865| 22.0k| yy_current_state = yyg->yy_start; 1866| | 1867| 50.7k| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 22.0k|#define yytext_ptr yytext_r ------------------ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 703| 22.0k|#define YY_MORE_ADJ 0 ------------------ | Branch (1867:47): [True: 28.7k, False: 22.0k] ------------------ 1868| 28.7k| { 1869| 28.7k| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 28.7k|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (1869:19): [True: 28.7k, False: 0] ------------------ 1870| 28.7k| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1870:8): [True: 1.86k, False: 26.8k] ------------------ 1871| 1.86k| { 1872| 1.86k| yyg->yy_last_accepting_state = yy_current_state; 1873| 1.86k| yyg->yy_last_accepting_cpos = yy_cp; 1874| 1.86k| } 1875| 44.6k| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1875:11): [True: 15.9k, False: 28.7k] ------------------ 1876| 15.9k| { 1877| 15.9k| yy_current_state = (int) yy_def[yy_current_state]; 1878| 15.9k| if ( yy_current_state >= 45 ) ------------------ | Branch (1878:9): [True: 15.9k, False: 0] ------------------ 1879| 15.9k| yy_c = yy_meta[yy_c]; 1880| 15.9k| } 1881| 28.7k| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1882| 28.7k| } 1883| | 1884| 22.0k| return yy_current_state; 1885| 22.0k|} re_lexer.c:re_yy_load_buffer_state: 2059| 41.1k|{ 2060| 41.1k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2061| 41.1k| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 41.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2062| 41.1k| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 41.1k|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 41.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2063| 41.1k| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 41.1k|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 41.1k|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2064| 41.1k| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2065| 41.1k|} re_lexer.c:re_yy_init_buffer: 2123| 39|{ 2124| 39| int oerrno = errno; 2125| 39| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2126| | 2127| 39| yy_flush_buffer( b , yyscanner); ------------------ | | 56| 39|#define yy_flush_buffer re_yy_flush_buffer ------------------ 2128| | 2129| 39| b->yy_input_file = file; 2130| 39| b->yy_fill_buffer = 1; 2131| | 2132| | /* If b is the current buffer, then yy_init_buffer was _probably_ 2133| | * called from yyrestart() or through yy_get_next_buffer. 2134| | * In that case, we don't want to reset the lineno or column. 2135| | */ 2136| 39| if (b != YY_CURRENT_BUFFER){ ------------------ | | 509| 39|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 39, False: 0] | | ------------------ | | 510| 39| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 39| : NULL) ------------------ | Branch (2136:9): [True: 0, False: 39] ------------------ 2137| 0| b->yy_bs_lineno = 1; 2138| 0| b->yy_bs_column = 0; 2139| 0| } 2140| | 2141| 39| b->yy_is_interactive = 0; 2142| | 2143| 39| errno = oerrno; 2144| 39|} re_lexer.c:re_yyensure_buffer_stack: 2232| 20.5k|{ 2233| 20.5k| yy_size_t num_to_alloc; 2234| 20.5k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2235| | 2236| 20.5k| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2236:6): [True: 20.5k, False: 0] ------------------ 2237| | 2238| | /* First allocation is just for 2 elements, since we don't know if this 2239| | * scanner will even need a stack. We use 2 instead of 1 to avoid an 2240| | * immediate realloc on the next call. 2241| | */ 2242| 20.5k| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2243| 20.5k| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 20.5k|#define yyalloc re_yyalloc ------------------ 2244| 20.5k| (num_to_alloc * sizeof(struct yy_buffer_state*) 2245| 20.5k| , yyscanner); 2246| 20.5k| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2246:8): [True: 0, False: 20.5k] ------------------ 2247| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2248| | 2249| 20.5k| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2250| | 2251| 20.5k| yyg->yy_buffer_stack_max = num_to_alloc; 2252| 20.5k| yyg->yy_buffer_stack_top = 0; 2253| 20.5k| return; 2254| 20.5k| } 2255| | 2256| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2256:6): [True: 0, False: 0] ------------------ 2257| | 2258| | /* Increase the buffer to prepare for a possible push. */ 2259| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2260| | 2261| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2262| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 230| 0|#define yyrealloc re_yyrealloc ------------------ 2263| 0| (yyg->yy_buffer_stack, 2264| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2265| 0| , yyscanner); 2266| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2266:8): [True: 0, False: 0] ------------------ 2267| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 77| 0|#define YY_FATAL_ERROR(msg) re_yyfatal(yyscanner, msg) ------------------ 2268| | 2269| | /* zero only the new slots.*/ 2270| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2271| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2272| 0| } 2273| 0|} re_lexer.c:yy_init_globals: 2609| 41.0k|{ 2610| 41.0k| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2611| | /* Initialization is the same as for the non-reentrant scanner. 2612| | * This function is called from yylex_destroy(), so don't allocate here. 2613| | */ 2614| | 2615| 41.0k| yyg->yy_buffer_stack = NULL; 2616| 41.0k| yyg->yy_buffer_stack_top = 0; 2617| 41.0k| yyg->yy_buffer_stack_max = 0; 2618| 41.0k| yyg->yy_c_buf_p = NULL; 2619| 41.0k| yyg->yy_init = 0; 2620| 41.0k| yyg->yy_start = 0; 2621| | 2622| 41.0k| yyg->yy_start_stack_ptr = 0; 2623| 41.0k| yyg->yy_start_stack_depth = 0; 2624| 41.0k| yyg->yy_start_stack = NULL; 2625| | 2626| |/* Defined in main.c */ 2627| |#ifdef YY_STDINIT 2628| | yyin = stdin; 2629| | yyout = stdout; 2630| |#else 2631| 41.0k| yyin = NULL; ------------------ | | 344| 41.0k|#define yyin yyg->yyin_r ------------------ 2632| 41.0k| yyout = NULL; ------------------ | | 345| 41.0k|#define yyout yyg->yyout_r ------------------ 2633| 41.0k|#endif 2634| | 2635| | /* For future reference: Set errno on error, since we are called by 2636| | * yylex_init() 2637| | */ 2638| 41.0k| return 0; 2639| 41.0k|} re_lexer.c:input: 1928| 2.01M|{ 1929| 2.01M| int c; 1930| 2.01M| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1931| | 1932| 2.01M| *yyg->yy_c_buf_p = yyg->yy_hold_char; 1933| | 1934| 2.01M| if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 2.01M|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (1934:7): [True: 39, False: 2.01M] ------------------ 1935| 39| { 1936| | /* yy_c_buf_p now points to the character we want to return. 1937| | * If this occurs *before* the EOB characters, then it's a 1938| | * valid NUL; if not, then we've hit the end of the buffer. 1939| | */ 1940| 39| if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 39|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (1940:8): [True: 0, False: 39] ------------------ 1941| | /* This was really a NUL. */ 1942| 0| *yyg->yy_c_buf_p = '\0'; 1943| | 1944| 39| else 1945| 39| { /* need more input */ 1946| 39| int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); ------------------ | | 567| 39|#define yytext_ptr yytext_r ------------------ 1947| 39| ++yyg->yy_c_buf_p; 1948| | 1949| 39| switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (1949:13): [True: 0, False: 39] ------------------ 1950| 39| { 1951| 39| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 39|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (1951:5): [True: 39, False: 0] ------------------ 1952| | /* This happens because yy_g_n_b() 1953| | * sees that we've accumulated a 1954| | * token and flags that we need to 1955| | * try matching the token before 1956| | * proceeding. But for input(), 1957| | * there's no matching to consider. 1958| | * So convert the EOB_ACT_LAST_MATCH 1959| | * to EOB_ACT_END_OF_FILE. 1960| | */ 1961| | 1962| | /* Reset buffer status. */ 1963| 39| yyrestart( yyin , yyscanner); ------------------ | | 98| 39|#define yyrestart re_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 39|#define yyin yyg->yyin_r ------------------ 1964| | 1965| | /*FALLTHROUGH*/ 1966| | 1967| 39| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 39|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (1967:5): [True: 0, False: 39] ------------------ 1968| 39| { 1969| 39| if ( yywrap( yyscanner ) ) ------------------ | | 206| 39|#define yywrap re_yywrap | | ------------------ | | | | 561| 39|#define re_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:30): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1970| 39| return 0; 1971| | 1972| 0| if ( ! yyg->yy_did_buffer_switch_on_eof ) ------------------ | Branch (1972:11): [True: 0, False: 0] ------------------ 1973| 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 | | ------------------ ------------------ 1974| |#ifdef __cplusplus 1975| | return yyinput(yyscanner); 1976| |#else 1977| 0| return input(yyscanner); 1978| 39|#endif 1979| 39| } 1980| | 1981| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (1981:5): [True: 0, False: 39] ------------------ 1982| 0| yyg->yy_c_buf_p = yyg->yytext_ptr + offset; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 1983| 0| break; 1984| 39| } 1985| 39| } 1986| 39| } 1987| | 1988| 2.01M| c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ 1989| 2.01M| *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ 1990| 2.01M| yyg->yy_hold_char = *++yyg->yy_c_buf_p; 1991| | 1992| 2.01M| if ( c == '\n' ) ------------------ | Branch (1992:7): [True: 0, False: 2.01M] ------------------ 1993| | 1994| 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] | | ------------------ ------------------ 1995| 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] | | ------------------ ------------------ 1996| 0| }while(0) ------------------ | Branch (1996:12): [Folded - Ignored] ------------------ 1997| 2.01M|; 1998| | 1999| 2.01M| return c; 2000| 2.01M|} yr_rules_from_arena: 327| 132|{ 328| 132| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_get_ptr( 329| 132| arena, YR_SUMMARY_SECTION, 0); ------------------ | | 68| 132|#define YR_SUMMARY_SECTION 11 ------------------ 330| | 331| 132| if (summary == NULL) ------------------ | Branch (331:7): [True: 0, False: 132] ------------------ 332| 0| return ERROR_CORRUPT_FILE; ------------------ | | 52| 0|#define ERROR_CORRUPT_FILE 7 ------------------ 333| | 334| 132| YR_RULES* new_rules = (YR_RULES*) yr_malloc(sizeof(YR_RULES)); 335| | 336| 132| if (new_rules == NULL) ------------------ | Branch (336:7): [True: 0, False: 132] ------------------ 337| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 338| | 339| | // Now YR_RULES relies on this arena, let's increment the arena's 340| | // reference count so that if the original owner of the arena calls 341| | // yr_arena_destroy the arena is not destroyed. 342| 132| yr_arena_acquire(arena); 343| | 344| 132| new_rules->arena = arena; 345| 132| new_rules->num_rules = summary->num_rules; 346| 132| new_rules->num_strings = summary->num_strings; 347| 132| new_rules->num_namespaces = summary->num_namespaces; 348| | 349| 132| new_rules->rules_table = yr_arena_get_ptr(arena, YR_RULES_TABLE, 0); ------------------ | | 58| 132|#define YR_RULES_TABLE 1 ------------------ 350| | 351| 132| new_rules->strings_table = yr_arena_get_ptr(arena, YR_STRINGS_TABLE, 0); ------------------ | | 60| 132|#define YR_STRINGS_TABLE 3 ------------------ 352| | 353| 132| new_rules->ext_vars_table = yr_arena_get_ptr( 354| 132| arena, YR_EXTERNAL_VARIABLES_TABLE, 0); ------------------ | | 61| 132|#define YR_EXTERNAL_VARIABLES_TABLE 4 ------------------ 355| | 356| 132| new_rules->ac_transition_table = yr_arena_get_ptr( 357| 132| arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 132|#define YR_AC_TRANSITION_TABLE 8 ------------------ 358| | 359| 132| new_rules->ac_match_table = yr_arena_get_ptr( 360| 132| arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 132|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 361| | 362| 132| new_rules->ac_match_pool = yr_arena_get_ptr( 363| 132| arena, YR_AC_STATE_MATCHES_POOL, 0); ------------------ | | 67| 132|#define YR_AC_STATE_MATCHES_POOL 10 ------------------ 364| | 365| 132| new_rules->code_start = yr_arena_get_ptr(arena, YR_CODE_SECTION, 0); ------------------ | | 63| 132|#define YR_CODE_SECTION 6 ------------------ 366| | 367| 132| *rules = new_rules; 368| | 369| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 370| 132|} yr_rules_destroy: 516| 132|{ 517| 132| YR_EXTERNAL_VARIABLE* external = rules->ext_vars_table; 518| | 519| 132| while (!EXTERNAL_VARIABLE_IS_NULL(external)) ------------------ | | 152| 132| ((x) != NULL ? (x)->type == EXTERNAL_VARIABLE_TYPE_NULL : true) | | ------------------ | | | | 144| 132|#define EXTERNAL_VARIABLE_TYPE_NULL 0 | | ------------------ | | | Branch (152:4): [True: 132, False: 0] | | ------------------ ------------------ | Branch (519:10): [True: 0, False: 132] ------------------ 520| 0| { 521| 0| if (external->type == EXTERNAL_VARIABLE_TYPE_MALLOC_STRING) ------------------ | | 149| 0|#define EXTERNAL_VARIABLE_TYPE_MALLOC_STRING 5 ------------------ | Branch (521:9): [True: 0, False: 0] ------------------ 522| 0| yr_free(external->value.s); 523| | 524| 0| external++; 525| 0| } 526| | 527| 132| yr_arena_release(rules->arena); 528| 132| yr_free(rules); 529| | 530| 132| return ERROR_SUCCESS; ------------------ | | 40| 132|#define ERROR_SUCCESS 0 ------------------ 531| 132|} ss_compare: 45| 495|{ 46| 495| size_t i = 0; 47| | 48| 30.7k| while (s1->length > i && s2->length > i && s1->c_string[i] == s2->c_string[i]) ------------------ | Branch (48:10): [True: 30.2k, False: 472] | Branch (48:28): [True: 30.2k, False: 0] | Branch (48:46): [True: 30.2k, False: 23] ------------------ 49| 30.2k| { 50| 30.2k| i++; 51| 30.2k| } 52| | 53| 495| if (i == s1->length && i == s2->length) ------------------ | Branch (53:7): [True: 472, False: 23] | Branch (53:26): [True: 472, False: 0] ------------------ 54| 472| return 0; 55| 23| else if (i == s1->length) ------------------ | Branch (55:12): [True: 0, False: 23] ------------------ 56| 0| return -1; 57| 23| else if (i == s2->length) ------------------ | Branch (57:12): [True: 0, False: 23] ------------------ 58| 0| return 1; 59| 23| else if (s1->c_string[i] < s2->c_string[i]) ------------------ | Branch (59:12): [True: 11, False: 12] ------------------ 60| 11| return -1; 61| 12| else 62| 12| return 1; 63| 495|} ss_new: 216| 2.47k|{ 217| 2.47k| SIZED_STRING* result; 218| | 219| 2.47k| size_t length = strlen(s); 220| | 221| 2.47k| result = (SIZED_STRING*) yr_malloc(sizeof(SIZED_STRING) + length); 222| | 223| 2.47k| if (result == NULL) ------------------ | Branch (223:7): [True: 0, False: 2.47k] ------------------ 224| 0| return NULL; 225| | 226| 2.47k| result->length = (uint32_t) length; 227| 2.47k| result->flags = 0; 228| | 229| | // Copy the string and the null terminator. 230| 2.47k| strcpy(result->c_string, s); 231| | 232| 2.47k| return result; 233| 2.47k|} ss_convert_to_wide: 240| 4.59k|{ 241| 4.59k| SIZED_STRING* wide = (SIZED_STRING*) yr_malloc( 242| 4.59k| sizeof(SIZED_STRING) + s->length * 2); 243| | 244| 4.59k| if (wide == NULL) ------------------ | Branch (244:7): [True: 0, False: 4.59k] ------------------ 245| 0| return NULL; 246| | 247| 771k| for (size_t i = 0; i < s->length; i++) ------------------ | Branch (247:22): [True: 766k, False: 4.59k] ------------------ 248| 766k| { 249| 766k| wide->c_string[i * 2] = s->c_string[i]; 250| 766k| wide->c_string[i * 2 + 1] = '\x00'; 251| 766k| } 252| | 253| 4.59k| wide->length = s->length * 2; 254| 4.59k| wide->flags = s->flags | STRING_FLAGS_WIDE; ------------------ | | 70| 4.59k|#define STRING_FLAGS_WIDE 0x10 ------------------ 255| | 256| 4.59k| return wide; 257| 4.59k|} yr_stack_create: 42| 7.09k|{ 43| 7.09k| *stack = (YR_STACK*) yr_malloc(sizeof(YR_STACK)); 44| | 45| 7.09k| if (*stack == NULL) ------------------ | Branch (45:7): [True: 0, False: 7.09k] ------------------ 46| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 47| | 48| 7.09k| (*stack)->items = yr_malloc(initial_capacity * item_size); 49| | 50| 7.09k| if ((*stack)->items == NULL) ------------------ | Branch (50:7): [True: 0, False: 7.09k] ------------------ 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| 7.09k| (*stack)->capacity = initial_capacity; 58| 7.09k| (*stack)->item_size = item_size; 59| 7.09k| (*stack)->top = 0; 60| | 61| 7.09k| return ERROR_SUCCESS; ------------------ | | 40| 7.09k|#define ERROR_SUCCESS 0 ------------------ 62| 7.09k|} yr_stack_destroy: 68| 7.09k|{ 69| 7.09k| yr_free(stack->items); 70| 7.09k| yr_free(stack); 71| 7.09k|} yr_stack_push: 79| 1.18M|{ 80| 1.18M| if (stack->top == stack->capacity) ------------------ | Branch (80:7): [True: 235, False: 1.18M] ------------------ 81| 235| { 82| 235| void* items = yr_realloc( 83| 235| stack->items, 2 * stack->capacity * stack->item_size); 84| | 85| 235| if (items == NULL) ------------------ | Branch (85:9): [True: 0, False: 235] ------------------ 86| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 87| | 88| 235| stack->items = items; 89| 235| stack->capacity *= 2; 90| 235| } 91| | 92| 1.18M| memcpy( 93| 1.18M| (uint8_t*) stack->items + stack->top * stack->item_size, 94| 1.18M| item, 95| 1.18M| stack->item_size); 96| | 97| 1.18M| stack->top++; 98| | 99| 1.18M| return ERROR_SUCCESS; ------------------ | | 40| 1.18M|#define ERROR_SUCCESS 0 ------------------ 100| 1.18M|} yr_stack_pop: 109| 1.19M|{ 110| 1.19M| if (stack->top == 0) // Return 0 if stack is empty. ------------------ | Branch (110:7): [True: 7.09k, False: 1.18M] ------------------ 111| 7.09k| return 0; 112| | 113| 1.18M| stack->top--; 114| | 115| 1.18M| memcpy( 116| 1.18M| item, 117| 1.18M| (uint8_t*) stack->items + stack->top * stack->item_size, 118| 1.18M| stack->item_size); 119| | 120| 1.18M| return 1; 121| 1.19M|} xtoi: 36| 46.5k|{ 37| 46.5k| size_t i; 38| 46.5k| size_t l = strlen(hexstr); 39| | 40| 46.5k| uint64_t r = 0; 41| | 42| 139k| for (i = 0; i < l; i++) ------------------ | Branch (42:15): [True: 93.1k, False: 46.5k] ------------------ 43| 93.1k| { 44| 93.1k| switch (hexstr[i]) 45| 93.1k| { 46| 3.54k| case '0': ------------------ | Branch (46:5): [True: 3.54k, False: 89.5k] ------------------ 47| 4.43k| case '1': ------------------ | Branch (47:5): [True: 885, False: 92.2k] ------------------ 48| 5.01k| case '2': ------------------ | Branch (48:5): [True: 583, False: 92.5k] ------------------ 49| 5.28k| case '3': ------------------ | Branch (49:5): [True: 271, False: 92.8k] ------------------ 50| 5.50k| case '4': ------------------ | Branch (50:5): [True: 218, False: 92.8k] ------------------ 51| 5.91k| case '5': ------------------ | Branch (51:5): [True: 410, False: 92.6k] ------------------ 52| 6.36k| case '6': ------------------ | Branch (52:5): [True: 448, False: 92.6k] ------------------ 53| 6.60k| case '7': ------------------ | Branch (53:5): [True: 246, False: 92.8k] ------------------ 54| 6.80k| case '8': ------------------ | Branch (54:5): [True: 199, False: 92.9k] ------------------ 55| 7.05k| case '9': ------------------ | Branch (55:5): [True: 249, False: 92.8k] ------------------ 56| 7.05k| r |= ((uint64_t) (hexstr[i] - '0')) << ((l - i - 1) * 4); 57| 7.05k| break; 58| 82.4k| case 'a': ------------------ | Branch (58:5): [True: 82.4k, False: 10.6k] ------------------ 59| 82.5k| case 'b': ------------------ | Branch (59:5): [True: 92, False: 93.0k] ------------------ 60| 82.5k| case 'c': ------------------ | Branch (60:5): [True: 15, False: 93.0k] ------------------ 61| 82.8k| case 'd': ------------------ | Branch (61:5): [True: 319, False: 92.7k] ------------------ 62| 82.8k| case 'e': ------------------ | Branch (62:5): [True: 26, False: 93.0k] ------------------ 63| 84.1k| case 'f': ------------------ | Branch (63:5): [True: 1.30k, False: 91.8k] ------------------ 64| 84.1k| r |= ((uint64_t) (hexstr[i] - 'a' + 10)) << ((l - i - 1) * 4); 65| 84.1k| break; 66| 819| case 'A': ------------------ | Branch (66:5): [True: 819, False: 92.2k] ------------------ 67| 1.27k| case 'B': ------------------ | Branch (67:5): [True: 451, False: 92.6k] ------------------ 68| 1.39k| case 'C': ------------------ | Branch (68:5): [True: 128, False: 92.9k] ------------------ 69| 1.64k| case 'D': ------------------ | Branch (69:5): [True: 250, False: 92.8k] ------------------ 70| 1.74k| case 'E': ------------------ | Branch (70:5): [True: 92, False: 93.0k] ------------------ 71| 1.88k| case 'F': ------------------ | Branch (71:5): [True: 143, False: 92.9k] ------------------ 72| 1.88k| r |= ((uint64_t) (hexstr[i] - 'A' + 10)) << ((l - i - 1) * 4); 73| 1.88k| break; 74| 0| default: ------------------ | Branch (74:5): [True: 0, False: 93.1k] ------------------ 75| 0| i = l; // force loop exit 76| 93.1k| } 77| 93.1k| } 78| | 79| 46.5k| return r; 80| 46.5k|} strlcpy: 91| 43.6k|{ 92| 43.6k| register char* d = dst; 93| 43.6k| register const char* s = src; 94| 43.6k| register size_t n = size; 95| | 96| | // Copy as many bytes as will fit 97| | 98| 43.6k| if (n != 0 && --n != 0) ------------------ | Branch (98:7): [True: 43.6k, False: 0] | Branch (98:17): [True: 43.6k, False: 0] ------------------ 99| 43.6k| { 100| 43.6k| do 101| 1.23M| { 102| 1.23M| if ((*d++ = *s++) == 0) ------------------ | Branch (102:11): [True: 22.7k, False: 1.21M] ------------------ 103| 22.7k| break; 104| | 105| 1.23M| } while (--n != 0); ------------------ | Branch (105:14): [True: 1.19M, False: 20.9k] ------------------ 106| 43.6k| } 107| | 108| | // Not enough room in dst, add NUL and traverse rest of src 109| | 110| 43.6k| if (n == 0) ------------------ | Branch (110:7): [True: 20.9k, False: 22.7k] ------------------ 111| 20.9k| { 112| 20.9k| if (size != 0) ------------------ | Branch (112:9): [True: 20.9k, False: 0] ------------------ 113| 20.9k| *d = '\0'; // NULL-terminate dst 114| | 115| 49.2k| while (*s++) ------------------ | Branch (115:12): [True: 28.3k, False: 20.9k] ------------------ 116| 28.3k| ; 117| 20.9k| } 118| | 119| 43.6k| return (s - src - 1); // count does not include NULL 120| 43.6k|} strlcat: 125| 9.31k|{ 126| 9.31k| register char* d = dst; 127| 9.31k| register const char* s = src; 128| 9.31k| register size_t n = size; 129| 9.31k| size_t dlen; 130| | 131| | // Find the end of dst and adjust bytes left but don't go past end 132| | 133| 383k| while (n-- != 0 && *d != '\0') d++; ------------------ | Branch (133:10): [True: 383k, False: 0] | Branch (133:22): [True: 374k, False: 9.31k] ------------------ 134| | 135| 9.31k| dlen = d - dst; 136| 9.31k| n = size - dlen; 137| | 138| 9.31k| if (n == 0) ------------------ | Branch (138:7): [True: 0, False: 9.31k] ------------------ 139| 0| return (dlen + strlen(s)); 140| | 141| 18.6k| while (*s != '\0') ------------------ | Branch (141:10): [True: 9.31k, False: 9.31k] ------------------ 142| 9.31k| { 143| 9.31k| if (n != 1) ------------------ | Branch (143:9): [True: 8.59k, False: 720] ------------------ 144| 8.59k| { 145| 8.59k| *d++ = *s; 146| 8.59k| n--; 147| 8.59k| } 148| 9.31k| s++; 149| 9.31k| } 150| | 151| 9.31k| *d = '\0'; 152| | 153| 9.31k| return (dlen + (s - src)); // count does not include NULL 154| 9.31k|} 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; ------------------ | | 76| 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| 21.6k|{ 179| 21.6k| if (pthread_setspecific(*storage, value) != 0) ------------------ | Branch (179:7): [True: 0, False: 21.6k] ------------------ 180| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 76| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 181| | 182| 21.6k| return ERROR_SUCCESS; ------------------ | | 40| 21.6k|#define ERROR_SUCCESS 0 ------------------ 183| 21.6k|} LLVMFuzzerInitialize: 37| 2|{ 38| 2| yr_initialize(); 39| 2| return 0; 40| 2|} LLVMFuzzerTestOneInput: 44| 1.27k|{ 45| 1.27k| YR_RULES* rules; 46| 1.27k| YR_COMPILER* compiler; 47| | 48| 1.27k| char* buffer = (char*) malloc(size + 1); 49| | 50| 1.27k| if (!buffer) ------------------ | Branch (50:7): [True: 0, False: 1.27k] ------------------ 51| 0| return 0; 52| | 53| 1.27k| strncpy(buffer, (const char*) data, size); 54| 1.27k| buffer[size] = 0; 55| | 56| 1.27k| if (yr_compiler_create(&compiler) != ERROR_SUCCESS) ------------------ | Branch (56:7): [True: 0, False: 1.27k] ------------------ 57| 0| { 58| 0| free(buffer); 59| 0| return 0; 60| 0| } 61| | 62| 1.27k| if (yr_compiler_add_string(compiler, (const char*) buffer, NULL) == 0) ------------------ | Branch (62:7): [True: 132, False: 1.13k] ------------------ 63| 132| { 64| 132| if (yr_compiler_get_rules(compiler, &rules) == ERROR_SUCCESS) ------------------ | Branch (64:9): [True: 132, False: 0] ------------------ 65| 132| yr_rules_destroy(rules); 66| 132| } 67| | 68| 1.27k| yr_compiler_destroy(compiler); 69| 1.27k| free(buffer); 70| | 71| 1.27k| return 0; 72| 1.27k|}