yr_ac_automaton_create: 732| 1|{ 733| 1| YR_AC_AUTOMATON* new_automaton; 734| 1| YR_AC_STATE* root_state; 735| | 736| 1| new_automaton = (YR_AC_AUTOMATON*) yr_malloc(sizeof(YR_AC_AUTOMATON)); 737| 1| root_state = (YR_AC_STATE*) yr_malloc(sizeof(YR_AC_STATE)); 738| | 739| 1| if (new_automaton == NULL || root_state == NULL) ------------------ | Branch (739:7): [True: 0, False: 1] | Branch (739:32): [True: 0, False: 1] ------------------ 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| root_state->depth = 0; 748| 1| root_state->matches_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 1| (YR_ARENA_REF) \ | | 44| 1| { \ | | 45| 1| UINT32_MAX, UINT32_MAX \ | | 46| 1| } ------------------ 749| 1| root_state->failure = NULL; 750| 1| root_state->first_child = NULL; 751| 1| root_state->siblings = NULL; 752| 1| root_state->t_table_slot = 0; 753| | 754| 1| new_automaton->arena = arena; 755| 1| new_automaton->root = root_state; 756| 1| new_automaton->bitmask = NULL; 757| 1| new_automaton->tables_size = 0; 758| | 759| 1| *automaton = new_automaton; 760| | 761| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 762| 1|} yr_ac_automaton_destroy: 768| 1|{ 769| 1| _yr_ac_state_destroy(automaton->root); 770| | 771| 1| yr_free(automaton->bitmask); 772| 1| yr_free(automaton); 773| | 774| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 775| 1|} yr_ac_compile: 847| 1|{ 848| 1| FAIL_ON_ERROR(_yr_ac_create_failure_links(automaton)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 849| 1| FAIL_ON_ERROR(_yr_ac_optimize_failure_links(automaton)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 850| 1| FAIL_ON_ERROR(_yr_ac_build_transition_table(automaton)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 851| | 852| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 853| 1|} ahocorasick.c:_yr_ac_state_destroy: 196| 1|{ 197| 1| YR_AC_STATE* child_state = state->first_child; 198| | 199| 1| while (child_state != NULL) ------------------ | Branch (199:10): [True: 0, False: 1] ------------------ 200| 0| { 201| 0| YR_AC_STATE* next_child_state = child_state->siblings; 202| 0| _yr_ac_state_destroy(child_state); 203| 0| child_state = next_child_state; 204| 0| } 205| | 206| 1| yr_free(state); 207| | 208| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 209| 1|} ahocorasick.c:_yr_ac_create_failure_links: 218| 1|{ 219| 1| YR_AC_STATE* current_state; 220| 1| YR_AC_STATE* failure_state; 221| 1| YR_AC_STATE* temp_state; 222| 1| YR_AC_STATE* state; 223| 1| YR_AC_STATE* transition_state; 224| 1| YR_AC_STATE* root_state; 225| 1| YR_AC_MATCH* match; 226| | 227| 1| QUEUE queue; 228| | 229| 1| queue.head = NULL; 230| 1| queue.tail = NULL; 231| | 232| 1| root_state = automaton->root; 233| | 234| | // Set the failure link of root state to itself. 235| 1| root_state->failure = root_state; 236| | 237| | // Push root's children and set their failure link to root. 238| 1| state = root_state->first_child; 239| | 240| 1| while (state != NULL) ------------------ | Branch (240:10): [True: 0, False: 1] ------------------ 241| 0| { 242| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 243| 0| state->failure = root_state; 244| 0| state = state->siblings; 245| 0| } 246| | 247| | // Traverse the trie in BFS order calculating the failure link 248| | // for each state. 249| 1| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (249:10): [True: 0, False: 1] ------------------ 250| 0| { 251| 0| current_state = _yr_ac_queue_pop(&queue); 252| 0| match = yr_arena_ref_to_ptr(automaton->arena, ¤t_state->matches_ref); 253| | 254| 0| if (match != NULL) ------------------ | Branch (254:9): [True: 0, False: 0] ------------------ 255| 0| { 256| | // Find the last match in the list of matches. 257| 0| while (match->next != NULL) match = match->next; ------------------ | Branch (257:14): [True: 0, False: 0] ------------------ 258| | 259| 0| if (match->backtrack > 0) ------------------ | Branch (259:11): [True: 0, False: 0] ------------------ 260| 0| match->next = yr_arena_ref_to_ptr( 261| 0| automaton->arena, &root_state->matches_ref); 262| 0| } 263| 0| else 264| 0| { 265| | // This state doesn't have any matches, its matches will be those 266| | // in the root state, if any. 267| 0| current_state->matches_ref = root_state->matches_ref; 268| 0| } 269| | 270| | // Iterate over all the states that the current state can transition to. 271| 0| transition_state = current_state->first_child; 272| | 273| 0| while (transition_state != NULL) ------------------ | Branch (273:12): [True: 0, False: 0] ------------------ 274| 0| { 275| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, transition_state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 276| 0| failure_state = current_state->failure; 277| | 278| 0| while (1) ------------------ | Branch (278:14): [True: 0, Folded] ------------------ 279| 0| { 280| 0| temp_state = _yr_ac_next_state(failure_state, transition_state->input); 281| | 282| 0| if (temp_state != NULL) ------------------ | Branch (282:13): [True: 0, False: 0] ------------------ 283| 0| { 284| 0| transition_state->failure = temp_state; 285| | 286| 0| if (YR_ARENA_IS_NULL_REF(transition_state->matches_ref)) ------------------ | | 49| 0| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | | Branch (49:3): [True: 0, False: 0] | | ------------------ ------------------ 287| 0| { 288| 0| transition_state->matches_ref = temp_state->matches_ref; 289| 0| } 290| 0| else 291| 0| { 292| 0| match = yr_arena_ref_to_ptr( 293| 0| automaton->arena, &transition_state->matches_ref); 294| | 295| 0| assert(match != NULL); ------------------ | Branch (295:13): [True: 0, False: 0] | Branch (295:13): [True: 0, False: 0] ------------------ 296| | 297| | // Find the last match in the list of matches. 298| 0| while (match->next != NULL) match = match->next; ------------------ | Branch (298:20): [True: 0, False: 0] ------------------ 299| | 300| 0| match->next = yr_arena_ref_to_ptr( 301| 0| automaton->arena, &temp_state->matches_ref); 302| 0| } 303| | 304| 0| break; 305| 0| } 306| 0| else 307| 0| { 308| 0| if (failure_state == root_state) ------------------ | Branch (308:15): [True: 0, False: 0] ------------------ 309| 0| { 310| 0| transition_state->failure = root_state; 311| 0| break; 312| 0| } 313| 0| else 314| 0| { 315| 0| failure_state = failure_state->failure; 316| 0| } 317| 0| } 318| 0| } // while(1) 319| | 320| 0| transition_state = transition_state->siblings; 321| 0| } 322| | 323| 0| } // while(!__yr_ac_queue_is_empty(&queue)) 324| | 325| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 326| 1|} ahocorasick.c:_yr_ac_queue_is_empty: 131| 3|{ 132| | return queue->head == NULL; 133| 3|} ahocorasick.c:_yr_ac_optimize_failure_links: 364| 1|{ 365| 1| QUEUE queue = {NULL, NULL}; 366| | 367| | // Push root's children. 368| 1| YR_AC_STATE* root_state = automaton->root; 369| 1| YR_AC_STATE* state = root_state->first_child; 370| | 371| 1| while (state != NULL) ------------------ | Branch (371:10): [True: 0, False: 1] ------------------ 372| 0| { 373| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 374| 0| state = state->siblings; 375| 0| } 376| | 377| 1| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (377:10): [True: 0, False: 1] ------------------ 378| 0| { 379| 0| YR_AC_STATE* current_state = _yr_ac_queue_pop(&queue); 380| | 381| 0| if (current_state->failure != root_state) ------------------ | Branch (381:9): [True: 0, False: 0] ------------------ 382| 0| { 383| 0| if (_yr_ac_transitions_subset(current_state, current_state->failure)) ------------------ | Branch (383:11): [True: 0, False: 0] ------------------ 384| 0| current_state->failure = current_state->failure->failure; 385| 0| } 386| | 387| | // Push children of current_state 388| 0| state = current_state->first_child; 389| | 390| 0| while (state != NULL) ------------------ | Branch (390:12): [True: 0, False: 0] ------------------ 391| 0| { 392| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 393| 0| state = state->siblings; 394| 0| } 395| 0| } 396| | 397| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 398| 1|} ahocorasick.c:_yr_ac_build_transition_table: 526| 1|{ 527| 1| YR_AC_TRANSITION* t_table; 528| 1| uint32_t* m_table; 529| 1| YR_AC_STATE* state; 530| 1| YR_AC_STATE* child_state; 531| 1| YR_AC_STATE* root_state = automaton->root; 532| | 533| 1| uint32_t slot; 534| | 535| 1| 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| 1| automaton->tables_size = 512; 540| | 541| 1| automaton->bitmask = yr_calloc( 542| 1| YR_BITMASK_SIZE(automaton->tables_size), sizeof(YR_BITMASK)); ------------------ | | 57| 1|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 543| | 544| 1| if (automaton->bitmask == NULL) ------------------ | Branch (544:7): [True: 0, False: 1] ------------------ 545| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 546| | 547| 1| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 548| 1| automaton->arena, 549| 1| YR_AC_TRANSITION_TABLE, 550| 1| automaton->tables_size * sizeof(YR_AC_TRANSITION), 551| 1| NULL)); 552| | 553| 1| FAIL_ON_ERROR(yr_arena_allocate_zeroed_memory( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 554| 1| automaton->arena, 555| 1| YR_AC_STATE_MATCHES_TABLE, 556| 1| automaton->tables_size * sizeof(uint32_t), 557| 1| NULL)); 558| | 559| 1| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 1|#define YR_AC_TRANSITION_TABLE 8 ------------------ 560| 1| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 1|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 561| | 562| | // The failure link for the root node points to itself. 563| 1| t_table[0] = YR_AC_MAKE_TRANSITION(0, 0); ------------------ | | 50| 1| ((YR_AC_TRANSITION)( \ | | 51| 1| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 1|#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| 1| if (!YR_ARENA_IS_NULL_REF(root_state->matches_ref)) ------------------ | | 49| 1| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 1| (YR_ARENA_REF) \ | | | | 44| 1| { \ | | | | 45| 1| UINT32_MAX, UINT32_MAX \ | | | | 46| 1| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 1| (YR_ARENA_REF) \ | | | | 44| 1| { \ | | | | 45| 1| UINT32_MAX, UINT32_MAX \ | | | | 46| 1| } | | ------------------ ------------------ | Branch (570:7): [True: 0, False: 1] ------------------ 571| 0| 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| 1| yr_bitmask_set(automaton->bitmask, 0); ------------------ | | 60| 1| do \ | | 61| 1| { \ | | 62| 1| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 1|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 1|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 1| } while (0) | | ------------------ | | | Branch (63:12): [Folded, False: 1] | | ------------------ ------------------ 575| | 576| | // Index 0 is for root node. Unused indexes start at 1. 577| 1| automaton->t_table_unused_candidate = 1; 578| | 579| 1| child_state = root_state->first_child; 580| | 581| 1| while (child_state != NULL) ------------------ | Branch (581:10): [True: 0, False: 1] ------------------ 582| 0| { 583| | // Each state stores its slot number. 584| 0| child_state->t_table_slot = child_state->input + 1; 585| | 586| 0| t_table[child_state->input + 1] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 0| ((YR_AC_TRANSITION)( \ | | 51| 0| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 0|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 587| 0| 0, child_state->input + 1); 588| | 589| 0| yr_bitmask_set(automaton->bitmask, child_state->input + 1); ------------------ | | 60| 0| do \ | | 61| 0| { \ | | 62| 0| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 0| } while (0) | | ------------------ | | | Branch (63:12): [Folded, False: 0] | | ------------------ ------------------ 590| | 591| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 592| 0| child_state = child_state->siblings; 593| 0| } 594| | 595| 1| while (!_yr_ac_queue_is_empty(&queue)) ------------------ | Branch (595:10): [True: 0, False: 1] ------------------ 596| 0| { 597| 0| state = _yr_ac_queue_pop(&queue); 598| | 599| 0| FAIL_ON_ERROR(_yr_ac_find_suitable_transition_table_slot( ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 600| 0| 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| 0| t_table = yr_arena_get_ptr(automaton->arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 0|#define YR_AC_TRANSITION_TABLE 8 ------------------ 606| 0| m_table = yr_arena_get_ptr(automaton->arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 0|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 607| | 608| 0| t_table[state->t_table_slot] |= (slot << YR_AC_SLOT_OFFSET_BITS); ------------------ | | 39| 0|#define YR_AC_SLOT_OFFSET_BITS 9 ------------------ 609| 0| t_table[slot] = YR_AC_MAKE_TRANSITION(state->failure->t_table_slot, 0); ------------------ | | 50| 0| ((YR_AC_TRANSITION)( \ | | 51| 0| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 0|#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| 0| if (YR_ARENA_IS_NULL_REF(state->matches_ref)) ------------------ | | 49| 0| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | | Branch (49:3): [True: 0, False: 0] | | ------------------ ------------------ 616| 0| m_table[slot] = 0; 617| 0| else 618| 0| m_table[slot] = state->matches_ref.offset / sizeof(YR_AC_MATCH) + 1; 619| | 620| 0| state->t_table_slot = slot; 621| | 622| 0| yr_bitmask_set(automaton->bitmask, slot); ------------------ | | 60| 0| do \ | | 61| 0| { \ | | 62| 0| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 0| } while (0) | | ------------------ | | | Branch (63:12): [Folded, False: 0] | | ------------------ ------------------ 623| | 624| | // Push children of current_state 625| 0| child_state = state->first_child; 626| | 627| 0| while (child_state != NULL) ------------------ | Branch (627:12): [True: 0, False: 0] ------------------ 628| 0| { 629| 0| child_state->t_table_slot = slot + child_state->input + 1; 630| | 631| 0| t_table[child_state->t_table_slot] = YR_AC_MAKE_TRANSITION( ------------------ | | 50| 0| ((YR_AC_TRANSITION)( \ | | 51| 0| (((YR_AC_TRANSITION) state) << YR_AC_SLOT_OFFSET_BITS) | (code))) | | ------------------ | | | | 39| 0|#define YR_AC_SLOT_OFFSET_BITS 9 | | ------------------ ------------------ 632| 0| 0, child_state->input + 1); 633| | 634| 0| yr_bitmask_set(automaton->bitmask, child_state->t_table_slot); ------------------ | | 60| 0| do \ | | 61| 0| { \ | | 62| 0| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 0| } while (0) | | ------------------ | | | Branch (63:12): [Folded, False: 0] | | ------------------ ------------------ 635| | 636| 0| FAIL_ON_ERROR(_yr_ac_queue_push(&queue, child_state)); ------------------ | | 134| 0| { \ | | 135| 0| int __error = (x); \ | | 136| 0| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 0] | | ------------------ | | 137| 0| return __error; \ | | 138| 0| } ------------------ 637| | 638| 0| child_state = child_state->siblings; 639| 0| } 640| 0| } 641| | 642| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 643| 1|} yr_arena_create: 237| 1|{ 238| 1| YR_ARENA* new_arena = (YR_ARENA*) yr_calloc(1, sizeof(YR_ARENA)); 239| | 240| 1| if (new_arena == NULL) ------------------ | Branch (240:7): [True: 0, False: 1] ------------------ 241| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 242| | 243| 1| new_arena->xrefs = 1; 244| 1| new_arena->num_buffers = num_buffers; 245| 1| new_arena->initial_buffer_size = initial_buffer_size; 246| | 247| 1| *arena = new_arena; 248| | 249| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 250| 1|} yr_arena_acquire: 253| 1|{ 254| 1| arena->xrefs++; 255| 1|} yr_arena_release: 272| 1|{ 273| 1| arena->xrefs--; 274| | 275| 1| if (arena->xrefs > 0) ------------------ | Branch (275:7): [True: 1, False: 0] ------------------ 276| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 277| | 278| 0| for (uint32_t i = 0; i < arena->num_buffers; i++) ------------------ | Branch (278:24): [True: 0, False: 0] ------------------ 279| 0| { 280| 0| if (arena->buffers[i].data != NULL) ------------------ | Branch (280:9): [True: 0, False: 0] ------------------ 281| 0| yr_free(arena->buffers[i].data); 282| 0| } 283| | 284| 0| YR_RELOC* reloc = arena->reloc_list_head; 285| | 286| 0| while (reloc != NULL) ------------------ | Branch (286:10): [True: 0, False: 0] ------------------ 287| 0| { 288| 0| YR_RELOC* next = reloc->next; 289| 0| yr_free(reloc); 290| 0| reloc = next; 291| 0| } 292| | 293| 0| yr_free(arena); 294| | 295| 0| return ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 296| 1|} yr_arena_allocate_zeroed_memory: 342| 2|{ 343| 2| return _yr_arena_allocate_memory( 344| 2| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, ref); ------------------ | | 114| 2|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 345| 2|} yr_arena_allocate_struct: 386| 2|{ 387| 2| YR_ARENA_REF r; 388| | 389| 2| int result = _yr_arena_allocate_memory( 390| 2| arena, YR_ARENA_ZERO_MEMORY, buffer_id, size, &r); ------------------ | | 114| 2|#define YR_ARENA_ZERO_MEMORY 1 ------------------ 391| | 392| 2| if (result != ERROR_SUCCESS) ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ | Branch (392:7): [True: 0, False: 2] ------------------ 393| 0| return result; 394| | 395| 2| va_list field_offsets; 396| 2| va_start(field_offsets, ref); 397| | 398| 2| result = _yr_arena_make_ptr_relocatable( 399| 2| arena, buffer_id, r.offset, field_offsets); 400| | 401| 2| va_end(field_offsets); 402| | 403| 2| if (result == ERROR_SUCCESS && ref != NULL) ------------------ | | 40| 4|#define ERROR_SUCCESS 0 ------------------ | Branch (403:7): [True: 2, False: 0] | Branch (403:34): [True: 2, False: 0] ------------------ 404| 2| { 405| 2| ref->buffer_id = r.buffer_id; 406| 2| ref->offset = r.offset; 407| 2| } 408| | 409| 2| return result; 410| 2|} yr_arena_get_ptr: 416| 16|{ 417| 16| assert(buffer_id < arena->num_buffers); ------------------ | Branch (417:3): [True: 0, False: 16] | Branch (417:3): [True: 16, False: 0] ------------------ 418| 16| assert(offset <= arena->buffers[buffer_id].used); ------------------ | Branch (418:3): [True: 0, False: 16] | Branch (418:3): [True: 16, False: 0] ------------------ 419| | 420| 16| if (arena->buffers[buffer_id].data == NULL) ------------------ | Branch (420:7): [True: 3, False: 13] ------------------ 421| 3| return NULL; 422| | 423| 13| return arena->buffers[buffer_id].data + offset; 424| 16|} yr_arena_ref_to_ptr: 463| 4|{ 464| 4| if (YR_ARENA_IS_NULL_REF(*ref)) ------------------ | | 49| 4| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 4| (YR_ARENA_REF) \ | | | | 44| 4| { \ | | | | 45| 4| UINT32_MAX, UINT32_MAX \ | | | | 46| 4| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 4| (YR_ARENA_REF) \ | | | | 44| 4| { \ | | | | 45| 4| UINT32_MAX, UINT32_MAX \ | | | | 46| 4| } | | ------------------ | | | Branch (49:3): [True: 0, False: 4] | | ------------------ ------------------ 465| 0| 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| 4| return yr_arena_get_ptr(arena, ref->buffer_id, ref->offset); 474| 4|} yr_arena_make_ptr_relocatable: 488| 1|{ 489| 1| int result; 490| | 491| 1| va_list offsets; 492| 1| va_start(offsets, buffer_id); 493| | 494| 1| result = _yr_arena_make_ptr_relocatable(arena, buffer_id, 0, offsets); 495| | 496| 1| va_end(offsets); 497| | 498| 1| return result; 499| 1|} yr_arena_write_data: 507| 7|{ 508| 7| YR_ARENA_REF r; 509| | 510| | // Allocate space in the buffer. 511| 7| FAIL_ON_ERROR(_yr_arena_allocate_memory(arena, 0, buffer_id, size, &r)); ------------------ | | 134| 7| { \ | | 135| 7| int __error = (x); \ | | 136| 7| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 7|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 7] | | ------------------ | | 137| 7| return __error; \ | | 138| 7| } ------------------ 512| | 513| | // Copy the data into the allocated space. 514| 7| memcpy(arena->buffers[buffer_id].data + r.offset, data, size); 515| | 516| 7| if (ref != NULL) ------------------ | Branch (516:7): [True: 3, False: 4] ------------------ 517| 3| { 518| 3| ref->buffer_id = r.buffer_id; 519| 3| ref->offset = r.offset; 520| 3| } 521| | 522| 7| return ERROR_SUCCESS; ------------------ | | 40| 7|#define ERROR_SUCCESS 0 ------------------ 523| 7|} arena.c:_yr_arena_allocate_memory: 138| 11|{ 139| 11| if (buffer_id > arena->num_buffers) ------------------ | Branch (139:7): [True: 0, False: 11] ------------------ 140| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 141| | 142| 11| 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| 11| if (b->size - b->used < size) ------------------ | Branch (148:7): [True: 8, False: 3] ------------------ 149| 8| { 150| 8| size_t new_size = (b->size == 0) ? arena->initial_buffer_size : b->size * 2; ------------------ | Branch (150:23): [True: 8, False: 0] ------------------ 151| | 152| 8| while (new_size < b->used + size) new_size *= 2; ------------------ | Branch (152:12): [True: 0, False: 8] ------------------ 153| | 154| | // Make sure that buffer size if not larger than 4GB. 155| 8| if (new_size > 1ULL << 32) ------------------ | Branch (155:9): [True: 0, False: 8] ------------------ 156| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 157| | 158| 8| uint8_t* new_data = yr_realloc(b->data, new_size); 159| | 160| 8| if (new_data == NULL) ------------------ | Branch (160:9): [True: 0, False: 8] ------------------ 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| 8|#if !defined(_WIN32) && !defined(__CYGWIN__) 167| 8| if (flags & YR_ARENA_ZERO_MEMORY) ------------------ | | 114| 8|#define YR_ARENA_ZERO_MEMORY 1 ------------------ | Branch (167:9): [True: 4, False: 4] ------------------ 168| 4| memset(new_data + b->used, 0, new_size - b->used); 169| 8|#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| 8| if (b->data != NULL && b->data != new_data) ------------------ | Branch (173:9): [True: 0, False: 8] | Branch (173:28): [True: 0, False: 0] ------------------ 174| 0| { 175| 0| YR_RELOC* reloc = arena->reloc_list_head; 176| | 177| 0| while (reloc != NULL) ------------------ | Branch (177:14): [True: 0, False: 0] ------------------ 178| 0| { 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| 0| uint8_t* base = buffer_id == reloc->buffer_id ------------------ | Branch (183:25): [True: 0, False: 0] ------------------ 184| 0| ? new_data 185| 0| : 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| 0| void** reloc_address = (void**) (base + reloc->offset); 190| | 191| | // reloc_target is the value of the relocatable pointer. 192| 0| void* reloc_target = *reloc_address; 193| | 194| 0| if ((uint8_t*) reloc_target >= b->data && ------------------ | Branch (194:13): [True: 0, False: 0] ------------------ 195| 0| (uint8_t*) reloc_target < b->data + b->used) ------------------ | Branch (195:13): [True: 0, False: 0] ------------------ 196| 0| { 197| | // reloc_target points to some data inside the buffer being moved, so 198| | // the pointer needs to be adjusted. 199| 0| *reloc_address = (uint8_t*) reloc_target - b->data + new_data; 200| 0| } 201| | 202| 0| reloc = reloc->next; 203| 0| } 204| 0| } 205| | 206| 8| b->size = new_size; 207| 8| b->data = new_data; 208| 8| } 209| | 210| 11| if (ref != NULL) ------------------ | Branch (210:7): [True: 9, False: 2] ------------------ 211| 9| { 212| 9| ref->buffer_id = buffer_id; 213| 9| ref->offset = (uint32_t) b->used; 214| 9| } 215| | 216| 11| b->used += size; 217| | 218| 11| return ERROR_SUCCESS; ------------------ | | 40| 11|#define ERROR_SUCCESS 0 ------------------ 219| 11|} arena.c:_yr_arena_make_ptr_relocatable: 80| 3|{ 81| 3| size_t offset; 82| | 83| 3| int result = ERROR_SUCCESS; ------------------ | | 40| 3|#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| 3| offset = va_arg(offsets, size_t); 88| | 89| 5| while (offset != EOL) ------------------ | | 38| 5|#define EOL ((size_t) -1) ------------------ | Branch (89:10): [True: 2, False: 3] ------------------ 90| 2| { 91| 2| YR_RELOC* reloc = (YR_RELOC*) yr_malloc(sizeof(YR_RELOC)); 92| | 93| 2| if (reloc == NULL) ------------------ | Branch (93:9): [True: 0, False: 2] ------------------ 94| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 95| | 96| 2| reloc->buffer_id = buffer_id; 97| 2| reloc->offset = base_offset + (yr_arena_off_t) offset; 98| 2| reloc->next = NULL; 99| | 100| 2| if (arena->reloc_list_head == NULL) ------------------ | Branch (100:9): [True: 1, False: 1] ------------------ 101| 1| arena->reloc_list_head = reloc; 102| | 103| 2| if (arena->reloc_list_tail != NULL) ------------------ | Branch (103:9): [True: 1, False: 1] ------------------ 104| 1| arena->reloc_list_tail->next = reloc; 105| | 106| 2| arena->reloc_list_tail = reloc; 107| 2| offset = va_arg(offsets, size_t); 108| 2| } 109| | 110| 3| return result; 111| 3|} _yr_compiler_store_data: 177| 2|{ 178| | // Check if the data is already in YR_SZ_POOL by using a hash table. 179| 2| uint32_t offset = yr_hash_table_lookup_uint32_raw_key( 180| 2| compiler->sz_table, data, data_length, NULL); 181| | 182| 2| if (offset == UINT32_MAX) ------------------ | Branch (182:7): [True: 2, False: 0] ------------------ 183| 2| { 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| 2| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 188| 2| compiler->arena, YR_SZ_POOL, data, data_length, ref)); 189| | 190| 2| FAIL_ON_ERROR(yr_hash_table_add_uint32_raw_key( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 191| 2| compiler->sz_table, data, data_length, NULL, ref->offset)); 192| 2| } 193| 0| else 194| 0| { 195| 0| ref->buffer_id = YR_SZ_POOL; ------------------ | | 62| 0|#define YR_SZ_POOL 5 ------------------ 196| 0| ref->offset = offset; 197| 0| } 198| | 199| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 200| 2|} _yr_compiler_store_string: 209| 2|{ 210| 2| return _yr_compiler_store_data( 211| 2| compiler, 212| 2| (void*) string, 213| 2| strlen(string) + 1, // include the null terminator 214| 2| ref); 215| 2|} yr_compiler_create: 218| 1|{ 219| 1| int result; 220| 1| YR_COMPILER* new_compiler; 221| | 222| 1| new_compiler = (YR_COMPILER*) yr_calloc(1, sizeof(YR_COMPILER)); 223| | 224| 1| if (new_compiler == NULL) ------------------ | Branch (224:7): [True: 0, False: 1] ------------------ 225| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 226| | 227| 1| new_compiler->current_rule_idx = UINT32_MAX; 228| 1| new_compiler->next_rule_idx = 0; 229| 1| new_compiler->current_string_idx = 0; 230| 1| new_compiler->current_namespace_idx = 0; 231| 1| new_compiler->current_meta_idx = 0; 232| 1| new_compiler->num_namespaces = 0; 233| 1| new_compiler->errors = 0; 234| 1| new_compiler->callback = NULL; 235| 1| new_compiler->rules = NULL; 236| 1| new_compiler->include_callback = _yr_compiler_default_include_callback; 237| 1| new_compiler->incl_clbk_user_data = NULL; 238| 1| new_compiler->include_free = _yr_compiler_default_include_free; 239| 1| new_compiler->re_ast_callback = NULL; 240| 1| new_compiler->re_ast_clbk_user_data = NULL; 241| 1| new_compiler->last_error = ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 242| 1| new_compiler->last_error_line = 0; 243| 1| new_compiler->strict_escape = false; 244| 1| new_compiler->current_line = 0; 245| 1| new_compiler->file_name_stack_ptr = 0; 246| 1| new_compiler->fixup_stack_head = NULL; 247| 1| new_compiler->loop_index = -1; 248| 1| new_compiler->loop_for_of_var_index = -1; 249| | 250| 1| new_compiler->atoms_config.get_atom_quality = yr_atoms_heuristic_quality; 251| 1| new_compiler->atoms_config.quality_warning_threshold = 252| 1| YR_ATOM_QUALITY_WARNING_THRESHOLD; ------------------ | | 84| 1| YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 71| 1|#define YR_MAX_ATOM_QUALITY 255 | | ------------------ | | YR_MAX_ATOM_QUALITY - 22 * YR_MAX_ATOM_LENGTH + 38 | | ------------------ | | | | 67| 1|#define YR_MAX_ATOM_LENGTH 4 | | ------------------ ------------------ 253| | 254| 1| result = yr_hash_table_create(5000, &new_compiler->rules_table); 255| | 256| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (256:7): [True: 1, False: 0] ------------------ 257| 1| result = yr_hash_table_create(1000, &new_compiler->objects_table); 258| | 259| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (259:7): [True: 1, False: 0] ------------------ 260| 1| result = yr_hash_table_create(10000, &new_compiler->strings_table); 261| | 262| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (262:7): [True: 1, False: 0] ------------------ 263| 1| result = yr_hash_table_create( 264| 1| 1000, &new_compiler->wildcard_identifiers_table); 265| | 266| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (266:7): [True: 1, False: 0] ------------------ 267| 1| result = yr_hash_table_create(10000, &new_compiler->sz_table); 268| | 269| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (269:7): [True: 1, False: 0] ------------------ 270| 1| result = yr_arena_create(YR_NUM_SECTIONS, 1048576, &new_compiler->arena); ------------------ | | 72| 1|#define YR_NUM_SECTIONS 12 ------------------ 271| | 272| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (272:7): [True: 1, False: 0] ------------------ 273| 1| result = yr_ac_automaton_create( 274| 1| new_compiler->arena, &new_compiler->automaton); 275| | 276| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (276:7): [True: 1, False: 0] ------------------ 277| 1| { 278| 1| *compiler = new_compiler; 279| 1| } 280| 0| else // if error, do cleanup 281| 0| { 282| 0| yr_compiler_destroy(new_compiler); 283| 0| } 284| | 285| 1| return result; 286| 1|} yr_compiler_destroy: 289| 1|{ 290| 1| if (compiler->arena != NULL) ------------------ | Branch (290:7): [True: 1, False: 0] ------------------ 291| 1| yr_arena_release(compiler->arena); 292| | 293| 1| if (compiler->automaton != NULL) ------------------ | Branch (293:7): [True: 1, False: 0] ------------------ 294| 1| yr_ac_automaton_destroy(compiler->automaton); 295| | 296| 1| if (compiler->rules_table != NULL) ------------------ | Branch (296:7): [True: 1, False: 0] ------------------ 297| 1| yr_hash_table_destroy(compiler->rules_table, NULL); 298| | 299| 1| if (compiler->strings_table != NULL) ------------------ | Branch (299:7): [True: 1, False: 0] ------------------ 300| 1| yr_hash_table_destroy(compiler->strings_table, NULL); 301| | 302| 1| if (compiler->wildcard_identifiers_table != NULL) ------------------ | Branch (302:7): [True: 1, False: 0] ------------------ 303| 1| yr_hash_table_destroy(compiler->wildcard_identifiers_table, NULL); 304| | 305| 1| if (compiler->sz_table != NULL) ------------------ | Branch (305:7): [True: 1, False: 0] ------------------ 306| 1| yr_hash_table_destroy(compiler->sz_table, NULL); 307| | 308| 1| if (compiler->objects_table != NULL) ------------------ | Branch (308:7): [True: 1, False: 0] ------------------ 309| 1| yr_hash_table_destroy( 310| 1| compiler->objects_table, 311| 1| (YR_HASH_TABLE_FREE_VALUE_FUNC) yr_object_destroy); 312| | 313| 1| if (compiler->atoms_config.free_quality_table) ------------------ | Branch (313:7): [True: 0, False: 1] ------------------ 314| 0| yr_free(compiler->atoms_config.quality_table); 315| | 316| 1| for (int i = 0; i < compiler->file_name_stack_ptr; i++) ------------------ | Branch (316:19): [True: 0, False: 1] ------------------ 317| 0| yr_free(compiler->file_name_stack[i]); 318| | 319| 1| YR_FIXUP* fixup = compiler->fixup_stack_head; 320| | 321| 1| while (fixup != NULL) ------------------ | Branch (321:10): [True: 0, False: 1] ------------------ 322| 0| { 323| 0| YR_FIXUP* next_fixup = fixup->next; 324| 0| yr_free(fixup); 325| 0| fixup = next_fixup; 326| 0| } 327| | 328| 1| yr_free(compiler); 329| 1|} yr_compiler_add_string: 662| 1|{ 663| | // Don't allow calls to yr_compiler_add_string() after 664| | // yr_compiler_get_rules() has been called. 665| 1| assert(compiler->rules == NULL); ------------------ | Branch (665:3): [True: 0, False: 1] | Branch (665:3): [True: 1, False: 0] ------------------ 666| | 667| | // Don't allow calls to yr_compiler_add_string() if a previous call to 668| | // yr_compiler_add_XXXX failed. 669| 1| assert(compiler->errors == 0); ------------------ | Branch (669:3): [True: 0, False: 1] | Branch (669:3): [True: 1, False: 0] ------------------ 670| | 671| 1| if (namespace_ != NULL) ------------------ | Branch (671:7): [True: 0, False: 1] ------------------ 672| 0| compiler->last_error = _yr_compiler_set_namespace(compiler, namespace_); 673| 1| else 674| 1| compiler->last_error = _yr_compiler_set_namespace(compiler, "default"); 675| | 676| 1| if (compiler->last_error != ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (676:7): [True: 0, False: 1] ------------------ 677| 0| return ++compiler->errors; 678| | 679| 1| return yr_lex_parse_rules_string(rules_string, compiler); 680| 1|} yr_compiler_get_rules: 730| 1|{ 731| | // Don't allow calls to yr_compiler_get_rules() if a previous call to 732| | // yr_compiler_add_XXXX failed. 733| 1| assert(compiler->errors == 0); ------------------ | Branch (733:3): [True: 0, False: 1] | Branch (733:3): [True: 1, False: 0] ------------------ 734| | 735| 1| *rules = NULL; 736| | 737| 1| if (compiler->rules == NULL) ------------------ | Branch (737:7): [True: 1, False: 0] ------------------ 738| 1| FAIL_ON_ERROR(_yr_compiler_compile_rules(compiler)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 739| | 740| 1| *rules = compiler->rules; 741| | 742| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 743| 1|} compiler.c:_yr_compiler_set_namespace: 519| 1|{ 520| 1| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 521| 1| compiler->arena, YR_NAMESPACES_TABLE, 0); ------------------ | | 57| 1|#define YR_NAMESPACES_TABLE 0 ------------------ 522| | 523| 1| bool found = false; 524| | 525| 1| for (int i = 0; i < compiler->num_namespaces; i++, ns++) ------------------ | Branch (525:19): [True: 0, False: 1] ------------------ 526| 0| { 527| 0| if (strcmp(ns->name, namespace_) == 0) ------------------ | Branch (527:9): [True: 0, False: 0] ------------------ 528| 0| { 529| 0| found = true; 530| 0| compiler->current_namespace_idx = i; 531| 0| break; 532| 0| } 533| 0| } 534| | 535| 1| if (!found) ------------------ | Branch (535:7): [True: 1, False: 0] ------------------ 536| 1| { 537| 1| YR_ARENA_REF ref; 538| | 539| 1| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 540| 1| compiler->arena, 541| 1| YR_NAMESPACES_TABLE, 542| 1| sizeof(YR_NAMESPACE), 543| 1| &ref, 544| 1| offsetof(YR_NAMESPACE, name), 545| 1| EOL)); 546| | 547| 1| ns = (YR_NAMESPACE*) yr_arena_ref_to_ptr(compiler->arena, &ref); 548| | 549| 1| FAIL_ON_ERROR(_yr_compiler_store_string(compiler, namespace_, &ref)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 550| | 551| 1| ns->name = (const char*) yr_arena_ref_to_ptr(compiler->arena, &ref); 552| 1| ns->idx = compiler->num_namespaces; 553| | 554| 1| compiler->current_namespace_idx = compiler->num_namespaces; 555| 1| compiler->num_namespaces++; 556| 1| } 557| | 558| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 559| 1|} compiler.c:_yr_compiler_compile_rules: 683| 1|{ 684| 1| YR_RULE null_rule; 685| 1| YR_EXTERNAL_VARIABLE null_external; 686| | 687| 1| uint8_t halt = OP_HALT; ------------------ | | 46| 1|#define OP_HALT 255 ------------------ 688| | 689| | // Write halt instruction at the end of code. 690| 1| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 691| 1| compiler->arena, YR_CODE_SECTION, &halt, sizeof(uint8_t), NULL)); 692| | 693| | // Write a null rule indicating the end. 694| 1| memset(&null_rule, 0xFA, sizeof(YR_RULE)); 695| 1| null_rule.flags = RULE_FLAGS_NULL; ------------------ | | 54| 1|#define RULE_FLAGS_NULL 0x04 ------------------ 696| | 697| 1| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 698| 1| compiler->arena, YR_RULES_TABLE, &null_rule, sizeof(YR_RULE), NULL)); 699| | 700| | // Write a null external indicating the end. 701| 1| memset(&null_external, 0xFA, sizeof(YR_EXTERNAL_VARIABLE)); 702| 1| null_external.type = EXTERNAL_VARIABLE_TYPE_NULL; ------------------ | | 144| 1|#define EXTERNAL_VARIABLE_TYPE_NULL 0 ------------------ 703| | 704| 1| FAIL_ON_ERROR(yr_arena_write_data( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 705| 1| compiler->arena, 706| 1| YR_EXTERNAL_VARIABLES_TABLE, 707| 1| &null_external, 708| 1| sizeof(YR_EXTERNAL_VARIABLE), 709| 1| NULL)); 710| | 711| | // Write Aho-Corasick automaton to arena. 712| 1| FAIL_ON_ERROR(yr_ac_compile(compiler->automaton, compiler->arena)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 713| | 714| 1| YR_ARENA_REF ref; 715| | 716| 1| FAIL_ON_ERROR(yr_arena_allocate_struct( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 717| 1| compiler->arena, YR_SUMMARY_SECTION, sizeof(YR_SUMMARY), &ref, EOL)); 718| | 719| 1| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_ref_to_ptr( 720| 1| compiler->arena, &ref); 721| | 722| 1| summary->num_namespaces = compiler->num_namespaces; 723| 1| summary->num_rules = compiler->next_rule_idx; 724| 1| summary->num_strings = compiler->current_string_idx; 725| | 726| 1| return yr_rules_from_arena(compiler->arena, &compiler->rules); 727| 1|} yara_yyparse: 1902| 1|{ 1903| |/* Lookahead token kind. */ 1904| 1|int yychar; 1905| | 1906| | 1907| |/* The semantic value of the lookahead symbol. */ 1908| |/* Default value used for initialization, for pacifying older GCCs 1909| | or non-GCC compilers. */ 1910| 1|YY_INITIAL_VALUE (static YYSTYPE yyval_default;) ------------------ | | 727| 1|# define YY_INITIAL_VALUE(Value) Value ------------------ 1911| 1|YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); ------------------ | | 727| 1|# define YY_INITIAL_VALUE(Value) Value ------------------ 1912| | 1913| | /* Number of syntax errors so far. */ 1914| 1| int yynerrs = 0; 1915| | 1916| 1| yy_state_fast_t yystate = 0; 1917| | /* Number of tokens to shift before error messages enabled. */ 1918| 1| int yyerrstatus = 0; 1919| | 1920| | /* Refer to the stacks through separate pointers, to allow yyoverflow 1921| | to reallocate them elsewhere. */ 1922| | 1923| | /* Their size. */ 1924| 1| YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 634| 1|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ YYPTRDIFF_T yystacksize = YYINITDEPTH; ------------------ | | 1473| 1|# define YYINITDEPTH 200 ------------------ 1925| | 1926| | /* The state stack: array, bottom, top. */ 1927| 1| yy_state_t yyssa[YYINITDEPTH]; 1928| 1| yy_state_t *yyss = yyssa; 1929| 1| yy_state_t *yyssp = yyss; 1930| | 1931| | /* The semantic value stack: array, bottom, top. */ 1932| 1| YYSTYPE yyvsa[YYINITDEPTH]; 1933| 1| YYSTYPE *yyvs = yyvsa; 1934| 1| YYSTYPE *yyvsp = yyvs; 1935| | 1936| 1| int yyn; 1937| | /* The return value of yyparse. */ 1938| 1| int yyresult; 1939| | /* Lookahead symbol kind. */ 1940| 1| yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 1941| | /* The variables used to return semantic value and location from the 1942| | action routines. */ 1943| 1| YYSTYPE yyval; 1944| | 1945| | /* Buffer for error messages, and its allocated size. */ 1946| 1| char yymsgbuf[128]; 1947| 1| char *yymsg = yymsgbuf; 1948| 1| YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; ------------------ | | 634| 1|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1949| | 1950| 1|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1951| | 1952| | /* The number of symbols on the RHS of the reduced rule. 1953| | Keep to zero when no symbol should be popped. */ 1954| 1| int yylen = 0; 1955| | 1956| 1| YYDPRINTF ((stderr, "Starting parse\n")); ------------------ | | 1464| 1|# define YYDPRINTF(Args) ((void) 0) ------------------ 1957| | 1958| 1| yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 51| 1|#define yychar yara_yychar ------------------ yychar = YYEMPTY; /* Cause a token to be read. */ ------------------ | | 312| 1|#define YYEMPTY -2 ------------------ 1959| | 1960| 1| goto yysetstate; 1961| | 1962| | 1963| |/*------------------------------------------------------------. 1964| || yynewstate -- push a new state, which is found in yystate. | 1965| |`------------------------------------------------------------*/ 1966| 6|yynewstate: 1967| | /* In all cases, when you get here, the value and location stacks 1968| | have just been pushed. So pushing a state here evens the stacks. */ 1969| 6| yyssp++; 1970| | 1971| | 1972| |/*--------------------------------------------------------------------. 1973| || yysetstate -- set current state (the top of the stack) to yystate. | 1974| |`--------------------------------------------------------------------*/ 1975| 7|yysetstate: 1976| 7| YYDPRINTF ((stderr, "Entering state %d\n", yystate)); ------------------ | | 1464| 7|# define YYDPRINTF(Args) ((void) 0) ------------------ 1977| 7| YY_ASSERT (0 <= yystate && yystate < YYNSTATES); ------------------ | | 750| 7|#define YY_ASSERT(E) ((void) (0 && (E))) | | ------------------ | | | Branch (750:31): [Folded, False: 7] | | | Branch (750:37): [True: 0, False: 0] | | | Branch (750:37): [True: 0, False: 0] | | ------------------ ------------------ 1978| 7| YY_IGNORE_USELESS_CAST_BEGIN 1979| 7| *yyssp = YY_CAST (yy_state_t, yystate); ------------------ | | 210| 7|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 1980| 7| YY_IGNORE_USELESS_CAST_END 1981| 7| YY_STACK_PRINT (yyss, yyssp); 1982| | 1983| 7| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (1983:7): [True: 0, False: 7] ------------------ 1984| |#if !defined yyoverflow && !defined YYSTACK_RELOCATE 1985| | YYNOMEM; 1986| |#else 1987| 0| { 1988| | /* Get the current used size of the three stacks, in elements. */ 1989| 0| YYPTRDIFF_T yysize = yyssp - yyss + 1; ------------------ | | 634| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ ------------------ 1990| | 1991| |# if defined yyoverflow 1992| | { 1993| | /* Give user a chance to reallocate the stack. Use copies of 1994| | these so that the &'s don't force the real ones into 1995| | memory. */ 1996| | yy_state_t *yyss1 = yyss; 1997| | YYSTYPE *yyvs1 = yyvs; 1998| | 1999| | /* Each stack pointer address is followed by the size of the 2000| | data in use in that stack, in bytes. This used to be a 2001| | conditional around just the two extra args, but that might 2002| | be undefined if yyoverflow is a macro. */ 2003| | yyoverflow (YY_("memory exhausted"), 2004| | &yyss1, yysize * YYSIZEOF (*yyssp), 2005| | &yyvs1, yysize * YYSIZEOF (*yyvsp), 2006| | &yystacksize); 2007| | yyss = yyss1; 2008| | yyvs = yyvs1; 2009| | } 2010| |# else /* defined YYSTACK_RELOCATE */ 2011| | /* Extend the stack our own way. */ 2012| 0| if (YYMAXDEPTH <= yystacksize) ------------------ | | 1484| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (2012:11): [True: 0, False: 0] ------------------ 2013| 0| YYNOMEM; ------------------ | | 1315| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2014| 0| yystacksize *= 2; 2015| 0| if (YYMAXDEPTH < yystacksize) ------------------ | | 1484| 0|# define YYMAXDEPTH 10000 ------------------ | Branch (2015:11): [True: 0, False: 0] ------------------ 2016| 0| yystacksize = YYMAXDEPTH; ------------------ | | 1484| 0|# define YYMAXDEPTH 10000 ------------------ 2017| | 2018| 0| { 2019| 0| yy_state_t *yyss1 = yyss; 2020| 0| union yyalloc *yyptr = 2021| 0| YY_CAST (union yyalloc *, ------------------ | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 2022| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2023| 0| if (! yyptr) ------------------ | Branch (2023:13): [True: 0, False: 0] ------------------ 2024| 0| YYNOMEM; ------------------ | | 1315| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 2025| 0| YYSTACK_RELOCATE (yyss_alloc, yyss); ------------------ | | 847| 0| do \ | | 848| 0| { \ | | 849| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 634| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 850| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 865| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 851| 0| Stack = &yyptr->Stack_alloc; \ | | 852| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 831| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 853| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 854| 0| } \ | | 855| 0| while (0) | | ------------------ | | | Branch (855:12): [Folded, False: 0] | | ------------------ ------------------ 2026| 0| YYSTACK_RELOCATE (yyvs_alloc, yyvs); ------------------ | | 847| 0| do \ | | 848| 0| { \ | | 849| 0| YYPTRDIFF_T yynewbytes; \ | | ------------------ | | | | 634| 0|# define YYPTRDIFF_T __PTRDIFF_TYPE__ | | ------------------ | | 850| 0| YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ | | ------------------ | | | | 865| 0| __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 851| 0| Stack = &yyptr->Stack_alloc; \ | | 852| 0| yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ | | ------------------ | | | | 831| 0|# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) | | | | ------------------ | | | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | | | ------------------ | | | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 853| 0| yyptr += yynewbytes / YYSIZEOF (*yyptr); \ | | ------------------ | | | | 667| 0|#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) | | | | ------------------ | | | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | | | ------------------ | | ------------------ | | 854| 0| } \ | | 855| 0| while (0) | | ------------------ | | | Branch (855:12): [Folded, False: 0] | | ------------------ ------------------ 2027| 0|# undef YYSTACK_RELOCATE 2028| 0| if (yyss1 != yyssa) ------------------ | Branch (2028:13): [True: 0, False: 0] ------------------ 2029| 0| YYSTACK_FREE (yyss1); ------------------ | | 792| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 2030| 0| } 2031| 0|# endif 2032| | 2033| 0| yyssp = yyss + yysize - 1; 2034| 0| yyvsp = yyvs + yysize - 1; 2035| | 2036| 0| YY_IGNORE_USELESS_CAST_BEGIN 2037| 0| YYDPRINTF ((stderr, "Stack size increased to %ld\n", ------------------ | | 1464| 0|# define YYDPRINTF(Args) ((void) 0) ------------------ 2038| 0| YY_CAST (long, yystacksize))); 2039| 0| YY_IGNORE_USELESS_CAST_END 2040| | 2041| 0| if (yyss + yystacksize - 1 <= yyssp) ------------------ | Branch (2041:11): [True: 0, False: 0] ------------------ 2042| 0| YYABORT; ------------------ | | 1313| 0|#define YYABORT goto yyabortlab ------------------ 2043| 0| } 2044| 7|#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2045| | 2046| | 2047| 7| if (yystate == YYFINAL) ------------------ | | 880| 7|#define YYFINAL 2 ------------------ | Branch (2047:7): [True: 1, False: 6] ------------------ 2048| 1| YYACCEPT; ------------------ | | 1312| 1|#define YYACCEPT goto yyacceptlab ------------------ 2049| | 2050| 6| goto yybackup; 2051| | 2052| | 2053| |/*-----------. 2054| || yybackup. | 2055| |`-----------*/ 2056| 6|yybackup: 2057| | /* Do appropriate processing given the current state. Read a 2058| | lookahead token if we need one and don't already have one. */ 2059| | 2060| | /* First try to decide what to do without reference to lookahead token. */ 2061| 6| yyn = yypact[yystate]; 2062| 6| if (yypact_value_is_default (yyn)) ------------------ | | 1021| 6| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1018| 6|#define YYPACT_NINF (-170) | | ------------------ | | | Branch (1021:3): [True: 3, False: 3] | | ------------------ ------------------ 2063| 3| goto yydefault; 2064| | 2065| | /* Not known => get a lookahead token if don't already have one. */ 2066| | 2067| | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2068| 3| if (yychar == YYEMPTY) ------------------ | | 51| 3|#define yychar yara_yychar ------------------ if (yychar == YYEMPTY) ------------------ | | 312| 3|#define YYEMPTY -2 ------------------ | Branch (2068:7): [True: 3, False: 0] ------------------ 2069| 3| { 2070| 3| YYDPRINTF ((stderr, "Reading a token\n")); ------------------ | | 1464| 3|# define YYDPRINTF(Args) ((void) 0) ------------------ 2071| 3| yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 51| 3|#define yychar yara_yychar ------------------ yychar = yylex (&yylval, yyscanner, compiler); ------------------ | | 47| 3|#define yylex yara_yylex ------------------ 2072| 3| } 2073| | 2074| 3| if (yychar <= _END_OF_FILE_) ------------------ | | 51| 3|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 3|#define _END_OF_FILE_ 0 ------------------ | Branch (2074:7): [True: 1, False: 2] ------------------ 2075| 1| { 2076| 1| yychar = _END_OF_FILE_; ------------------ | | 51| 1|#define yychar yara_yychar ------------------ yychar = _END_OF_FILE_; ------------------ | | 313| 1|#define _END_OF_FILE_ 0 ------------------ 2077| 1| yytoken = YYSYMBOL_YYEOF; 2078| 1| YYDPRINTF ((stderr, "Now at end of input.\n")); ------------------ | | 1464| 1|# define YYDPRINTF(Args) ((void) 0) ------------------ 2079| 1| } 2080| 2| else if (yychar == YYerror) ------------------ | | 51| 2|#define yychar yara_yychar ------------------ else if (yychar == YYerror) ------------------ | | 314| 2|#define YYerror 256 ------------------ | Branch (2080:12): [True: 0, False: 2] ------------------ 2081| 0| { 2082| | /* The scanner already issued an error message, process directly 2083| | to error recovery. But do not keep the error token as 2084| | lookahead, it is too special and may lead us to an endless 2085| | loop in error recovery. */ 2086| 0| yychar = YYUNDEF; ------------------ | | 51| 0|#define yychar yara_yychar ------------------ yychar = YYUNDEF; ------------------ | | 315| 0|#define YYUNDEF 257 ------------------ 2087| 0| yytoken = YYSYMBOL_YYerror; 2088| 0| goto yyerrlab1; 2089| 0| } 2090| 2| else 2091| 2| { 2092| 2| yytoken = YYTRANSLATE (yychar); ------------------ | | 900| 2| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 894| 2|#define YYMAXUTOK 319 | | ------------------ | | | Branch (900:4): [True: 2, False: 0] | | | Branch (900:18): [True: 2, False: 0] | | ------------------ | | 901| 2| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 2|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 902| 2| : YYSYMBOL_YYUNDEF) ------------------ 2093| 2| YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2094| 2| } 2095| | 2096| | /* If the proper action on seeing token YYTOKEN is to reduce or to 2097| | detect an error, take that action. */ 2098| 3| yyn += yytoken; 2099| 3| if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) ------------------ | | 882| 3|#define YYLAST 480 ------------------ | Branch (2099:7): [True: 0, False: 3] | Branch (2099:18): [True: 0, False: 3] | Branch (2099:34): [True: 0, False: 3] ------------------ 2100| 0| goto yydefault; 2101| 3| yyn = yytable[yyn]; 2102| 3| if (yyn <= 0) ------------------ | Branch (2102:7): [True: 0, False: 3] ------------------ 2103| 0| { 2104| 0| if (yytable_value_is_error (yyn)) ------------------ | | 1026| 0| 0 | | ------------------ | | | Branch (1026:3): [Folded, False: 0] | | ------------------ ------------------ 2105| 0| goto yyerrlab; 2106| 0| yyn = -yyn; 2107| 0| goto yyreduce; 2108| 0| } 2109| | 2110| | /* Count tokens shifted since error; after three, turn off error 2111| | status. */ 2112| 3| if (yyerrstatus) ------------------ | Branch (2112:7): [True: 0, False: 3] ------------------ 2113| 0| yyerrstatus--; 2114| | 2115| | /* Shift the lookahead token. */ 2116| 3| YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2117| 3| yystate = yyn; 2118| 3| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2119| 3| *++yyvsp = yylval; 2120| 3| YY_IGNORE_MAYBE_UNINITIALIZED_END 2121| | 2122| | /* Discard the shifted token. */ 2123| 3| yychar = YYEMPTY; ------------------ | | 51| 3|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 3|#define YYEMPTY -2 ------------------ 2124| 3| goto yynewstate; 2125| | 2126| | 2127| |/*-----------------------------------------------------------. 2128| || yydefault -- do the default action for the current state. | 2129| |`-----------------------------------------------------------*/ 2130| 3|yydefault: 2131| 3| yyn = yydefact[yystate]; 2132| 3| if (yyn == 0) ------------------ | Branch (2132:7): [True: 0, False: 3] ------------------ 2133| 0| goto yyerrlab; 2134| 3| goto yyreduce; 2135| | 2136| | 2137| |/*-----------------------------. 2138| || yyreduce -- do a reduction. | 2139| |`-----------------------------*/ 2140| 3|yyreduce: 2141| | /* yyn is the number of a rule to reduce with. */ 2142| 3| yylen = yyr2[yyn]; 2143| | 2144| | /* If YYLEN is nonzero, implement the default value of the action: 2145| | '$$ = $1'. 2146| | 2147| | Otherwise, the following line sets YYVAL to garbage. 2148| | This behavior is undocumented and Bison 2149| | users should not rely upon it. Assigning to YYVAL 2150| | unconditionally makes the parser a bit smaller, and it avoids a 2151| | GCC warning that YYVAL may be used uninitialized. */ 2152| 3| yyval = yyvsp[1-yylen]; 2153| | 2154| | 2155| 3| YY_REDUCE_PRINT (yyn); 2156| 3| switch (yyn) 2157| 3| { 2158| 0| case 8: /* rules: rules "end of included file" */ ------------------ | Branch (2158:3): [True: 0, False: 3] ------------------ 2159| 0|#line 373 "libyara/grammar.y" 2160| 0| { 2161| 0| _yr_compiler_pop_file_name(compiler); 2162| 0| } 2163| 0|#line 2164 "libyara/grammar.c" 2164| 0| break; 2165| | 2166| 0| case 9: /* rules: rules error "end of included file" */ ------------------ | Branch (2166:3): [True: 0, False: 3] ------------------ 2167| 0|#line 377 "libyara/grammar.y" 2168| 0| { 2169| 0| _yr_compiler_pop_file_name(compiler); 2170| 0| } 2171| 0|#line 2172 "libyara/grammar.c" 2172| 0| break; 2173| | 2174| 1| case 10: /* import: "" "text string" */ ------------------ | Branch (2174:3): [True: 1, False: 2] ------------------ 2175| 1|#line 385 "libyara/grammar.y" 2176| 1| { 2177| 1| int result = yr_parser_reduce_import(yyscanner, (yyvsp[0].sized_string)); 2178| | 2179| 1| yr_free((yyvsp[0].sized_string)); 2180| | 2181| 1| fail_if_error(result); ------------------ | | 135| 1| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 1|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 1] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 1| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2182| 1| } 2183| 0|#line 2184 "libyara/grammar.c" 2184| 0| break; 2185| | 2186| 0| case 11: /* @1: %empty */ ------------------ | Branch (2186:3): [True: 0, False: 3] ------------------ 2187| 0|#line 397 "libyara/grammar.y" 2188| 0| { 2189| 0| fail_if_error(yr_parser_reduce_rule_declaration_phase_1( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2190| 0| yyscanner, (int32_t) (yyvsp[-2].integer), (yyvsp[0].c_string), &(yyval.rule))); 2191| 0| } 2192| 0|#line 2193 "libyara/grammar.c" 2193| 0| break; 2194| | 2195| 0| case 12: /* $@2: %empty */ ------------------ | Branch (2195:3): [True: 0, False: 3] ------------------ 2196| 0|#line 402 "libyara/grammar.y" 2197| 0| { 2198| 0| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr( 2199| 0| compiler->arena, &(yyvsp[-4].rule)); 2200| | 2201| 0| rule->tags = (char*) yr_arena_ref_to_ptr( 2202| 0| compiler->arena, &(yyvsp[-3].tag)); 2203| | 2204| 0| rule->metas = (YR_META*) yr_arena_ref_to_ptr( 2205| 0| compiler->arena, &(yyvsp[-1].meta)); 2206| | 2207| 0| rule->strings = (YR_STRING*) yr_arena_ref_to_ptr( 2208| 0| compiler->arena, &(yyvsp[0].string)); 2209| 0| } 2210| 0|#line 2211 "libyara/grammar.c" 2211| 0| break; 2212| | 2213| 0| case 13: /* rule: rule_modifiers "" "identifier" @1 tags '{' meta strings $@2 condition '}' */ ------------------ | Branch (2213:3): [True: 0, False: 3] ------------------ 2214| 0|#line 416 "libyara/grammar.y" 2215| 0| { 2216| 0| YR_RULE* rule = (YR_RULE*) yr_arena_ref_to_ptr( 2217| 0| compiler->arena, &(yyvsp[-7].rule)); 2218| 0| rule->required_strings = (yyvsp[-1].expression).required_strings.count; 2219| | 2220| 0| int result = yr_parser_reduce_rule_declaration_phase_2( 2221| 0| yyscanner, &(yyvsp[-7].rule)); // rule created in phase 1 2222| | 2223| 0| yr_free((yyvsp[-8].c_string)); 2224| | 2225| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2226| 0| } 2227| 0|#line 2228 "libyara/grammar.c" 2228| 0| break; 2229| | 2230| 0| case 14: /* meta: %empty */ ------------------ | Branch (2230:3): [True: 0, False: 3] ------------------ 2231| 0|#line 433 "libyara/grammar.y" 2232| 0| { 2233| 0| (yyval.meta) = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 2234| 0| } 2235| 0|#line 2236 "libyara/grammar.c" 2236| 0| break; 2237| | 2238| 0| case 15: /* meta: "" ':' meta_declarations */ ------------------ | Branch (2238:3): [True: 0, False: 3] ------------------ 2239| 0|#line 437 "libyara/grammar.y" 2240| 0| { 2241| 0| YR_META* meta = yr_arena_get_ptr( 2242| 0| compiler->arena, 2243| 0| YR_METAS_TABLE, ------------------ | | 59| 0|#define YR_METAS_TABLE 2 ------------------ 2244| 0| (compiler->current_meta_idx - 1) * sizeof(YR_META)); 2245| | 2246| 0| meta->flags |= META_FLAGS_LAST_IN_RULE; ------------------ | | 140| 0|#define META_FLAGS_LAST_IN_RULE 1 ------------------ 2247| | 2248| 0| (yyval.meta) = (yyvsp[0].meta); 2249| 0| } 2250| 0|#line 2251 "libyara/grammar.c" 2251| 0| break; 2252| | 2253| 0| case 16: /* strings: %empty */ ------------------ | Branch (2253:3): [True: 0, False: 3] ------------------ 2254| 0|#line 452 "libyara/grammar.y" 2255| 0| { 2256| 0| (yyval.string) = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 2257| 0| } 2258| 0|#line 2259 "libyara/grammar.c" 2259| 0| break; 2260| | 2261| 0| case 17: /* strings: "" ':' string_declarations */ ------------------ | Branch (2261:3): [True: 0, False: 3] ------------------ 2262| 0|#line 456 "libyara/grammar.y" 2263| 0| { 2264| 0| YR_STRING* string = (YR_STRING*) yr_arena_get_ptr( 2265| 0| compiler->arena, 2266| 0| YR_STRINGS_TABLE, ------------------ | | 60| 0|#define YR_STRINGS_TABLE 3 ------------------ 2267| 0| (compiler->current_string_idx - 1) * sizeof(YR_STRING)); 2268| | 2269| 0| string->flags |= STRING_FLAGS_LAST_IN_RULE; ------------------ | | 78| 0|#define STRING_FLAGS_LAST_IN_RULE 0x1000 ------------------ 2270| | 2271| 0| (yyval.string) = (yyvsp[0].string); 2272| 0| } 2273| 0|#line 2274 "libyara/grammar.c" 2274| 0| break; 2275| | 2276| 0| case 18: /* condition: "" ':' boolean_expression */ ------------------ | Branch (2276:3): [True: 0, False: 3] ------------------ 2277| 0|#line 471 "libyara/grammar.y" 2278| 0| { 2279| 0| (yyval.expression) = (yyvsp[0].expression); 2280| 0| } 2281| 0|#line 2282 "libyara/grammar.c" 2282| 0| break; 2283| | 2284| 0| case 19: /* rule_modifiers: %empty */ ------------------ | Branch (2284:3): [True: 0, False: 3] ------------------ 2285| 0|#line 478 "libyara/grammar.y" 2286| 0| { (yyval.integer) = 0; } 2287| 0|#line 2288 "libyara/grammar.c" 2288| 0| break; 2289| | 2290| 0| case 20: /* rule_modifiers: rule_modifiers rule_modifier */ ------------------ | Branch (2290:3): [True: 0, False: 3] ------------------ 2291| 0|#line 479 "libyara/grammar.y" 2292| 0| { (yyval.integer) = (yyvsp[-1].integer) | (yyvsp[0].integer); } 2293| 0|#line 2294 "libyara/grammar.c" 2294| 0| break; 2295| | 2296| 0| case 21: /* rule_modifier: "" */ ------------------ | Branch (2296:3): [True: 0, False: 3] ------------------ 2297| 0|#line 484 "libyara/grammar.y" 2298| 0| { (yyval.integer) = RULE_FLAGS_PRIVATE; } ------------------ | | 52| 0|#define RULE_FLAGS_PRIVATE 0x01 ------------------ 2299| 0|#line 2300 "libyara/grammar.c" 2300| 0| break; 2301| | 2302| 0| case 22: /* rule_modifier: "" */ ------------------ | Branch (2302:3): [True: 0, False: 3] ------------------ 2303| 0|#line 485 "libyara/grammar.y" 2304| 0| { (yyval.integer) = RULE_FLAGS_GLOBAL; } ------------------ | | 53| 0|#define RULE_FLAGS_GLOBAL 0x02 ------------------ 2305| 0|#line 2306 "libyara/grammar.c" 2306| 0| break; 2307| | 2308| 0| case 23: /* tags: %empty */ ------------------ | Branch (2308:3): [True: 0, False: 3] ------------------ 2309| 0|#line 491 "libyara/grammar.y" 2310| 0| { 2311| 0| (yyval.tag) = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 2312| 0| } 2313| 0|#line 2314 "libyara/grammar.c" 2314| 0| break; 2315| | 2316| 0| case 24: /* tags: ':' tag_list */ ------------------ | Branch (2316:3): [True: 0, False: 3] ------------------ 2317| 0|#line 495 "libyara/grammar.y" 2318| 0| { 2319| | // Tags list is represented in the arena as a sequence 2320| | // of null-terminated strings, the sequence ends with an 2321| | // additional null character. Here we write the ending null 2322| | //character. Example: tag1\0tag2\0tag3\0\0 2323| | 2324| 0| fail_if_error(yr_arena_write_string( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2325| 0| yyget_extra(yyscanner)->arena, YR_SZ_POOL, "", NULL)); 2326| | 2327| 0| (yyval.tag) = (yyvsp[0].tag); 2328| 0| } 2329| 0|#line 2330 "libyara/grammar.c" 2330| 0| break; 2331| | 2332| 0| case 25: /* tag_list: "identifier" */ ------------------ | Branch (2332:3): [True: 0, False: 3] ------------------ 2333| 0|#line 511 "libyara/grammar.y" 2334| 0| { 2335| 0| int result = yr_arena_write_string( 2336| 0| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 54| 0|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &(yyval.tag)); ------------------ | | 62| 0|#define YR_SZ_POOL 5 ------------------ 2337| | 2338| 0| yr_free((yyvsp[0].c_string)); 2339| | 2340| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2341| 0| } 2342| 0|#line 2343 "libyara/grammar.c" 2343| 0| break; 2344| | 2345| 0| case 26: /* tag_list: tag_list "identifier" */ ------------------ | Branch (2345:3): [True: 0, False: 3] ------------------ 2346| 0|#line 520 "libyara/grammar.y" 2347| 0| { 2348| 0| YR_ARENA_REF ref; 2349| | 2350| | // Write the new tag identifier. 2351| 0| int result = yr_arena_write_string( 2352| 0| yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 54| 0|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_SZ_POOL, (yyvsp[0].c_string), &ref); ------------------ | | 62| 0|#define YR_SZ_POOL 5 ------------------ 2353| | 2354| 0| yr_free((yyvsp[0].c_string)); 2355| | 2356| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2357| | 2358| | // Get the address for the tag identifier just written. 2359| 0| char* new_tag = (char*) yr_arena_ref_to_ptr( 2360| 0| compiler->arena, &ref); 2361| | 2362| | // Take the address of first tag's identifier in the list. 2363| 0| char* tag = (char*) yr_arena_ref_to_ptr( 2364| 0| compiler->arena, &(yyval.tag)); 2365| | 2366| | // Search for duplicated tags. Tags are written one after 2367| | // the other, with zeroes in between (i.e: tag1/0tag2/0tag3) 2368| | // that's why can use tag < new_tag as the condition for the 2369| | // loop. 2370| 0| while (tag < new_tag) ------------------ | Branch (2370:16): [True: 0, False: 0] ------------------ 2371| 0| { 2372| 0| if (strcmp(tag, new_tag) == 0) ------------------ | Branch (2372:15): [True: 0, False: 0] ------------------ 2373| 0| { 2374| 0| yr_compiler_set_error_extra_info(compiler, tag); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2375| 0| fail_with_error(ERROR_DUPLICATED_TAG_IDENTIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2376| 0| } 2377| | 2378| 0| tag += strlen(tag) + 1; 2379| 0| } 2380| | 2381| 0| (yyval.tag) = (yyvsp[-1].tag); 2382| 0| } 2383| 0|#line 2384 "libyara/grammar.c" 2384| 0| break; 2385| | 2386| 0| case 27: /* meta_declarations: meta_declaration */ ------------------ | Branch (2386:3): [True: 0, False: 3] ------------------ 2387| 0|#line 561 "libyara/grammar.y" 2388| 0| { (yyval.meta) = (yyvsp[0].meta); } 2389| 0|#line 2390 "libyara/grammar.c" 2390| 0| break; 2391| | 2392| 0| case 28: /* meta_declarations: meta_declarations meta_declaration */ ------------------ | Branch (2392:3): [True: 0, False: 3] ------------------ 2393| 0|#line 562 "libyara/grammar.y" 2394| 0| { (yyval.meta) = (yyvsp[-1].meta); } 2395| 0|#line 2396 "libyara/grammar.c" 2396| 0| break; 2397| | 2398| 0| case 29: /* meta_declaration: "identifier" '=' "text string" */ ------------------ | Branch (2398:3): [True: 0, False: 3] ------------------ 2399| 0|#line 568 "libyara/grammar.y" 2400| 0| { 2401| 0| SIZED_STRING* sized_string = (yyvsp[0].sized_string); 2402| | 2403| 0| int result = yr_parser_reduce_meta_declaration( 2404| 0| yyscanner, 2405| 0| META_TYPE_STRING, ------------------ | | 137| 0|#define META_TYPE_STRING 2 ------------------ 2406| 0| (yyvsp[-2].c_string), 2407| 0| sized_string->c_string, 2408| 0| 0, 2409| 0| &(yyval.meta)); 2410| | 2411| 0| yr_free((yyvsp[-2].c_string)); 2412| 0| yr_free((yyvsp[0].sized_string)); 2413| | 2414| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2415| 0| } 2416| 0|#line 2417 "libyara/grammar.c" 2417| 0| break; 2418| | 2419| 0| case 30: /* meta_declaration: "identifier" '=' "integer number" */ ------------------ | Branch (2419:3): [True: 0, False: 3] ------------------ 2420| 0|#line 585 "libyara/grammar.y" 2421| 0| { 2422| 0| int result = yr_parser_reduce_meta_declaration( 2423| 0| yyscanner, 2424| 0| META_TYPE_INTEGER, ------------------ | | 136| 0|#define META_TYPE_INTEGER 1 ------------------ 2425| 0| (yyvsp[-2].c_string), 2426| 0| NULL, 2427| 0| (yyvsp[0].integer), 2428| 0| &(yyval.meta)); 2429| | 2430| 0| yr_free((yyvsp[-2].c_string)); 2431| | 2432| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2433| 0| } 2434| 0|#line 2435 "libyara/grammar.c" 2435| 0| break; 2436| | 2437| 0| case 31: /* meta_declaration: "identifier" '=' '-' "integer number" */ ------------------ | Branch (2437:3): [True: 0, False: 3] ------------------ 2438| 0|#line 599 "libyara/grammar.y" 2439| 0| { 2440| 0| int result = yr_parser_reduce_meta_declaration( 2441| 0| yyscanner, 2442| 0| META_TYPE_INTEGER, ------------------ | | 136| 0|#define META_TYPE_INTEGER 1 ------------------ 2443| 0| (yyvsp[-3].c_string), 2444| 0| NULL, 2445| 0| -(yyvsp[0].integer), 2446| 0| &(yyval.meta)); 2447| | 2448| 0| yr_free((yyvsp[-3].c_string)); 2449| | 2450| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2451| 0| } 2452| 0|#line 2453 "libyara/grammar.c" 2453| 0| break; 2454| | 2455| 0| case 32: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2455:3): [True: 0, False: 3] ------------------ 2456| 0|#line 613 "libyara/grammar.y" 2457| 0| { 2458| 0| int result = yr_parser_reduce_meta_declaration( 2459| 0| yyscanner, 2460| 0| META_TYPE_BOOLEAN, ------------------ | | 138| 0|#define META_TYPE_BOOLEAN 3 ------------------ 2461| 0| (yyvsp[-2].c_string), 2462| 0| NULL, 2463| 0| true, 2464| 0| &(yyval.meta)); 2465| | 2466| 0| yr_free((yyvsp[-2].c_string)); 2467| | 2468| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2469| 0| } 2470| 0|#line 2471 "libyara/grammar.c" 2471| 0| break; 2472| | 2473| 0| case 33: /* meta_declaration: "identifier" '=' "" */ ------------------ | Branch (2473:3): [True: 0, False: 3] ------------------ 2474| 0|#line 627 "libyara/grammar.y" 2475| 0| { 2476| 0| int result = yr_parser_reduce_meta_declaration( 2477| 0| yyscanner, 2478| 0| META_TYPE_BOOLEAN, ------------------ | | 138| 0|#define META_TYPE_BOOLEAN 3 ------------------ 2479| 0| (yyvsp[-2].c_string), 2480| 0| NULL, 2481| 0| false, 2482| 0| &(yyval.meta)); 2483| | 2484| 0| yr_free((yyvsp[-2].c_string)); 2485| | 2486| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2487| 0| } 2488| 0|#line 2489 "libyara/grammar.c" 2489| 0| break; 2490| | 2491| 0| case 34: /* string_declarations: string_declaration */ ------------------ | Branch (2491:3): [True: 0, False: 3] ------------------ 2492| 0|#line 644 "libyara/grammar.y" 2493| 0| { (yyval.string) = (yyvsp[0].string); } 2494| 0|#line 2495 "libyara/grammar.c" 2495| 0| break; 2496| | 2497| 0| case 35: /* string_declarations: string_declarations string_declaration */ ------------------ | Branch (2497:3): [True: 0, False: 3] ------------------ 2498| 0|#line 645 "libyara/grammar.y" 2499| 0| { (yyval.string) = (yyvsp[-1].string); } 2500| 0|#line 2501 "libyara/grammar.c" 2501| 0| break; 2502| | 2503| 0| case 36: /* $@3: %empty */ ------------------ | Branch (2503:3): [True: 0, False: 3] ------------------ 2504| 0|#line 651 "libyara/grammar.y" 2505| 0| { 2506| 0| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 0|#define yyget_lineno yara_yyget_lineno ------------------ 2507| 0| } 2508| 0|#line 2509 "libyara/grammar.c" 2509| 0| break; 2510| | 2511| 0| case 37: /* string_declaration: "string identifier" '=' $@3 "text string" string_modifiers */ ------------------ | Branch (2511:3): [True: 0, False: 3] ------------------ 2512| 0|#line 655 "libyara/grammar.y" 2513| 0| { 2514| 0| int result = yr_parser_reduce_string_declaration( 2515| 0| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2516| | 2517| 0| yr_free((yyvsp[-4].c_string)); 2518| 0| yr_free((yyvsp[-1].sized_string)); 2519| 0| yr_free((yyvsp[0].modifier).alphabet); 2520| | 2521| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2522| 0| compiler->current_line = 0; 2523| 0| } 2524| 0|#line 2525 "libyara/grammar.c" 2525| 0| break; 2526| | 2527| 0| case 38: /* $@4: %empty */ ------------------ | Branch (2527:3): [True: 0, False: 3] ------------------ 2528| 0|#line 667 "libyara/grammar.y" 2529| 0| { 2530| 0| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 0|#define yyget_lineno yara_yyget_lineno ------------------ 2531| 0| } 2532| 0|#line 2533 "libyara/grammar.c" 2533| 0| break; 2534| | 2535| 0| case 39: /* string_declaration: "string identifier" '=' $@4 "regular expression" regexp_modifiers */ ------------------ | Branch (2535:3): [True: 0, False: 3] ------------------ 2536| 0|#line 671 "libyara/grammar.y" 2537| 0| { 2538| 0| int result; 2539| | 2540| 0| (yyvsp[0].modifier).flags |= STRING_FLAGS_REGEXP; ------------------ | | 71| 0|#define STRING_FLAGS_REGEXP 0x20 ------------------ 2541| | 2542| 0| result = yr_parser_reduce_string_declaration( 2543| 0| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2544| | 2545| 0| yr_free((yyvsp[-4].c_string)); 2546| 0| yr_free((yyvsp[-1].sized_string)); 2547| | 2548| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2549| | 2550| 0| compiler->current_line = 0; 2551| 0| } 2552| 0|#line 2553 "libyara/grammar.c" 2553| 0| break; 2554| | 2555| 0| case 40: /* $@5: %empty */ ------------------ | Branch (2555:3): [True: 0, False: 3] ------------------ 2556| 0|#line 687 "libyara/grammar.y" 2557| 0| { 2558| 0| compiler->current_line = yyget_lineno(yyscanner); ------------------ | | 55| 0|#define yyget_lineno yara_yyget_lineno ------------------ 2559| 0| } 2560| 0|#line 2561 "libyara/grammar.c" 2561| 0| break; 2562| | 2563| 0| case 41: /* string_declaration: "string identifier" '=' $@5 "hex string" hex_modifiers */ ------------------ | Branch (2563:3): [True: 0, False: 3] ------------------ 2564| 0|#line 691 "libyara/grammar.y" 2565| 0| { 2566| 0| int result; 2567| | 2568| 0| (yyvsp[0].modifier).flags |= STRING_FLAGS_HEXADECIMAL; ------------------ | | 67| 0|#define STRING_FLAGS_HEXADECIMAL 0x02 ------------------ 2569| | 2570| 0| result = yr_parser_reduce_string_declaration( 2571| 0| yyscanner, (yyvsp[0].modifier), (yyvsp[-4].c_string), (yyvsp[-1].sized_string), &(yyval.string)); 2572| | 2573| 0| yr_free((yyvsp[-4].c_string)); 2574| 0| yr_free((yyvsp[-1].sized_string)); 2575| | 2576| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2577| | 2578| 0| compiler->current_line = 0; 2579| 0| } 2580| 0|#line 2581 "libyara/grammar.c" 2581| 0| break; 2582| | 2583| 0| case 42: /* string_modifiers: %empty */ ------------------ | Branch (2583:3): [True: 0, False: 3] ------------------ 2584| 0|#line 711 "libyara/grammar.y" 2585| 0| { 2586| 0| (yyval.modifier).flags = 0; 2587| 0| (yyval.modifier).xor_min = 0; 2588| 0| (yyval.modifier).xor_max = 0; 2589| 0| (yyval.modifier).alphabet = NULL; 2590| 0| } 2591| 0|#line 2592 "libyara/grammar.c" 2592| 0| break; 2593| | 2594| 0| case 43: /* string_modifiers: string_modifiers string_modifier */ ------------------ | Branch (2594:3): [True: 0, False: 3] ------------------ 2595| 0|#line 718 "libyara/grammar.y" 2596| 0| { 2597| 0| (yyval.modifier) = (yyvsp[-1].modifier); 2598| | 2599| | // Only set the xor minimum and maximum if we are dealing with the 2600| | // xor modifier. If we don't check for this then we can end up with 2601| | // "xor wide" resulting in whatever is on the stack for "wide" 2602| | // overwriting the values for xor. 2603| 0| if ((yyvsp[0].modifier).flags & STRING_FLAGS_XOR) ------------------ | | 85| 0|#define STRING_FLAGS_XOR 0x80000 ------------------ | Branch (2603:13): [True: 0, False: 0] ------------------ 2604| 0| { 2605| 0| (yyval.modifier).xor_min = (yyvsp[0].modifier).xor_min; 2606| 0| (yyval.modifier).xor_max = (yyvsp[0].modifier).xor_max; 2607| 0| } 2608| | 2609| | // Only set the base64 alphabet if we are dealing with the base64 2610| | // modifier. If we don't check for this then we can end up with 2611| | // "base64 ascii" resulting in whatever is on the stack for "ascii" 2612| | // overwriting the values for base64. 2613| 0| if (((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64) || ------------------ | | 87| 0|#define STRING_FLAGS_BASE64 0x200000 ------------------ | Branch (2613:13): [True: 0, False: 0] ------------------ 2614| 0| ((yyvsp[0].modifier).flags & STRING_FLAGS_BASE64_WIDE)) ------------------ | | 88| 0|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ | Branch (2614:13): [True: 0, False: 0] ------------------ 2615| 0| { 2616| 0| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2616:15): [True: 0, False: 0] ------------------ 2617| 0| { 2618| 0| if (ss_compare((yyval.modifier).alphabet, (yyvsp[0].modifier).alphabet) != 0) ------------------ | Branch (2618:17): [True: 0, False: 0] ------------------ 2619| 0| { 2620| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2621| 0| compiler, "can not specify multiple alphabets"); 2622| | 2623| 0| yr_free((yyvsp[0].modifier).alphabet); 2624| 0| yr_free((yyval.modifier).alphabet); 2625| | 2626| 0| fail_with_error(ERROR_INVALID_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2627| 0| } 2628| 0| else 2629| 0| { 2630| 0| yr_free((yyvsp[0].modifier).alphabet); 2631| 0| } 2632| 0| } 2633| 0| else 2634| 0| { 2635| 0| (yyval.modifier).alphabet = (yyvsp[0].modifier).alphabet; 2636| 0| } 2637| 0| } 2638| | 2639| 0| if ((yyval.modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2639:13): [True: 0, False: 0] ------------------ 2640| 0| { 2641| 0| if ((yyval.modifier).alphabet != NULL) ------------------ | Branch (2641:15): [True: 0, False: 0] ------------------ 2642| 0| yr_free((yyval.modifier).alphabet); 2643| | 2644| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2645| 0| } 2646| 0| else 2647| 0| { 2648| 0| (yyval.modifier).flags = (yyval.modifier).flags | (yyvsp[0].modifier).flags; 2649| 0| } 2650| 0| } 2651| 0|#line 2652 "libyara/grammar.c" 2652| 0| break; 2653| | 2654| 0| case 44: /* string_modifier: "" */ ------------------ | Branch (2654:3): [True: 0, False: 3] ------------------ 2655| 0|#line 777 "libyara/grammar.y" 2656| 0| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 0|#define STRING_FLAGS_WIDE 0x10 ------------------ 2657| 0|#line 2658 "libyara/grammar.c" 2658| 0| break; 2659| | 2660| 0| case 45: /* string_modifier: "" */ ------------------ | Branch (2660:3): [True: 0, False: 3] ------------------ 2661| 0|#line 778 "libyara/grammar.y" 2662| 0| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 0|#define STRING_FLAGS_ASCII 0x08 ------------------ 2663| 0|#line 2664 "libyara/grammar.c" 2664| 0| break; 2665| | 2666| 0| case 46: /* string_modifier: "" */ ------------------ | Branch (2666:3): [True: 0, False: 3] ------------------ 2667| 0|#line 779 "libyara/grammar.y" 2668| 0| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 0|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2669| 0|#line 2670 "libyara/grammar.c" 2670| 0| break; 2671| | 2672| 0| case 47: /* string_modifier: "" */ ------------------ | Branch (2672:3): [True: 0, False: 3] ------------------ 2673| 0|#line 780 "libyara/grammar.y" 2674| 0| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 0|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2675| 0|#line 2676 "libyara/grammar.c" 2676| 0| break; 2677| | 2678| 0| case 48: /* string_modifier: "" */ ------------------ | Branch (2678:3): [True: 0, False: 3] ------------------ 2679| 0|#line 781 "libyara/grammar.y" 2680| 0| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 0|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2681| 0|#line 2682 "libyara/grammar.c" 2682| 0| break; 2683| | 2684| 0| case 49: /* string_modifier: "" */ ------------------ | Branch (2684:3): [True: 0, False: 3] ------------------ 2685| 0|#line 783 "libyara/grammar.y" 2686| 0| { 2687| 0| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 0|#define STRING_FLAGS_XOR 0x80000 ------------------ 2688| 0| (yyval.modifier).xor_min = 0; 2689| 0| (yyval.modifier).xor_max = 255; 2690| 0| } 2691| 0|#line 2692 "libyara/grammar.c" 2692| 0| break; 2693| | 2694| 0| case 50: /* string_modifier: "" '(' "integer number" ')' */ ------------------ | Branch (2694:3): [True: 0, False: 3] ------------------ 2695| 0|#line 789 "libyara/grammar.y" 2696| 0| { 2697| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2698| | 2699| 0| if ((yyvsp[-1].integer) < 0 || (yyvsp[-1].integer) > 255) ------------------ | Branch (2699:13): [True: 0, False: 0] | Branch (2699:40): [True: 0, False: 0] ------------------ 2700| 0| { 2701| 0| yr_compiler_set_error_extra_info(compiler, "invalid xor range"); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2702| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2703| 0| } 2704| | 2705| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2706| | 2707| 0| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 0|#define STRING_FLAGS_XOR 0x80000 ------------------ 2708| 0| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-1].integer); 2709| 0| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2710| 0| } 2711| 0|#line 2712 "libyara/grammar.c" 2712| 0| break; 2713| | 2714| 0| case 51: /* string_modifier: "" '(' "integer number" '-' "integer number" ')' */ ------------------ | Branch (2714:3): [True: 0, False: 3] ------------------ 2715| 0|#line 810 "libyara/grammar.y" 2716| 0| { 2717| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2718| | 2719| 0| if ((yyvsp[-3].integer) < 0) ------------------ | Branch (2719:13): [True: 0, False: 0] ------------------ 2720| 0| { 2721| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2722| 0| compiler, "lower bound for xor range exceeded (min: 0)"); 2723| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2724| 0| } 2725| | 2726| 0| if ((yyvsp[-1].integer) > 255) ------------------ | Branch (2726:13): [True: 0, False: 0] ------------------ 2727| 0| { 2728| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2729| 0| compiler, "upper bound for xor range exceeded (max: 255)"); 2730| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2731| 0| } 2732| | 2733| 0| if ((yyvsp[-3].integer) > (yyvsp[-1].integer)) ------------------ | Branch (2733:13): [True: 0, False: 0] ------------------ 2734| 0| { 2735| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2736| 0| compiler, "xor lower bound exceeds upper bound"); 2737| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2738| 0| } 2739| | 2740| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2741| | 2742| 0| (yyval.modifier).flags = STRING_FLAGS_XOR; ------------------ | | 85| 0|#define STRING_FLAGS_XOR 0x80000 ------------------ 2743| 0| (yyval.modifier).xor_min = (uint8_t) (yyvsp[-3].integer); 2744| 0| (yyval.modifier).xor_max = (uint8_t) (yyvsp[-1].integer); 2745| 0| } 2746| 0|#line 2747 "libyara/grammar.c" 2747| 0| break; 2748| | 2749| 0| case 52: /* string_modifier: "" */ ------------------ | Branch (2749:3): [True: 0, False: 3] ------------------ 2750| 0|#line 841 "libyara/grammar.y" 2751| 0| { 2752| 0| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 0|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2753| 0| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 0| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2754| 0| } 2755| 0|#line 2756 "libyara/grammar.c" 2756| 0| break; 2757| | 2758| 0| case 53: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2758:3): [True: 0, False: 3] ------------------ 2759| 0|#line 846 "libyara/grammar.y" 2760| 0| { 2761| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2762| | 2763| 0| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2763:13): [True: 0, False: 0] ------------------ 2764| 0| { 2765| 0| yr_free((yyvsp[-1].sized_string)); 2766| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2767| 0| compiler, "length of base64 alphabet must be 64"); 2768| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2769| 0| } 2770| | 2771| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2772| | 2773| 0| (yyval.modifier).flags = STRING_FLAGS_BASE64; ------------------ | | 87| 0|#define STRING_FLAGS_BASE64 0x200000 ------------------ 2774| 0| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2775| 0| } 2776| 0|#line 2777 "libyara/grammar.c" 2777| 0| break; 2778| | 2779| 0| case 54: /* string_modifier: "" */ ------------------ | Branch (2779:3): [True: 0, False: 3] ------------------ 2780| 0|#line 863 "libyara/grammar.y" 2781| 0| { 2782| 0| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 0|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2783| 0| (yyval.modifier).alphabet = ss_new(DEFAULT_BASE64_ALPHABET); ------------------ | | 200| 0| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ------------------ 2784| 0| } 2785| 0|#line 2786 "libyara/grammar.c" 2786| 0| break; 2787| | 2788| 0| case 55: /* string_modifier: "" '(' "text string" ')' */ ------------------ | Branch (2788:3): [True: 0, False: 3] ------------------ 2789| 0|#line 868 "libyara/grammar.y" 2790| 0| { 2791| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2792| | 2793| 0| if ((yyvsp[-1].sized_string)->length != 64) ------------------ | Branch (2793:13): [True: 0, False: 0] ------------------ 2794| 0| { 2795| 0| yr_free((yyvsp[-1].sized_string)); 2796| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2797| 0| compiler, "length of base64 alphabet must be 64"); 2798| 0| result = ERROR_INVALID_MODIFIER; ------------------ | | 106| 0|#define ERROR_INVALID_MODIFIER 59 ------------------ 2799| 0| } 2800| | 2801| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2802| | 2803| 0| (yyval.modifier).flags = STRING_FLAGS_BASE64_WIDE; ------------------ | | 88| 0|#define STRING_FLAGS_BASE64_WIDE 0x400000 ------------------ 2804| 0| (yyval.modifier).alphabet = (yyvsp[-1].sized_string); 2805| 0| } 2806| 0|#line 2807 "libyara/grammar.c" 2807| 0| break; 2808| | 2809| 0| case 56: /* regexp_modifiers: %empty */ ------------------ | Branch (2809:3): [True: 0, False: 3] ------------------ 2810| 0|#line 887 "libyara/grammar.y" 2811| 0| { (yyval.modifier).flags = 0; } 2812| 0|#line 2813 "libyara/grammar.c" 2813| 0| break; 2814| | 2815| 0| case 57: /* regexp_modifiers: regexp_modifiers regexp_modifier */ ------------------ | Branch (2815:3): [True: 0, False: 3] ------------------ 2816| 0|#line 889 "libyara/grammar.y" 2817| 0| { 2818| 0| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2818:13): [True: 0, False: 0] ------------------ 2819| 0| { 2820| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2821| 0| } 2822| 0| else 2823| 0| { 2824| 0| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2825| 0| } 2826| 0| } 2827| 0|#line 2828 "libyara/grammar.c" 2828| 0| break; 2829| | 2830| 0| case 58: /* regexp_modifier: "" */ ------------------ | Branch (2830:3): [True: 0, False: 3] ------------------ 2831| 0|#line 902 "libyara/grammar.y" 2832| 0| { (yyval.modifier).flags = STRING_FLAGS_WIDE; } ------------------ | | 70| 0|#define STRING_FLAGS_WIDE 0x10 ------------------ 2833| 0|#line 2834 "libyara/grammar.c" 2834| 0| break; 2835| | 2836| 0| case 59: /* regexp_modifier: "" */ ------------------ | Branch (2836:3): [True: 0, False: 3] ------------------ 2837| 0|#line 903 "libyara/grammar.y" 2838| 0| { (yyval.modifier).flags = STRING_FLAGS_ASCII; } ------------------ | | 69| 0|#define STRING_FLAGS_ASCII 0x08 ------------------ 2839| 0|#line 2840 "libyara/grammar.c" 2840| 0| break; 2841| | 2842| 0| case 60: /* regexp_modifier: "" */ ------------------ | Branch (2842:3): [True: 0, False: 3] ------------------ 2843| 0|#line 904 "libyara/grammar.y" 2844| 0| { (yyval.modifier).flags = STRING_FLAGS_NO_CASE; } ------------------ | | 68| 0|#define STRING_FLAGS_NO_CASE 0x04 ------------------ 2845| 0|#line 2846 "libyara/grammar.c" 2846| 0| break; 2847| | 2848| 0| case 61: /* regexp_modifier: "" */ ------------------ | Branch (2848:3): [True: 0, False: 3] ------------------ 2849| 0|#line 905 "libyara/grammar.y" 2850| 0| { (yyval.modifier).flags = STRING_FLAGS_FULL_WORD; } ------------------ | | 73| 0|#define STRING_FLAGS_FULL_WORD 0x80 ------------------ 2851| 0|#line 2852 "libyara/grammar.c" 2852| 0| break; 2853| | 2854| 0| case 62: /* regexp_modifier: "" */ ------------------ | Branch (2854:3): [True: 0, False: 3] ------------------ 2855| 0|#line 906 "libyara/grammar.y" 2856| 0| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 0|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2857| 0|#line 2858 "libyara/grammar.c" 2858| 0| break; 2859| | 2860| 0| case 63: /* hex_modifiers: %empty */ ------------------ | Branch (2860:3): [True: 0, False: 3] ------------------ 2861| 0|#line 910 "libyara/grammar.y" 2862| 0| { (yyval.modifier).flags = 0; } 2863| 0|#line 2864 "libyara/grammar.c" 2864| 0| break; 2865| | 2866| 0| case 64: /* hex_modifiers: hex_modifiers hex_modifier */ ------------------ | Branch (2866:3): [True: 0, False: 3] ------------------ 2867| 0|#line 912 "libyara/grammar.y" 2868| 0| { 2869| 0| if ((yyvsp[-1].modifier).flags & (yyvsp[0].modifier).flags) ------------------ | Branch (2869:13): [True: 0, False: 0] ------------------ 2870| 0| { 2871| 0| fail_with_error(ERROR_DUPLICATED_MODIFIER); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 2872| 0| } 2873| 0| else 2874| 0| { 2875| 0| (yyval.modifier).flags = (yyvsp[-1].modifier).flags | (yyvsp[0].modifier).flags; 2876| 0| } 2877| 0| } 2878| 0|#line 2879 "libyara/grammar.c" 2879| 0| break; 2880| | 2881| 0| case 65: /* hex_modifier: "" */ ------------------ | Branch (2881:3): [True: 0, False: 3] ------------------ 2882| 0|#line 925 "libyara/grammar.y" 2883| 0| { (yyval.modifier).flags = STRING_FLAGS_PRIVATE; } ------------------ | | 86| 0|#define STRING_FLAGS_PRIVATE 0x100000 ------------------ 2884| 0|#line 2885 "libyara/grammar.c" 2885| 0| break; 2886| | 2887| 0| case 66: /* identifier: "identifier" */ ------------------ | Branch (2887:3): [True: 0, False: 3] ------------------ 2888| 0|#line 930 "libyara/grammar.y" 2889| 0| { 2890| 0| YR_EXPRESSION expr; 2891| | 2892| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2893| 0| int var_index = yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), &expr); 2894| | 2895| 0| if (var_index >= 0) ------------------ | Branch (2895:13): [True: 0, False: 0] ------------------ 2896| 0| { 2897| | // The identifier corresponds to a loop variable. 2898| 0| result = yr_parser_emit_with_arg( 2899| 0| yyscanner, 2900| 0| OP_PUSH_M, ------------------ | | 82| 0|#define OP_PUSH_M 34 ------------------ 2901| 0| var_index, 2902| 0| NULL, 2903| 0| NULL); 2904| | 2905| | // The expression associated to this identifier is the same one 2906| | // associated to the loop variable. 2907| 0| (yyval.expression) = expr; 2908| 0| } 2909| 0| else 2910| 0| { 2911| | // Search for identifier within the global namespace, where the 2912| | // externals variables reside. 2913| | 2914| 0| YR_OBJECT* object = (YR_OBJECT*) yr_hash_table_lookup( 2915| 0| compiler->objects_table, (yyvsp[0].c_string), NULL); 2916| | 2917| 0| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 2918| 0| compiler->arena, 2919| 0| YR_NAMESPACES_TABLE, ------------------ | | 57| 0|#define YR_NAMESPACES_TABLE 0 ------------------ 2920| 0| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 2921| | 2922| 0| if (object == NULL) ------------------ | Branch (2922:15): [True: 0, False: 0] ------------------ 2923| 0| { 2924| | // If not found, search within the current namespace. 2925| 0| object = (YR_OBJECT*) yr_hash_table_lookup( 2926| 0| compiler->objects_table, (yyvsp[0].c_string), ns->name); 2927| 0| } 2928| | 2929| 0| if (object != NULL) ------------------ | Branch (2929:15): [True: 0, False: 0] ------------------ 2930| 0| { 2931| 0| YR_ARENA_REF ref; 2932| | 2933| 0| result = _yr_compiler_store_string( 2934| 0| compiler, (yyvsp[0].c_string), &ref); 2935| | 2936| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (2936:17): [True: 0, False: 0] ------------------ 2937| 0| result = yr_parser_emit_with_arg_reloc( 2938| 0| yyscanner, 2939| 0| OP_OBJ_LOAD, ------------------ | | 64| 0|#define OP_OBJ_LOAD 16 ------------------ 2940| 0| yr_arena_ref_to_ptr(compiler->arena, &ref), 2941| 0| NULL, 2942| 0| NULL); 2943| | 2944| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 2945| 0| (yyval.expression).value.object = object; 2946| 0| (yyval.expression).identifier.ptr = NULL; 2947| 0| (yyval.expression).identifier.ref = ref; 2948| 0| } 2949| 0| else 2950| 0| { 2951| 0| uint32_t rule_idx = yr_hash_table_lookup_uint32( 2952| 0| compiler->rules_table, (yyvsp[0].c_string), ns->name); 2953| | 2954| 0| if (rule_idx != UINT32_MAX) ------------------ | Branch (2954:17): [True: 0, False: 0] ------------------ 2955| 0| { 2956| 0| result = yr_parser_emit_with_arg( 2957| 0| yyscanner, 2958| 0| OP_PUSH_RULE, ------------------ | | 75| 0|#define OP_PUSH_RULE 27 ------------------ 2959| 0| rule_idx, 2960| 0| NULL, 2961| 0| NULL); 2962| | 2963| 0| YR_RULE* rule = _yr_compiler_get_rule_by_idx(compiler, rule_idx); 2964| | 2965| 0| yr_arena_ptr_to_ref(compiler->arena, rule->identifier, &(yyval.expression).identifier.ref); 2966| | 2967| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 2968| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 2969| 0| (yyval.expression).identifier.ptr = NULL; 2970| 0| (yyval.expression).required_strings.count = 0; 2971| 0| } 2972| 0| else 2973| 0| { 2974| 0| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2975| 0| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 0|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 2976| 0| } 2977| 0| } 2978| 0| } 2979| | 2980| 0| yr_free((yyvsp[0].c_string)); 2981| | 2982| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 2983| 0| } 2984| 0|#line 2985 "libyara/grammar.c" 2985| 0| break; 2986| | 2987| 0| case 67: /* identifier: identifier '.' "identifier" */ ------------------ | Branch (2987:3): [True: 0, False: 3] ------------------ 2988| 0|#line 1026 "libyara/grammar.y" 2989| 0| { 2990| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 2991| 0| YR_OBJECT* field = NULL; 2992| | 2993| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (2993:13): [True: 0, False: 0] ------------------ 2994| 0| (yyvsp[-2].expression).value.object->type == OBJECT_TYPE_STRUCTURE) ------------------ | | 60| 0|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (2994:13): [True: 0, False: 0] ------------------ 2995| 0| { 2996| 0| field = yr_object_lookup_field((yyvsp[-2].expression).value.object, (yyvsp[0].c_string)); 2997| | 2998| 0| if (field != NULL) ------------------ | Branch (2998:15): [True: 0, False: 0] ------------------ 2999| 0| { 3000| 0| YR_ARENA_REF ref; 3001| | 3002| 0| result = _yr_compiler_store_string( 3003| 0| compiler, (yyvsp[0].c_string), &ref); 3004| | 3005| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (3005:17): [True: 0, False: 0] ------------------ 3006| 0| result = yr_parser_emit_with_arg_reloc( 3007| 0| yyscanner, 3008| 0| OP_OBJ_FIELD, ------------------ | | 66| 0|#define OP_OBJ_FIELD 18 ------------------ 3009| 0| yr_arena_ref_to_ptr(compiler->arena, &ref), 3010| 0| NULL, 3011| 0| NULL); 3012| | 3013| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3014| 0| (yyval.expression).value.object = field; 3015| 0| (yyval.expression).identifier.ref = ref; 3016| 0| (yyval.expression).identifier.ptr = NULL; 3017| 0| } 3018| 0| else 3019| 0| { 3020| 0| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3021| 0| result = ERROR_INVALID_FIELD_NAME; ------------------ | | 80| 0|#define ERROR_INVALID_FIELD_NAME 33 ------------------ 3022| 0| } 3023| 0| } 3024| 0| else 3025| 0| { 3026| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | ------------------ | | | Branch (322:7): [True: 0, False: 0] | | ------------------ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3027| 0| compiler, expression_identifier((yyvsp[-2].expression))); 3028| | 3029| 0| result = ERROR_NOT_A_STRUCTURE; ------------------ | | 82| 0|#define ERROR_NOT_A_STRUCTURE 35 ------------------ 3030| 0| } 3031| | 3032| 0| yr_free((yyvsp[0].c_string)); 3033| | 3034| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3035| 0| } 3036| 0|#line 3037 "libyara/grammar.c" 3037| 0| break; 3038| | 3039| 0| case 68: /* identifier: identifier '[' primary_expression ']' */ ------------------ | Branch (3039:3): [True: 0, False: 3] ------------------ 3040| 0|#line 1074 "libyara/grammar.y" 3041| 0| { 3042| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 3043| 0| YR_OBJECT_ARRAY* array; 3044| 0| YR_OBJECT_DICTIONARY* dict; 3045| | 3046| 0| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3046:13): [True: 0, False: 0] ------------------ 3047| 0| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_ARRAY) ------------------ | | 61| 0|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (3047:13): [True: 0, False: 0] ------------------ 3048| 0| { 3049| 0| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3049:15): [True: 0, False: 0] ------------------ 3050| 0| { 3051| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3052| 0| compiler, "array indexes must be of integer type"); 3053| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 3054| 0| } 3055| | 3056| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3057| | 3058| 0| result = yr_parser_emit( 3059| 0| yyscanner, OP_INDEX_ARRAY, NULL); ------------------ | | 67| 0|#define OP_INDEX_ARRAY 19 ------------------ 3060| | 3061| 0| array = object_as_array((yyvsp[-3].expression).value.object); ------------------ | | 910| 0|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 3062| | 3063| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3064| 0| (yyval.expression).value.object = array->prototype_item; 3065| 0| (yyval.expression).identifier.ptr = array->identifier; 3066| 0| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 3067| 0| } 3068| 0| else if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3068:18): [True: 0, False: 0] ------------------ 3069| 0| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_DICTIONARY) ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (3069:18): [True: 0, False: 0] ------------------ 3070| 0| { 3071| 0| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3071:15): [True: 0, False: 0] ------------------ 3072| 0| { 3073| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3074| 0| compiler, "dictionary keys must be of string type"); 3075| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 3076| 0| } 3077| | 3078| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3079| | 3080| 0| result = yr_parser_emit( 3081| 0| yyscanner, OP_LOOKUP_DICT, NULL); ------------------ | | 90| 0|#define OP_LOOKUP_DICT 42 ------------------ 3082| | 3083| 0| dict = object_as_dictionary((yyvsp[-3].expression).value.object); ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 3084| | 3085| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3086| 0| (yyval.expression).value.object = dict->prototype_item; 3087| 0| (yyval.expression).identifier.ptr = dict->identifier; 3088| 0| (yyval.expression).identifier.ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 3089| 0| } 3090| 0| else 3091| 0| { 3092| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | ------------------ | | | Branch (322:7): [True: 0, False: 0] | | ------------------ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3093| 0| compiler, expression_identifier((yyvsp[-3].expression))); 3094| | 3095| 0| result = ERROR_NOT_INDEXABLE; ------------------ | | 83| 0|#define ERROR_NOT_INDEXABLE 36 ------------------ 3096| 0| } 3097| | 3098| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3099| 0| } 3100| 0|#line 3101 "libyara/grammar.c" 3101| 0| break; 3102| | 3103| 0| case 69: /* identifier: identifier '(' arguments ')' */ ------------------ | Branch (3103:3): [True: 0, False: 3] ------------------ 3104| 0|#line 1135 "libyara/grammar.y" 3105| 0| { 3106| 0| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 3107| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 3108| | 3109| 0| if ((yyvsp[-3].expression).type == EXPRESSION_TYPE_OBJECT && ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (3109:13): [True: 0, False: 0] ------------------ 3110| 0| (yyvsp[-3].expression).value.object->type == OBJECT_TYPE_FUNCTION) ------------------ | | 62| 0|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (3110:13): [True: 0, False: 0] ------------------ 3111| 0| { 3112| 0| YR_OBJECT_FUNCTION* function = object_as_function((yyvsp[-3].expression).value.object); ------------------ | | 912| 0|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 3113| | 3114| 0| result = yr_parser_check_types(compiler, function, (yyvsp[-1].c_string)); 3115| | 3116| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (3116:15): [True: 0, False: 0] ------------------ 3117| 0| result = _yr_compiler_store_string( 3118| 0| compiler, (yyvsp[-1].c_string), &ref); 3119| | 3120| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (3120:15): [True: 0, False: 0] ------------------ 3121| 0| result = yr_parser_emit_with_arg_reloc( 3122| 0| yyscanner, 3123| 0| OP_CALL, ------------------ | | 63| 0|#define OP_CALL 15 ------------------ 3124| 0| yr_arena_ref_to_ptr(compiler->arena, &ref), 3125| 0| NULL, 3126| 0| NULL); 3127| | 3128| 0| (yyval.expression).type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 3129| 0| (yyval.expression).value.object = function->return_obj; 3130| 0| (yyval.expression).identifier.ref = ref; 3131| 0| (yyval.expression).identifier.ptr = NULL; 3132| 0| } 3133| 0| else 3134| 0| { 3135| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | ------------------ | | | Branch (322:7): [True: 0, False: 0] | | ------------------ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3136| 0| compiler, expression_identifier((yyvsp[-3].expression))); 3137| | 3138| 0| result = ERROR_NOT_A_FUNCTION; ------------------ | | 84| 0|#define ERROR_NOT_A_FUNCTION 37 ------------------ 3139| 0| } 3140| | 3141| 0| yr_free((yyvsp[-1].c_string)); 3142| | 3143| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3144| 0| } 3145| 0|#line 3146 "libyara/grammar.c" 3146| 0| break; 3147| | 3148| 0| case 70: /* arguments: %empty */ ------------------ | Branch (3148:3): [True: 0, False: 3] ------------------ 3149| 0|#line 1179 "libyara/grammar.y" 3150| 0| { (yyval.c_string) = yr_strdup(""); } 3151| 0|#line 3152 "libyara/grammar.c" 3152| 0| break; 3153| | 3154| 0| case 71: /* arguments: arguments_list */ ------------------ | Branch (3154:3): [True: 0, False: 3] ------------------ 3155| 0|#line 1180 "libyara/grammar.y" 3156| 0| { (yyval.c_string) = (yyvsp[0].c_string); } 3157| 0|#line 3158 "libyara/grammar.c" 3158| 0| break; 3159| | 3160| 0| case 72: /* arguments_list: expression */ ------------------ | Branch (3160:3): [True: 0, False: 3] ------------------ 3161| 0|#line 1185 "libyara/grammar.y" 3162| 0| { 3163| 0| (yyval.c_string) = (char*) yr_malloc(YR_MAX_FUNCTION_ARGS + 1); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3164| | 3165| 0| if ((yyval.c_string) == NULL) ------------------ | Branch (3165:13): [True: 0, False: 0] ------------------ 3166| 0| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3167| | 3168| 0| switch((yyvsp[0].expression).type) 3169| 0| { 3170| 0| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3170:11): [True: 0, False: 0] ------------------ 3171| 0| strlcpy((yyval.c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3172| 0| break; 3173| 0| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3173:11): [True: 0, False: 0] ------------------ 3174| 0| strlcpy((yyval.c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3175| 0| break; 3176| 0| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3176:11): [True: 0, False: 0] ------------------ 3177| 0| strlcpy((yyval.c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3178| 0| break; 3179| 0| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3179:11): [True: 0, False: 0] ------------------ 3180| 0| strlcpy((yyval.c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3181| 0| break; 3182| 0| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 0|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3182:11): [True: 0, False: 0] ------------------ 3183| 0| strlcpy((yyval.c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3184| 0| break; 3185| 0| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 0|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3185:11): [True: 0, False: 0] ------------------ 3186| 0| yr_free((yyval.c_string)); 3187| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3188| 0| compiler, "unknown type for argument 1 in function call"); 3189| 0| fail_with_error(ERROR_WRONG_TYPE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3190| 0| break; 3191| 0| default: ------------------ | Branch (3191:11): [True: 0, False: 0] ------------------ 3192| | // An unknown expression type is OK iff an error ocurred. 3193| 0| assert(compiler->last_error != ERROR_SUCCESS); ------------------ | Branch (3193:13): [True: 0, False: 0] | Branch (3193:13): [True: 0, False: 0] ------------------ 3194| 0| } 3195| 0| } 3196| 0|#line 3197 "libyara/grammar.c" 3197| 0| break; 3198| | 3199| 0| case 73: /* arguments_list: arguments_list ',' expression */ ------------------ | Branch (3199:3): [True: 0, False: 3] ------------------ 3200| 0|#line 1220 "libyara/grammar.y" 3201| 0| { 3202| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 3203| | 3204| 0| if (strlen((yyvsp[-2].c_string)) == YR_MAX_FUNCTION_ARGS) ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ | Branch (3204:13): [True: 0, False: 0] ------------------ 3205| 0| { 3206| 0| result = ERROR_TOO_MANY_ARGUMENTS; ------------------ | | 86| 0|#define ERROR_TOO_MANY_ARGUMENTS 39 ------------------ 3207| 0| } 3208| 0| else 3209| 0| { 3210| 0| switch((yyvsp[0].expression).type) 3211| 0| { 3212| 0| case EXPRESSION_TYPE_INTEGER: ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3212:13): [True: 0, False: 0] ------------------ 3213| 0| strlcat((yyvsp[-2].c_string), "i", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3214| 0| break; 3215| 0| case EXPRESSION_TYPE_FLOAT: ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (3215:13): [True: 0, False: 0] ------------------ 3216| 0| strlcat((yyvsp[-2].c_string), "f", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3217| 0| break; 3218| 0| case EXPRESSION_TYPE_BOOLEAN: ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3218:13): [True: 0, False: 0] ------------------ 3219| 0| strlcat((yyvsp[-2].c_string), "b", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3220| 0| break; 3221| 0| case EXPRESSION_TYPE_STRING: ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3221:13): [True: 0, False: 0] ------------------ 3222| 0| strlcat((yyvsp[-2].c_string), "s", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3223| 0| break; 3224| 0| case EXPRESSION_TYPE_REGEXP: ------------------ | | 49| 0|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (3224:13): [True: 0, False: 0] ------------------ 3225| 0| strlcat((yyvsp[-2].c_string), "r", YR_MAX_FUNCTION_ARGS); ------------------ | | 130| 0|#define YR_MAX_FUNCTION_ARGS 128 ------------------ 3226| 0| break; 3227| 0| case EXPRESSION_TYPE_UNKNOWN: ------------------ | | 45| 0|#define EXPRESSION_TYPE_UNKNOWN 0 ------------------ | Branch (3227:13): [True: 0, False: 0] ------------------ 3228| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 3229| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 3230| 0| compiler, "unknown type for argument %zu in function call", 3231| | // As we add one character per argument, the length of $1 is 3232| | // the number of arguments parsed so far, and the argument 3233| | // represented by is length of $1 plus one. 3234| 0| strlen((yyvsp[-2].c_string)) + 1); 3235| 0| break; 3236| 0| default: ------------------ | Branch (3236:13): [True: 0, False: 0] ------------------ 3237| | // An unknown expression type is OK iff an error ocurred. 3238| 0| assert(compiler->last_error != ERROR_SUCCESS); ------------------ | Branch (3238:15): [True: 0, False: 0] | Branch (3238:15): [True: 0, False: 0] ------------------ 3239| 0| } 3240| 0| } 3241| | 3242| 0| if (result != ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (3242:13): [True: 0, False: 0] ------------------ 3243| 0| yr_free((yyvsp[-2].c_string)); 3244| | 3245| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3246| | 3247| 0| (yyval.c_string) = (yyvsp[-2].c_string); 3248| 0| } 3249| 0|#line 3250 "libyara/grammar.c" 3250| 0| break; 3251| | 3252| 0| case 74: /* regexp: "regular expression" */ ------------------ | Branch (3252:3): [True: 0, False: 3] ------------------ 3253| 0|#line 1273 "libyara/grammar.y" 3254| 0| { 3255| 0| YR_ARENA_REF re_ref; 3256| 0| RE_ERROR error; 3257| | 3258| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 3259| 0| int re_flags = 0; 3260| 0| int parser_flags = RE_PARSER_FLAG_NONE; 3261| | 3262| 0| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_NO_CASE) ------------------ | | 39| 0|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ | Branch (3262:13): [True: 0, False: 0] ------------------ 3263| 0| re_flags |= RE_FLAGS_NO_CASE; ------------------ | | 98| 0|#define RE_FLAGS_NO_CASE 0x20 ------------------ 3264| | 3265| 0| if ((yyvsp[0].sized_string)->flags & SIZED_STRING_FLAGS_DOT_ALL) ------------------ | | 43| 0|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ | Branch (3265:13): [True: 0, False: 0] ------------------ 3266| 0| re_flags |= RE_FLAGS_DOT_ALL; ------------------ | | 100| 0|#define RE_FLAGS_DOT_ALL 0x80 ------------------ 3267| | 3268| 0| if (compiler->strict_escape) ------------------ | Branch (3268:13): [True: 0, False: 0] ------------------ 3269| 0| parser_flags |= RE_PARSER_FLAG_ENABLE_STRICT_ESCAPE_SEQUENCES; 3270| | 3271| 0| result = yr_re_compile( 3272| 0| (yyvsp[0].sized_string)->c_string, 3273| 0| re_flags, 3274| 0| parser_flags, 3275| 0| compiler->arena, 3276| 0| &re_ref, 3277| 0| &error); 3278| | 3279| 0| yr_free((yyvsp[0].sized_string)); 3280| | 3281| 0| if (result == ERROR_INVALID_REGULAR_EXPRESSION) ------------------ | | 54| 0|#define ERROR_INVALID_REGULAR_EXPRESSION 9 ------------------ | Branch (3281:13): [True: 0, False: 0] ------------------ 3282| 0| yr_compiler_set_error_extra_info(compiler, error.message); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3283| | 3284| 0| if (result == ERROR_SUCCESS || result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ if (result == ERROR_SUCCESS || result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (3284:13): [True: 0, False: 0] | Branch (3284:40): [True: 0, False: 0] ------------------ 3285| 0| { 3286| 0| if (result == ERROR_UNKNOWN_ESCAPE_SEQUENCE) ------------------ | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 ------------------ | Branch (3286:15): [True: 0, False: 0] ------------------ 3287| 0| { 3288| 0| yywarning( ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3289| 0| yyscanner, 3290| 0| "unknown escape sequence"); 3291| 0| } 3292| 0| result = yr_parser_emit_with_arg_reloc( 3293| 0| yyscanner, 3294| 0| OP_PUSH, ------------------ | | 61| 0|#define OP_PUSH 13 ------------------ 3295| 0| yr_arena_ref_to_ptr(compiler->arena, &re_ref), 3296| 0| NULL, 3297| 0| NULL); 3298| 0| } 3299| | 3300| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3301| | 3302| 0| (yyval.expression).type = EXPRESSION_TYPE_REGEXP; ------------------ | | 49| 0|#define EXPRESSION_TYPE_REGEXP 8 ------------------ 3303| 0| } 3304| 0|#line 3305 "libyara/grammar.c" 3305| 0| break; 3306| | 3307| 0| case 75: /* boolean_expression: expression */ ------------------ | Branch (3307:3): [True: 0, False: 3] ------------------ 3308| 0|#line 1328 "libyara/grammar.y" 3309| 0| { 3310| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (3310:13): [True: 0, False: 0] ------------------ 3311| 0| { 3312| 0| if (!YR_ARENA_IS_NULL_REF((yyvsp[0].expression).value.sized_string_ref)) ------------------ | | 49| 0| (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | (memcmp(&(ref), &YR_ARENA_NULL_REF, sizeof(YR_ARENA_NULL_REF)) == 0) | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ ------------------ | Branch (3312:15): [True: 0, False: 0] ------------------ 3313| 0| { 3314| 0| SIZED_STRING* sized_string = yr_arena_ref_to_ptr( 3315| 0| compiler->arena, &(yyvsp[0].expression).value.sized_string_ref); 3316| | 3317| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3318| 0| "using literal string \"%s\" in a boolean operation.", 3319| 0| sized_string->c_string); 3320| 0| } 3321| | 3322| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3323| 0| yyscanner, OP_STR_TO_BOOL, NULL)); 3324| 0| } 3325| 0| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_BOOLEAN) ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ | Branch (3325:13): [True: 0, False: 0] ------------------ 3326| 0| { 3327| 0| (yyval.expression).required_strings.count = 0; 3328| 0| } 3329| 0| else 3330| 0| { 3331| 0| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count; 3332| 0| } 3333| | 3334| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3335| 0| } 3336| 0|#line 3337 "libyara/grammar.c" 3337| 0| break; 3338| | 3339| 0| case 76: /* expression: "" */ ------------------ | Branch (3339:3): [True: 0, False: 3] ------------------ 3340| 0|#line 1359 "libyara/grammar.y" 3341| 0| { 3342| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, 1)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3343| | 3344| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3345| 0| (yyval.expression).required_strings.count = 0; 3346| 0| } 3347| 0|#line 3348 "libyara/grammar.c" 3348| 0| break; 3349| | 3350| 0| case 77: /* expression: "" */ ------------------ | Branch (3350:3): [True: 0, False: 3] ------------------ 3351| 0|#line 1366 "libyara/grammar.y" 3352| 0| { 3353| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, 0)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3354| | 3355| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3356| 0| (yyval.expression).required_strings.count = 0; 3357| 0| } 3358| 0|#line 3359 "libyara/grammar.c" 3359| 0| break; 3360| | 3361| 0| case 78: /* expression: primary_expression "" regexp */ ------------------ | Branch (3361:3): [True: 0, False: 3] ------------------ 3362| 0|#line 1373 "libyara/grammar.y" 3363| 0| { 3364| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "matches"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3365| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_REGEXP, "matches"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3366| | 3367| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3368| 0| yyscanner, 3369| 0| OP_MATCHES, 3370| 0| NULL)); 3371| | 3372| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3373| 0| (yyval.expression).required_strings.count = 0; 3374| 0| } 3375| 0|#line 3376 "libyara/grammar.c" 3376| 0| break; 3377| | 3378| 0| case 79: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3378:3): [True: 0, False: 3] ------------------ 3379| 0|#line 1386 "libyara/grammar.y" 3380| 0| { 3381| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3382| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "contains"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3383| | 3384| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3385| 0| yyscanner, OP_CONTAINS, NULL)); 3386| | 3387| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3388| 0| (yyval.expression).required_strings.count = 0; 3389| 0| } 3390| 0|#line 3391 "libyara/grammar.c" 3391| 0| break; 3392| | 3393| 0| case 80: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3393:3): [True: 0, False: 3] ------------------ 3394| 0|#line 1397 "libyara/grammar.y" 3395| 0| { 3396| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3397| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "icontains"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3398| | 3399| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3400| 0| yyscanner, OP_ICONTAINS, NULL)); 3401| | 3402| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3403| 0| (yyval.expression).required_strings.count = 0; 3404| 0| } 3405| 0|#line 3406 "libyara/grammar.c" 3406| 0| break; 3407| | 3408| 0| case 81: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3408:3): [True: 0, False: 3] ------------------ 3409| 0|#line 1408 "libyara/grammar.y" 3410| 0| { 3411| 0| check_type((yyvsp[-2].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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3412| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3413| | 3414| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3415| 0| yyscanner, OP_STARTSWITH, NULL)); 3416| | 3417| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3418| 0| (yyval.expression).required_strings.count = 0; 3419| 0| } 3420| 0|#line 3421 "libyara/grammar.c" 3421| 0| break; 3422| | 3423| 0| case 82: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3423:3): [True: 0, False: 3] ------------------ 3424| 0|#line 1419 "libyara/grammar.y" 3425| 0| { 3426| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3427| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3428| | 3429| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3430| 0| yyscanner, OP_ISTARTSWITH, NULL)); 3431| | 3432| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3433| 0| (yyval.expression).required_strings.count = 0; 3434| 0| } 3435| 0|#line 3436 "libyara/grammar.c" 3436| 0| break; 3437| | 3438| 0| case 83: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3438:3): [True: 0, False: 3] ------------------ 3439| 0|#line 1430 "libyara/grammar.y" 3440| 0| { 3441| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3442| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "endswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3443| | 3444| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3445| 0| yyscanner, OP_ENDSWITH, NULL)); 3446| | 3447| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3448| 0| (yyval.expression).required_strings.count = 0; 3449| 0| } 3450| 0|#line 3451 "libyara/grammar.c" 3451| 0| break; 3452| | 3453| 0| case 84: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3453:3): [True: 0, False: 3] ------------------ 3454| 0|#line 1441 "libyara/grammar.y" 3455| 0| { 3456| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3457| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_STRING, "iendswith"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3458| | 3459| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3460| 0| yyscanner, OP_IENDSWITH, NULL)); 3461| | 3462| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3463| 0| (yyval.expression).required_strings.count = 0; 3464| 0| } 3465| 0|#line 3466 "libyara/grammar.c" 3466| 0| break; 3467| | 3468| 0| case 85: /* expression: primary_expression "" primary_expression */ ------------------ | Branch (3468:3): [True: 0, False: 3] ------------------ 3469| 0|#line 1452 "libyara/grammar.y" 3470| 0| { 3471| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3472| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3473| | 3474| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3475| 0| yyscanner, OP_IEQUALS, NULL)); 3476| | 3477| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3478| 0| (yyval.expression).required_strings.count = 0; 3479| 0| } 3480| 0|#line 3481 "libyara/grammar.c" 3481| 0| break; 3482| | 3483| 0| case 86: /* expression: "string identifier" */ ------------------ | Branch (3483:3): [True: 0, False: 3] ------------------ 3484| 0|#line 1463 "libyara/grammar.y" 3485| 0| { 3486| 0| int result = yr_parser_reduce_string_identifier( 3487| 0| yyscanner, 3488| 0| (yyvsp[0].c_string), 3489| 0| OP_FOUND, ------------------ | | 70| 0|#define OP_FOUND 22 ------------------ 3490| 0| YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 3491| | 3492| 0| yr_free((yyvsp[0].c_string)); 3493| | 3494| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3495| | 3496| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3497| 0| (yyval.expression).required_strings.count = 1; 3498| 0| } 3499| 0|#line 3500 "libyara/grammar.c" 3500| 0| break; 3501| | 3502| 0| case 87: /* expression: "string identifier" "" primary_expression */ ------------------ | Branch (3502:3): [True: 0, False: 3] ------------------ 3503| 0|#line 1478 "libyara/grammar.y" 3504| 0| { 3505| 0| int result; 3506| | 3507| 0| check_type_with_cleanup((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "at", yr_free((yyvsp[-2].c_string))); ------------------ | | 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | 164| 0| break; \ | | 165| 0| } \ | | 166| 0| cleanup; \ | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | ------------------ | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | ------------------ | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 169| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 170| 0| } ------------------ 3508| | 3509| 0| result = yr_parser_reduce_string_identifier( 3510| 0| yyscanner, (yyvsp[-2].c_string), OP_FOUND_AT, (yyvsp[0].expression).value.integer); ------------------ | | 71| 0|#define OP_FOUND_AT 23 ------------------ 3511| | 3512| 0| yr_free((yyvsp[-2].c_string)); 3513| | 3514| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3515| | 3516| 0| (yyval.expression).required_strings.count = 1; 3517| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3518| 0| } 3519| 0|#line 3520 "libyara/grammar.c" 3520| 0| break; 3521| | 3522| 0| case 88: /* expression: "string identifier" "" range */ ------------------ | Branch (3522:3): [True: 0, False: 3] ------------------ 3523| 0|#line 1494 "libyara/grammar.y" 3524| 0| { 3525| 0| int result = yr_parser_reduce_string_identifier( 3526| 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 ------------------ 3527| | 3528| 0| yr_free((yyvsp[-2].c_string)); 3529| | 3530| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3531| | 3532| 0| (yyval.expression).required_strings.count = 1; 3533| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3534| 0| } 3535| 0|#line 3536 "libyara/grammar.c" 3536| 0| break; 3537| | 3538| 0| case 89: /* expression: "" for_expression error */ ------------------ | Branch (3538:3): [True: 0, False: 3] ------------------ 3539| 0|#line 1506 "libyara/grammar.y" 3540| 0| { 3541| | // Free all the loop variable identifiers, including the variables for 3542| | // the current loop (represented by loop_index), and set loop_index to 3543| | // -1. This is OK even if we have nested loops. If an error occurs while 3544| | // parsing the inner loop, it will be propagated to the outer loop 3545| | // anyways, so it's safe to do this cleanup while processing the error 3546| | // for the inner loop. 3547| | 3548| 0| for (int i = 0; i <= compiler->loop_index; i++) ------------------ | Branch (3548:25): [True: 0, False: 0] ------------------ 3549| 0| { 3550| 0| loop_vars_cleanup(i); ------------------ | | 179| 0| { \ | | 180| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 0| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 0, False: 0] | | ------------------ | | 182| 0| { \ | | 183| 0| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 0| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 0| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | 186| 0| } \ | | 187| 0| loop_ctx->vars_count = 0; \ | | 188| 0| } \ ------------------ 3551| 0| } 3552| | 3553| 0| compiler->loop_index = -1; 3554| 0| YYERROR; ------------------ | | 1314| 0|#define YYERROR goto yyerrorlab ------------------ 3555| 0| } 3556| 0|#line 3557 "libyara/grammar.c" 3557| 0| break; 3558| | 3559| 0| case 90: /* $@6: %empty */ ------------------ | Branch (3559:3): [True: 0, False: 3] ------------------ 3560| 0|#line 1580 "libyara/grammar.y" 3561| 0| { 3562| | // var_frame is used for accessing local variables used in this loop. 3563| | // All local variables are accessed using var_frame as a reference, 3564| | // like var_frame + 0, var_frame + 1, etc. Here we initialize var_frame 3565| | // with the correct value, which depends on the number of variables 3566| | // defined by any outer loops. 3567| | 3568| 0| int var_frame; 3569| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 3570| | 3571| 0| if (compiler->loop_index + 1 == YR_MAX_LOOP_NESTING) ------------------ | | 95| 0|#define YR_MAX_LOOP_NESTING 4 ------------------ | Branch (3571:13): [True: 0, False: 0] ------------------ 3572| 0| result = ERROR_LOOP_NESTING_LIMIT_EXCEEDED; ------------------ | | 57| 0|#define ERROR_LOOP_NESTING_LIMIT_EXCEEDED 12 ------------------ 3573| | 3574| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3575| | 3576| 0| compiler->loop_index++; 3577| | 3578| | // This loop uses internal variables besides the ones explicitly 3579| | // defined by the user. 3580| 0| compiler->loop[compiler->loop_index].vars_internal_count = \ 3581| 0| YR_INTERNAL_LOOP_VARS; ------------------ | | 76| 0|#define YR_INTERNAL_LOOP_VARS 3 ------------------ 3582| | 3583| | // Initialize the number of variables, this number will be incremented 3584| | // as variable declaration are processed by for_variables. 3585| 0| compiler->loop[compiler->loop_index].vars_count = 0; 3586| | 3587| 0| var_frame = _yr_compiler_get_var_frame(compiler); 3588| | 3589| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3590| 0| yyscanner, OP_CLEAR_M, var_frame + 0, NULL, NULL)); 3591| | 3592| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3593| 0| yyscanner, OP_CLEAR_M, var_frame + 1, NULL, NULL)); 3594| | 3595| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3596| 0| yyscanner, OP_POP_M, var_frame + 2, NULL, NULL)); 3597| 0| } 3598| 0|#line 3599 "libyara/grammar.c" 3599| 0| break; 3600| | 3601| 0| case 91: /* $@7: %empty */ ------------------ | Branch (3601:3): [True: 0, False: 3] ------------------ 3602| 0|#line 1618 "libyara/grammar.y" 3603| 0| { 3604| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 3605| 0| YR_FIXUP* fixup; 3606| | 3607| 0| YR_ARENA_REF loop_start_ref; 3608| 0| YR_ARENA_REF jmp_offset_ref; 3609| | 3610| 0| int var_frame = _yr_compiler_get_var_frame(compiler); 3611| | 3612| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3613| 0| yyscanner, OP_ITER_NEXT, &loop_start_ref)); 3614| | 3615| | // For each variable generate an instruction that pops the value from 3616| | // the stack and store it into one memory slot starting at var_frame + 3617| | // YR_INTERNAL_LOOP_VARS because the first YR_INTERNAL_LOOP_VARS slots 3618| | // in the frame are for the internal variables. 3619| | 3620| 0| for (int i = 0; i < loop_ctx->vars_count; i++) ------------------ | Branch (3620:25): [True: 0, False: 0] ------------------ 3621| 0| { 3622| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3623| 0| yyscanner, 3624| 0| OP_POP_M, 3625| 0| var_frame + YR_INTERNAL_LOOP_VARS + i, 3626| 0| NULL, 3627| 0| NULL)); 3628| 0| } 3629| | 3630| 0| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3631| 0| yyscanner, 3632| 0| OP_JTRUE_P, 3633| 0| 0, // still don't know the jump offset, use 0 for now. 3634| 0| NULL, 3635| 0| &jmp_offset_ref)); 3636| | 3637| | // We still don't know the jump's target, so we push a fixup entry 3638| | // in the stack, so that the jump's offset can be set once we know it. 3639| | 3640| 0| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3641| | 3642| 0| if (fixup == NULL) ------------------ | Branch (3642:13): [True: 0, False: 0] ------------------ 3643| 0| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3644| | 3645| 0| fixup->ref = jmp_offset_ref; 3646| 0| fixup->next = compiler->fixup_stack_head; 3647| 0| compiler->fixup_stack_head = fixup; 3648| | 3649| 0| loop_ctx->start_ref = loop_start_ref; 3650| 0| } 3651| 0|#line 3652 "libyara/grammar.c" 3652| 0| break; 3653| | 3654| 0| case 92: /* expression: "" for_expression $@6 for_iteration ':' $@7 '(' boolean_expression ')' */ ------------------ | Branch (3654:3): [True: 0, False: 3] ------------------ 3655| 0|#line 1667 "libyara/grammar.y" 3656| 0| { 3657| 0| int32_t jmp_offset; 3658| 0| YR_FIXUP* fixup; 3659| 0| YR_ARENA_REF pop_ref; 3660| | 3661| 0| int var_frame = _yr_compiler_get_var_frame(compiler); 3662| | 3663| 0| if ((yyvsp[-5].integer) == FOR_ITERATION_STRING_SET) ------------------ | | 113| 0|#define FOR_ITERATION_STRING_SET 2 ------------------ | Branch (3663:13): [True: 0, False: 0] ------------------ 3664| 0| { 3665| 0| compiler->loop_for_of_var_index = -1; 3666| 0| } 3667| | 3668| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3669| 0| yyscanner, OP_INCR_M, var_frame + 1, NULL, NULL)); 3670| | 3671| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3672| 0| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3673| | 3674| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3675| 0| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3676| | 3677| 0| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_CONDITION, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3678| | 3679| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3680| 0| yyscanner, OP_ADD_M, var_frame + 0, NULL, NULL)); 3681| | 3682| 0| jmp_offset = \ 3683| 0| compiler->loop[compiler->loop_index].start_ref.offset - 3684| 0| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION); ------------------ | | 63| 0|#define YR_CODE_SECTION 6 ------------------ 3685| | 3686| 0| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3687| 0| yyscanner, 3688| 0| OP_JTRUE_P, 3689| 0| jmp_offset, 3690| 0| NULL, 3691| 0| NULL)); 3692| | 3693| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3694| 0| yyscanner, OP_POP, &pop_ref)); 3695| | 3696| | // Pop from the stack the fixup entry containing the reference to 3697| | // the jump offset that needs to be fixed. 3698| | 3699| 0| fixup = compiler->fixup_stack_head; 3700| 0| compiler->fixup_stack_head = fixup->next; 3701| | 3702| | // The fixup entry has a reference to the jump offset that need 3703| | // to be fixed, convert the address into a pointer. 3704| 0| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3705| 0| compiler->arena, &fixup->ref); 3706| | 3707| | // The reference in the fixup entry points to the jump's offset 3708| | // but the jump instruction is one byte before, that's why we add 3709| | // one to the offset. 3710| 0| jmp_offset = pop_ref.offset - fixup->ref.offset + 1; 3711| | 3712| | // Fix the jump's offset. 3713| 0| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3714| | 3715| 0| yr_free(fixup); 3716| | 3717| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3718| 0| yyscanner, OP_PUSH_M, var_frame + 1, NULL, NULL)); 3719| | 3720| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3721| 0| yyscanner, OP_PUSH_M, var_frame + 0, NULL, NULL)); 3722| | 3723| 0| fail_if_error(yr_parser_emit_with_arg( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3724| 0| yyscanner, OP_PUSH_M, var_frame + 2, NULL, NULL)); 3725| | 3726| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3727| 0| yyscanner, OP_ITER_END, NULL)); 3728| | 3729| 0| loop_vars_cleanup(compiler->loop_index); ------------------ | | 179| 0| { \ | | 180| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[loop_index]; \ | | 181| 0| for (int i = 0; i < loop_ctx->vars_count; i++) \ | | ------------------ | | | Branch (181:23): [True: 0, False: 0] | | ------------------ | | 182| 0| { \ | | 183| 0| yr_free((void*) loop_ctx->vars[i].identifier.ptr); \ | | 184| 0| loop_ctx->vars[i].identifier.ptr = NULL; \ | | 185| 0| loop_ctx->vars[i].identifier.ref = YR_ARENA_NULL_REF; \ | | ------------------ | | | | 43| 0| (YR_ARENA_REF) \ | | | | 44| 0| { \ | | | | 45| 0| UINT32_MAX, UINT32_MAX \ | | | | 46| 0| } | | ------------------ | | 186| 0| } \ | | 187| 0| loop_ctx->vars_count = 0; \ | | 188| 0| } \ ------------------ 3730| | 3731| 0| compiler->loop_index--; 3732| | 3733| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3734| 0| (yyval.expression).required_strings.count = 0; 3735| 0| } 3736| 0|#line 3737 "libyara/grammar.c" 3737| 0| break; 3738| | 3739| 0| case 93: /* expression: for_expression "" string_set */ ------------------ | Branch (3739:3): [True: 0, False: 3] ------------------ 3740| 0|#line 1748 "libyara/grammar.y" 3741| 0| { 3742| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].string_set).count) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3742:13): [True: 0, False: 0] | Branch (3742:71): [True: 0, False: 0] ------------------ 3743| 0| { 3744| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3745| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].string_set).count); 3746| 0| } 3747| | 3748| 0| if (((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > 0) || ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3748:14): [True: 0, False: 0] | Branch (3748:72): [True: 0, False: 0] ------------------ 3749| 0| ((yyvsp[-2].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3749:16): [True: 0, False: 0] ------------------ 3750| 0| ((yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 0|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-2].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 0|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3750:20): [True: 0, False: 0] | Branch (3750:82): [True: 0, False: 0] ------------------ 3751| 0| { 3752| 0| (yyval.expression).required_strings.count = 1; 3753| 0| } 3754| 0| else 3755| 0| { 3756| 0| (yyval.expression).required_strings.count = 0; 3757| 0| } 3758| | 3759| 0| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 74| 0|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_STRING_SET, NULL, NULL); ------------------ | | 42| 0|#define OF_STRING_SET 0 ------------------ 3760| | 3761| 0| yr_string_set_destroy((yyvsp[0].string_set)); 3762| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3763| 0| } 3764| 0|#line 3765 "libyara/grammar.c" 3765| 0| break; 3766| | 3767| 0| case 94: /* expression: for_expression "" rule_set */ ------------------ | Branch (3767:3): [True: 0, False: 3] ------------------ 3768| 0|#line 1772 "libyara/grammar.y" 3769| 0| { 3770| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-2].expression).value.integer > (yyvsp[0].integer)) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3770:13): [True: 0, False: 0] | Branch (3770:71): [True: 0, False: 0] ------------------ 3771| 0| { 3772| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3773| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-2].expression).value.integer, (yyvsp[0].integer)); 3774| 0| } 3775| 0| yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 74| 0|#define OP_OF 26 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 0|#define OF_RULE_SET 1 ------------------ 3776| | 3777| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3778| 0| (yyval.expression).required_strings.count = 0; 3779| 0| } 3780| 0|#line 3781 "libyara/grammar.c" 3781| 0| break; 3782| | 3783| 0| case 95: /* expression: primary_expression '%' "" string_set */ ------------------ | Branch (3783:3): [True: 0, False: 3] ------------------ 3784| 0|#line 1784 "libyara/grammar.y" 3785| 0| { 3786| 0| check_type_with_cleanup((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%", yr_string_set_destroy((yyvsp[0].string_set))); ------------------ | | 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 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( \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | 164| 0| break; \ | | 165| 0| } \ | | 166| 0| cleanup; \ | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | ------------------ | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | ------------------ | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 169| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 170| 0| } ------------------ 3787| | 3788| | // The value of primary_expression can be undefined because 3789| | // it could be a variable for which don't know the value during 3790| | // compiling time. However, if the value is defined it should be 3791| | // in the range [1,100]. 3792| 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 (3792:13): [True: 0, False: 0] ------------------ 3793| 0| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3793:14): [True: 0, False: 0] | Branch (3793:58): [True: 0, False: 0] ------------------ 3794| 0| { 3795| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3796| 0| compiler, "percentage must be between 1 and 100 (inclusive)"); 3797| | 3798| 0| yr_string_set_destroy((yyvsp[0].string_set)); 3799| 0| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3800| 0| } 3801| | 3802| 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 (3802:13): [True: 0, False: 0] ------------------ 3803| 0| { 3804| 0| (yyval.expression).required_strings.count = 1; 3805| 0| } 3806| 0| else 3807| 0| { 3808| 0| (yyval.expression).required_strings.count = 0; 3809| 0| } 3810| | 3811| 0| yr_string_set_destroy((yyvsp[0].string_set)); 3812| 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 ------------------ 3813| 0| } 3814| 0|#line 3815 "libyara/grammar.c" 3815| 0| break; 3816| | 3817| 0| case 96: /* expression: primary_expression '%' "" rule_set */ ------------------ | Branch (3817:3): [True: 0, False: 3] ------------------ 3818| 0|#line 1814 "libyara/grammar.y" 3819| 0| { 3820| 0| check_type((yyvsp[-3].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 3821| | 3822| | // The value of primary_expression can be undefined because 3823| | // it could be a variable for which don't know the value during 3824| | // compiling time. However, if the value is defined it should be 3825| | // in the range [1,100]. 3826| 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 (3826:13): [True: 0, False: 0] ------------------ 3827| 0| ((yyvsp[-3].expression).value.integer < 1 || (yyvsp[-3].expression).value.integer > 100)) ------------------ | Branch (3827:14): [True: 0, False: 0] | Branch (3827:58): [True: 0, False: 0] ------------------ 3828| 0| { 3829| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3830| 0| compiler, "percentage must be between 1 and 100 (inclusive)"); 3831| | 3832| 0| fail_with_error(ERROR_INVALID_PERCENTAGE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3833| 0| } 3834| | 3835| 0| yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 122| 0|#define OP_OF_PERCENT 74 ------------------ yr_parser_emit_with_arg(yyscanner, OP_OF_PERCENT, OF_RULE_SET, NULL, NULL); ------------------ | | 43| 0|#define OF_RULE_SET 1 ------------------ 3836| 0| } 3837| 0|#line 3838 "libyara/grammar.c" 3838| 0| break; 3839| | 3840| 0| case 97: /* expression: for_expression "" string_set "" range */ ------------------ | Branch (3840:3): [True: 0, False: 3] ------------------ 3841| 0|#line 1833 "libyara/grammar.y" 3842| 0| { 3843| 0| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].string_set).count) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3843:13): [True: 0, False: 0] | Branch (3843:71): [True: 0, False: 0] ------------------ 3844| 0| { 3845| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3846| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].string_set).count); 3847| 0| } 3848| | 3849| 0| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > 0) || ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3849:14): [True: 0, False: 0] | Branch (3849:72): [True: 0, False: 0] ------------------ 3850| 0| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3850:16): [True: 0, False: 0] ------------------ 3851| 0| ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 0|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 0|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3851:20): [True: 0, False: 0] | Branch (3851:82): [True: 0, False: 0] ------------------ 3852| 0| { 3853| 0| (yyval.expression).required_strings.count = 1; 3854| 0| } 3855| 0| else 3856| 0| { 3857| 0| (yyval.expression).required_strings.count = 0; 3858| 0| } 3859| | 3860| 0| yr_parser_emit(yyscanner, OP_OF_FOUND_IN, NULL); ------------------ | | 123| 0|#define OP_OF_FOUND_IN 75 ------------------ 3861| | 3862| | // Mark strings as non-fast strings (since we need to check all matches whether they are in range) 3863| 0| yr_parser_mark_nonfast(yyscanner, (yyvsp[-2].string_set)); 3864| | 3865| 0| yr_string_set_destroy((yyvsp[-2].string_set)); 3866| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3867| 0| } 3868| 0|#line 3869 "libyara/grammar.c" 3869| 0| break; 3870| | 3871| 0| case 98: /* expression: for_expression "" string_set "" primary_expression */ ------------------ | Branch (3871:3): [True: 0, False: 3] ------------------ 3872| 0|#line 1860 "libyara/grammar.y" 3873| 0| { 3874| 0| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3874:13): [True: 0, False: 0] ------------------ 3875| 0| { 3876| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 3877| 0| "at expression must be an integer"); 3878| | 3879| 0| yr_string_set_destroy((yyvsp[-2].string_set)); 3880| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3881| 0| } 3882| | 3883| 0| if ((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > (yyvsp[-2].string_set).count) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3883:13): [True: 0, False: 0] | Branch (3883:71): [True: 0, False: 0] ------------------ 3884| 0| { 3885| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3886| 0| "expression always false - requesting %" PRId64 " of %" PRId64 ".", (yyvsp[-4].expression).value.integer, (yyvsp[-2].string_set).count); 3887| 0| } 3888| | 3889| | // Both of these are warnings: 3890| | // 3891| | // "N of them at 0" where N > 1 3892| | // 3893| | //"all of them at 0" where there is more than 1 in "them". 3894| | // 3895| | // This means you can do "all of them at 0" if you only have one string 3896| | // defined in the set. 3897| 0| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3897:14): [True: 0, False: 0] ------------------ 3898| 0| !IS_UNDEFINED((yyvsp[-4].expression).value.integer) && (yyvsp[-4].expression).value.integer > 1) || ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (3898:15): [True: 0, False: 0] | Branch (3898:70): [True: 0, False: 0] ------------------ 3899| 0| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3899:16): [True: 0, False: 0] ------------------ 3900| 0| (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL && (yyvsp[-2].string_set).count > 1)) ------------------ | | 108| 0|#define FOR_EXPRESSION_ALL 1 ------------------ | Branch (3900:15): [True: 0, False: 0] | Branch (3900:77): [True: 0, False: 0] ------------------ 3901| 0| { 3902| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 3903| 0| "multiple strings at an offset is usually false."); 3904| 0| } 3905| | 3906| 0| if (((yyvsp[-4].expression).type == EXPRESSION_TYPE_INTEGER && (yyvsp[-4].expression).value.integer > 0) || ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (3906:14): [True: 0, False: 0] | Branch (3906:72): [True: 0, False: 0] ------------------ 3907| 0| ((yyvsp[-4].expression).type == EXPRESSION_TYPE_QUANTIFIER && ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ | Branch (3907:16): [True: 0, False: 0] ------------------ 3908| 0| ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 108| 0|#define FOR_EXPRESSION_ALL 1 ------------------ ((yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ALL || (yyvsp[-4].expression).value.integer == FOR_EXPRESSION_ANY))) ------------------ | | 109| 0|#define FOR_EXPRESSION_ANY 2 ------------------ | Branch (3908:20): [True: 0, False: 0] | Branch (3908:82): [True: 0, False: 0] ------------------ 3909| 0| { 3910| 0| (yyval.expression).required_strings.count = 1; 3911| 0| } 3912| 0| else 3913| 0| { 3914| 0| (yyval.expression).required_strings.count = 0; 3915| 0| } 3916| | 3917| 0| yr_parser_emit(yyscanner, OP_OF_FOUND_AT, NULL); ------------------ | | 127| 0|#define OP_OF_FOUND_AT 79 ------------------ 3918| | 3919| | // Mark strings as non-fast strings (since we need to check all matches whether they are at location) 3920| 0| yr_parser_mark_nonfast(yyscanner, (yyvsp[-2].string_set)); 3921| | 3922| 0| yr_string_set_destroy((yyvsp[-2].string_set)); 3923| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3924| 0| } 3925| 0|#line 3926 "libyara/grammar.c" 3926| 0| break; 3927| | 3928| 0| case 99: /* expression: "" boolean_expression */ ------------------ | Branch (3928:3): [True: 0, False: 3] ------------------ 3929| 0|#line 1913 "libyara/grammar.y" 3930| 0| { 3931| 0| yr_parser_emit(yyscanner, OP_NOT, NULL); ------------------ | | 51| 0|#define OP_NOT 3 ------------------ 3932| | 3933| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3934| 0| (yyval.expression).required_strings.count = 0; 3935| 0| } 3936| 0|#line 3937 "libyara/grammar.c" 3937| 0| break; 3938| | 3939| 0| case 100: /* expression: "" boolean_expression */ ------------------ | Branch (3939:3): [True: 0, False: 3] ------------------ 3940| 0|#line 1920 "libyara/grammar.y" 3941| 0| { 3942| 0| yr_parser_emit(yyscanner, OP_DEFINED, NULL); ------------------ | | 125| 0|#define OP_DEFINED 77 ------------------ 3943| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3944| 0| (yyval.expression).required_strings.count = 0; 3945| 0| } 3946| 0|#line 3947 "libyara/grammar.c" 3947| 0| break; 3948| | 3949| 0| case 101: /* $@8: %empty */ ------------------ | Branch (3949:3): [True: 0, False: 3] ------------------ 3950| 0|#line 1926 "libyara/grammar.y" 3951| 0| { 3952| 0| YR_FIXUP* fixup; 3953| 0| YR_ARENA_REF jmp_offset_ref; 3954| | 3955| 0| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3956| 0| yyscanner, 3957| 0| OP_JFALSE, 3958| 0| 0, // still don't know the jump offset, use 0 for now. 3959| 0| NULL, 3960| 0| &jmp_offset_ref)); 3961| | 3962| | // Create a fixup entry for the jump and push it in the stack. 3963| 0| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 3964| | 3965| 0| if (fixup == NULL) ------------------ | Branch (3965:13): [True: 0, False: 0] ------------------ 3966| 0| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 3967| | 3968| 0| fixup->ref = jmp_offset_ref; 3969| 0| fixup->next = compiler->fixup_stack_head; 3970| 0| compiler->fixup_stack_head = fixup; 3971| 0| } 3972| 0|#line 3973 "libyara/grammar.c" 3973| 0| break; 3974| | 3975| 0| case 102: /* expression: boolean_expression "" $@8 boolean_expression */ ------------------ | Branch (3975:3): [True: 0, False: 3] ------------------ 3976| 0|#line 1948 "libyara/grammar.y" 3977| 0| { 3978| 0| YR_FIXUP* fixup; 3979| | 3980| 0| fail_if_error(yr_parser_emit(yyscanner, OP_AND, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 3981| | 3982| 0| fixup = compiler->fixup_stack_head; 3983| | 3984| 0| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 3985| 0| compiler->arena, &fixup->ref); 3986| | 3987| 0| int32_t jmp_offset = \ 3988| 0| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 0|#define YR_CODE_SECTION 6 ------------------ 3989| 0| fixup->ref.offset + 1; 3990| | 3991| 0| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 3992| | 3993| | // Remove fixup from the stack. 3994| 0| compiler->fixup_stack_head = fixup->next; 3995| 0| yr_free(fixup); 3996| | 3997| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 3998| 0| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count + (yyvsp[-3].expression).required_strings.count; 3999| 0| } 4000| 0|#line 4001 "libyara/grammar.c" 4001| 0| break; 4002| | 4003| 0| case 103: /* $@9: %empty */ ------------------ | Branch (4003:3): [True: 0, False: 3] ------------------ 4004| 0|#line 1972 "libyara/grammar.y" 4005| 0| { 4006| 0| YR_FIXUP* fixup; 4007| 0| YR_ARENA_REF jmp_offset_ref; 4008| | 4009| 0| fail_if_error(yr_parser_emit_with_arg_int32( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4010| 0| yyscanner, 4011| 0| OP_JTRUE, 4012| 0| 0, // still don't know the jump destination, use 0 for now. 4013| 0| NULL, 4014| 0| &jmp_offset_ref)); 4015| | 4016| 0| fixup = (YR_FIXUP*) yr_malloc(sizeof(YR_FIXUP)); 4017| | 4018| 0| if (fixup == NULL) ------------------ | Branch (4018:13): [True: 0, False: 0] ------------------ 4019| 0| fail_with_error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4020| | 4021| 0| fixup->ref = jmp_offset_ref; 4022| 0| fixup->next = compiler->fixup_stack_head; 4023| 0| compiler->fixup_stack_head = fixup; 4024| 0| } 4025| 0|#line 4026 "libyara/grammar.c" 4026| 0| break; 4027| | 4028| 0| case 104: /* expression: boolean_expression "" $@9 boolean_expression */ ------------------ | Branch (4028:3): [True: 0, False: 3] ------------------ 4029| 0|#line 1993 "libyara/grammar.y" 4030| 0| { 4031| 0| YR_FIXUP* fixup; 4032| | 4033| 0| fail_if_error(yr_parser_emit(yyscanner, OP_OR, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4034| | 4035| 0| fixup = compiler->fixup_stack_head; 4036| | 4037| 0| int32_t jmp_offset = \ 4038| 0| yr_arena_get_current_offset(compiler->arena, YR_CODE_SECTION) - ------------------ | | 63| 0|#define YR_CODE_SECTION 6 ------------------ 4039| 0| fixup->ref.offset + 1; 4040| | 4041| 0| int32_t* jmp_offset_addr = (int32_t*) yr_arena_ref_to_ptr( 4042| 0| compiler->arena, &fixup->ref); 4043| | 4044| 0| memcpy(jmp_offset_addr, &jmp_offset, sizeof(jmp_offset)); 4045| | 4046| | // Remove fixup from the stack. 4047| 0| compiler->fixup_stack_head = fixup->next; 4048| 0| yr_free(fixup); 4049| | 4050| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4051| | 4052| | // Set required string count to minimum from both parts 4053| 0| if ((yyvsp[-3].expression).required_strings.count > (yyvsp[0].expression).required_strings.count) { ------------------ | Branch (4053:13): [True: 0, False: 0] ------------------ 4054| 0| (yyval.expression).required_strings.count = (yyvsp[0].expression).required_strings.count; 4055| 0| } else { 4056| 0| (yyval.expression).required_strings.count = (yyvsp[-3].expression).required_strings.count; 4057| 0| } 4058| 0| } 4059| 0|#line 4060 "libyara/grammar.c" 4060| 0| break; 4061| | 4062| 0| case 105: /* expression: primary_expression "<" primary_expression */ ------------------ | Branch (4062:3): [True: 0, False: 3] ------------------ 4063| 0|#line 2023 "libyara/grammar.y" 4064| 0| { 4065| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4066| 0| yyscanner, "<", (yyvsp[-2].expression), (yyvsp[0].expression))); 4067| | 4068| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4069| 0| (yyval.expression).required_strings.count = 0; 4070| 0| } 4071| 0|#line 4072 "libyara/grammar.c" 4072| 0| break; 4073| | 4074| 0| case 106: /* expression: primary_expression ">" primary_expression */ ------------------ | Branch (4074:3): [True: 0, False: 3] ------------------ 4075| 0|#line 2031 "libyara/grammar.y" 4076| 0| { 4077| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4078| 0| yyscanner, ">", (yyvsp[-2].expression), (yyvsp[0].expression))); 4079| | 4080| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4081| 0| (yyval.expression).required_strings.count = 0; 4082| 0| } 4083| 0|#line 4084 "libyara/grammar.c" 4084| 0| break; 4085| | 4086| 0| case 107: /* expression: primary_expression "<=" primary_expression */ ------------------ | Branch (4086:3): [True: 0, False: 3] ------------------ 4087| 0|#line 2039 "libyara/grammar.y" 4088| 0| { 4089| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4090| 0| yyscanner, "<=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4091| | 4092| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4093| 0| (yyval.expression).required_strings.count = 0; 4094| 0| } 4095| 0|#line 4096 "libyara/grammar.c" 4096| 0| break; 4097| | 4098| 0| case 108: /* expression: primary_expression ">=" primary_expression */ ------------------ | Branch (4098:3): [True: 0, False: 3] ------------------ 4099| 0|#line 2047 "libyara/grammar.y" 4100| 0| { 4101| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4102| 0| yyscanner, ">=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4103| | 4104| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4105| 0| (yyval.expression).required_strings.count = 0; 4106| 0| } 4107| 0|#line 4108 "libyara/grammar.c" 4108| 0| break; 4109| | 4110| 0| case 109: /* expression: primary_expression "==" primary_expression */ ------------------ | Branch (4110:3): [True: 0, False: 3] ------------------ 4111| 0|#line 2055 "libyara/grammar.y" 4112| 0| { 4113| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4114| 0| yyscanner, "==", (yyvsp[-2].expression), (yyvsp[0].expression))); 4115| | 4116| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4117| 0| (yyval.expression).required_strings.count = 0; 4118| 0| } 4119| 0|#line 4120 "libyara/grammar.c" 4120| 0| break; 4121| | 4122| 0| case 110: /* expression: primary_expression "!=" primary_expression */ ------------------ | Branch (4122:3): [True: 0, False: 3] ------------------ 4123| 0|#line 2063 "libyara/grammar.y" 4124| 0| { 4125| 0| fail_if_error(yr_parser_reduce_operation( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4126| 0| yyscanner, "!=", (yyvsp[-2].expression), (yyvsp[0].expression))); 4127| | 4128| 0| (yyval.expression).type = EXPRESSION_TYPE_BOOLEAN; ------------------ | | 46| 0|#define EXPRESSION_TYPE_BOOLEAN 1 ------------------ 4129| 0| (yyval.expression).required_strings.count = 0; 4130| 0| } 4131| 0|#line 4132 "libyara/grammar.c" 4132| 0| break; 4133| | 4134| 0| case 111: /* expression: primary_expression */ ------------------ | Branch (4134:3): [True: 0, False: 3] ------------------ 4135| 0|#line 2071 "libyara/grammar.y" 4136| 0| { 4137| 0| (yyval.expression) = (yyvsp[0].expression); 4138| 0| } 4139| 0|#line 4140 "libyara/grammar.c" 4140| 0| break; 4141| | 4142| 0| case 112: /* expression: '(' expression ')' */ ------------------ | Branch (4142:3): [True: 0, False: 3] ------------------ 4143| 0|#line 2075 "libyara/grammar.y" 4144| 0| { 4145| 0| (yyval.expression) = (yyvsp[-1].expression); 4146| 0| } 4147| 0|#line 4148 "libyara/grammar.c" 4148| 0| break; 4149| | 4150| 0| case 113: /* for_iteration: for_variables "" iterator */ ------------------ | Branch (4150:3): [True: 0, False: 3] ------------------ 4151| 0|#line 2082 "libyara/grammar.y" 4152| 0| { (yyval.integer) = FOR_ITERATION_ITERATOR; } ------------------ | | 112| 0|#define FOR_ITERATION_ITERATOR 1 ------------------ 4153| 0|#line 4154 "libyara/grammar.c" 4154| 0| break; 4155| | 4156| 0| case 114: /* for_iteration: "" string_iterator */ ------------------ | Branch (4156:3): [True: 0, False: 3] ------------------ 4157| 0|#line 2084 "libyara/grammar.y" 4158| 0| { 4159| 0| int var_frame; 4160| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4161| | 4162| 0| if (compiler->loop_for_of_var_index != -1) ------------------ | Branch (4162:13): [True: 0, False: 0] ------------------ 4163| 0| result = ERROR_NESTED_FOR_OF_LOOP; ------------------ | | 79| 0|#define ERROR_NESTED_FOR_OF_LOOP 32 ------------------ 4164| | 4165| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4166| | 4167| | // Simulate that we have 1 variable with string loops 4168| 0| compiler->loop[compiler->loop_index].vars_count = 1; 4169| | 4170| | // Set where we can find our string in case $ is in 4171| | // the body of the loop 4172| 0| var_frame = _yr_compiler_get_var_frame(compiler); 4173| 0| compiler->loop_for_of_var_index = var_frame + 4174| 0| compiler->loop[compiler->loop_index].vars_internal_count; 4175| | 4176| 0| (yyval.integer) = FOR_ITERATION_STRING_SET; ------------------ | | 113| 0|#define FOR_ITERATION_STRING_SET 2 ------------------ 4177| 0| } 4178| 0|#line 4179 "libyara/grammar.c" 4179| 0| break; 4180| | 4181| 0| case 115: /* for_variables: "identifier" */ ------------------ | Branch (4181:3): [True: 0, False: 3] ------------------ 4182| 0|#line 2109 "libyara/grammar.y" 4183| 0| { 4184| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4185| | 4186| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4187| | 4188| 0| if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4188:13): [True: 0, False: 0] ------------------ 4189| 0| { 4190| 0| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4191| 0| yr_free((yyvsp[0].c_string)); 4192| | 4193| 0| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 0|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4194| 0| } 4195| | 4196| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4197| | 4198| 0| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4199| | 4200| 0| assert(loop_ctx->vars_count <= YR_MAX_LOOP_VARS); ------------------ | Branch (4200:9): [True: 0, False: 0] | Branch (4200:9): [True: 0, False: 0] ------------------ 4201| 0| } 4202| 0|#line 4203 "libyara/grammar.c" 4203| 0| break; 4204| | 4205| 0| case 116: /* for_variables: for_variables ',' "identifier" */ ------------------ | Branch (4205:3): [True: 0, False: 3] ------------------ 4206| 0|#line 2129 "libyara/grammar.y" 4207| 0| { 4208| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4209| | 4210| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4211| | 4212| 0| if (loop_ctx->vars_count == YR_MAX_LOOP_VARS) ------------------ | | 102| 0|#define YR_MAX_LOOP_VARS 2 ------------------ | Branch (4212:13): [True: 0, False: 0] ------------------ 4213| 0| { 4214| 0| yr_compiler_set_error_extra_info(compiler, "too many loop variables"); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4215| 0| yr_free((yyvsp[0].c_string)); 4216| | 4217| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4218| 0| } 4219| 0| else if (yr_parser_lookup_loop_variable(yyscanner, (yyvsp[0].c_string), NULL) >= 0) ------------------ | Branch (4219:18): [True: 0, False: 0] ------------------ 4220| 0| { 4221| 0| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4222| 0| yr_free((yyvsp[0].c_string)); 4223| | 4224| 0| result = ERROR_DUPLICATED_LOOP_IDENTIFIER; ------------------ | | 58| 0|#define ERROR_DUPLICATED_LOOP_IDENTIFIER 13 ------------------ 4225| 0| } 4226| | 4227| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4228| | 4229| 0| loop_ctx->vars[loop_ctx->vars_count++].identifier.ptr = (yyvsp[0].c_string); 4230| 0| } 4231| 0|#line 4232 "libyara/grammar.c" 4232| 0| break; 4233| | 4234| 0| case 117: /* iterator: identifier */ ------------------ | Branch (4234:3): [True: 0, False: 3] ------------------ 4235| 0|#line 2157 "libyara/grammar.y" 4236| 0| { 4237| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4238| | 4239| | // Initially we assume that the identifier is from a non-iterable type, 4240| | // this will change later if it's iterable. 4241| 0| int result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4242| | 4243| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4243:13): [True: 0, False: 0] ------------------ 4244| 0| { 4245| 0| switch((yyvsp[0].expression).value.object->type) ------------------ | Branch (4245:18): [True: 0, False: 0] ------------------ 4246| 0| { 4247| 0| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 0|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (4247:13): [True: 0, False: 0] ------------------ 4248| | // If iterating an array the loop must define a single variable 4249| | // that will hold the current item. If a different number of 4250| | // variables were defined that's an error. 4251| 0| if (loop_ctx->vars_count == 1) ------------------ | Branch (4251:19): [True: 0, False: 0] ------------------ 4252| 0| { 4253| 0| loop_ctx->vars[0].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4254| 0| loop_ctx->vars[0].value.object = \ 4255| 0| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 910| 0|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4256| | 4257| 0| result = yr_parser_emit(yyscanner, OP_ITER_START_ARRAY, NULL); ------------------ | | 102| 0|#define OP_ITER_START_ARRAY 54 ------------------ 4258| 0| } 4259| 0| else 4260| 0| { 4261| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); | | ------------------ | | | Branch (330:7): [True: 0, False: 0] | | ------------------ ------------------ 4262| 0| compiler, 4263| 0| "iterator for \"%s\" yields a single item on each iteration" 4264| 0| ", but the loop expects %d", 4265| 0| expression_identifier((yyvsp[0].expression)), 4266| 0| loop_ctx->vars_count); 4267| | 4268| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4269| 0| } 4270| 0| break; 4271| | 4272| 0| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (4272:13): [True: 0, False: 0] ------------------ 4273| | // If iterating a dictionary the loop must define exactly two 4274| | // variables, one for the key and another for the value . If a 4275| | // different number of variables were defined that's an error. 4276| 0| if (loop_ctx->vars_count == 2) ------------------ | Branch (4276:19): [True: 0, False: 0] ------------------ 4277| 0| { 4278| 0| loop_ctx->vars[0].type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ 4279| 0| loop_ctx->vars[0].value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 4280| 0| loop_ctx->vars[1].type = EXPRESSION_TYPE_OBJECT; ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ 4281| 0| loop_ctx->vars[1].value.object = \ 4282| 0| object_as_array((yyvsp[0].expression).value.object)->prototype_item; ------------------ | | 910| 0|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 4283| | 4284| 0| result = yr_parser_emit(yyscanner, OP_ITER_START_DICT, NULL); ------------------ | | 103| 0|#define OP_ITER_START_DICT 55 ------------------ 4285| 0| } 4286| 0| else 4287| 0| { 4288| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); | | ------------------ | | | Branch (330:7): [True: 0, False: 0] | | ------------------ ------------------ 4289| 0| compiler, 4290| 0| "iterator for \"%s\" yields a key,value pair item on each iteration", 4291| 0| expression_identifier((yyvsp[0].expression))); 4292| | 4293| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4294| 0| } 4295| 0| break; 4296| 0| } 4297| 0| } 4298| | 4299| 0| if (result == ERROR_WRONG_TYPE) ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ | Branch (4299:13): [True: 0, False: 0] ------------------ 4300| 0| { 4301| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); | | ------------------ | | | Branch (330:7): [True: 0, False: 0] | | ------------------ ------------------ 4302| 0| compiler, 4303| 0| "identifier \"%s\" is not iterable", 4304| 0| expression_identifier((yyvsp[0].expression))); 4305| 0| } 4306| | 4307| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4308| 0| } 4309| 0|#line 4310 "libyara/grammar.c" 4310| 0| break; 4311| | 4312| 0| case 118: /* iterator: set */ ------------------ | Branch (4312:3): [True: 0, False: 3] ------------------ 4313| 0|#line 2231 "libyara/grammar.y" 4314| 0| { 4315| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4316| | 4317| 0| YR_LOOP_CONTEXT* loop_ctx = &compiler->loop[compiler->loop_index]; 4318| | 4319| 0| if (loop_ctx->vars_count == 1) ------------------ | Branch (4319:13): [True: 0, False: 0] ------------------ 4320| 0| { 4321| 0| loop_ctx->vars[0].type = (yyvsp[0].enumeration).type; 4322| | 4323| 0| if ((yyvsp[0].enumeration).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4323:15): [True: 0, False: 0] ------------------ 4324| 0| loop_ctx->vars[0].value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 4325| 0| else 4326| 0| loop_ctx->vars[0].value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4327| 0| } 4328| 0| else 4329| 0| { 4330| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 4331| 0| compiler, 4332| 0| "iterator yields one value on each iteration " 4333| 0| ", but the loop expects %d", 4334| 0| loop_ctx->vars_count); 4335| | 4336| 0| result = ERROR_SYNTAX_ERROR; ------------------ | | 56| 0|#define ERROR_SYNTAX_ERROR 11 ------------------ 4337| 0| } 4338| | 4339| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4340| 0| } 4341| 0|#line 4342 "libyara/grammar.c" 4342| 0| break; 4343| | 4344| 0| case 119: /* set: '(' enumeration ')' */ ------------------ | Branch (4344:3): [True: 0, False: 3] ------------------ 4345| 0|#line 2263 "libyara/grammar.y" 4346| 0| { 4347| | // $2.count contains the number of items in the enumeration 4348| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[-1].enumeration).count)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4349| | 4350| 0| if ((yyvsp[-1].enumeration).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4350:13): [True: 0, False: 0] ------------------ 4351| 0| { 4352| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4353| 0| yyscanner, OP_ITER_START_INT_ENUM, NULL)); 4354| 0| } 4355| 0| else 4356| 0| { 4357| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4358| 0| yyscanner, OP_ITER_START_TEXT_STRING_SET, NULL)); 4359| 0| } 4360| | 4361| 0| (yyval.enumeration).type = (yyvsp[-1].enumeration).type; 4362| 0| } 4363| 0|#line 4364 "libyara/grammar.c" 4364| 0| break; 4365| | 4366| 0| case 120: /* set: range */ ------------------ | Branch (4366:3): [True: 0, False: 3] ------------------ 4367| 0|#line 2281 "libyara/grammar.y" 4368| 0| { 4369| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4370| 0| yyscanner, OP_ITER_START_INT_RANGE, NULL)); 4371| | 4372| 0| (yyval.enumeration).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4373| 0| } 4374| 0|#line 4375 "libyara/grammar.c" 4375| 0| break; 4376| | 4377| 0| case 121: /* range: '(' primary_expression ".." primary_expression ')' */ ------------------ | Branch (4377:3): [True: 0, False: 3] ------------------ 4378| 0|#line 2292 "libyara/grammar.y" 4379| 0| { 4380| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4381| | 4382| 0| if ((yyvsp[-3].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4382:13): [True: 0, False: 0] ------------------ 4383| 0| { 4384| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4385| 0| compiler, "wrong type for range's lower bound"); 4386| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4387| 0| } 4388| | 4389| 0| if ((yyvsp[-1].expression).type != EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (4389:13): [True: 0, False: 0] ------------------ 4390| 0| { 4391| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4392| 0| compiler, "wrong type for range's upper bound"); 4393| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4394| 0| } 4395| | 4396| | // If we can statically determine lower and upper bounds, ensure 4397| | // lower < upper. Check for upper bound here because some things (like 4398| | // string count) are EXPRESSION_TYPE_INTEGER. 4399| 0| if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ if ((yyvsp[-3].expression).value.integer != YR_UNDEFINED && (yyvsp[-1].expression).value.integer != YR_UNDEFINED) ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (4399:13): [True: 0, False: 0] | Branch (4399:69): [True: 0, False: 0] ------------------ 4400| 0| { 4401| 0| if ((yyvsp[-3].expression).value.integer > (yyvsp[-1].expression).value.integer) ------------------ | Branch (4401:15): [True: 0, False: 0] ------------------ 4402| 0| { 4403| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4404| 0| compiler, "range lower bound must be less than upper bound"); 4405| 0| result = ERROR_INVALID_VALUE; ------------------ | | 111| 0|#define ERROR_INVALID_VALUE 64 ------------------ 4406| 0| } 4407| 0| else if ((yyvsp[-3].expression).value.integer < 0) ------------------ | Branch (4407:20): [True: 0, False: 0] ------------------ 4408| 0| { 4409| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4410| 0| compiler, "range lower bound can not be negative"); 4411| 0| result = ERROR_INVALID_VALUE; ------------------ | | 111| 0|#define ERROR_INVALID_VALUE 64 ------------------ 4412| 0| } 4413| 0| } 4414| | 4415| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4416| 0| } 4417| 0|#line 4418 "libyara/grammar.c" 4418| 0| break; 4419| | 4420| 0| case 122: /* enumeration: primary_expression */ ------------------ | Branch (4420:3): [True: 0, False: 3] ------------------ 4421| 0|#line 2335 "libyara/grammar.y" 4422| 0| { 4423| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4424| | 4425| 0| if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type != EXPRESSION_TYPE_INTEGER && (yyvsp[0].expression).type != EXPRESSION_TYPE_STRING) ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4425:13): [True: 0, False: 0] | Branch (4425:70): [True: 0, False: 0] ------------------ 4426| 0| { 4427| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4428| 0| compiler, "wrong type for enumeration item"); 4429| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4430| 0| } 4431| | 4432| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4433| | 4434| 0| (yyval.enumeration).type = (yyvsp[0].expression).type; 4435| 0| (yyval.enumeration).count = 1; 4436| 0| } 4437| 0|#line 4438 "libyara/grammar.c" 4438| 0| break; 4439| | 4440| 0| case 123: /* enumeration: enumeration ',' primary_expression */ ------------------ | Branch (4440:3): [True: 0, False: 3] ------------------ 4441| 0|#line 2351 "libyara/grammar.y" 4442| 0| { 4443| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4444| | 4445| 0| if ((yyvsp[0].expression).type != (yyvsp[-2].enumeration).type) ------------------ | Branch (4445:13): [True: 0, False: 0] ------------------ 4446| 0| { 4447| 0| yr_compiler_set_error_extra_info( ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4448| 0| compiler, "enumerations must be all the same type"); 4449| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4450| 0| } 4451| | 4452| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4453| | 4454| 0| (yyval.enumeration).type = (yyvsp[-2].enumeration).type; 4455| 0| (yyval.enumeration).count = (yyvsp[-2].enumeration).count + 1; 4456| 0| } 4457| 0|#line 4458 "libyara/grammar.c" 4458| 0| break; 4459| | 4460| 0| case 124: /* string_iterator: string_set */ ------------------ | Branch (4460:3): [True: 0, False: 3] ------------------ 4461| 0|#line 2371 "libyara/grammar.y" 4462| 0| { 4463| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].string_set).count)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4464| 0| fail_if_error(yr_parser_emit(yyscanner, OP_ITER_START_STRING_SET, ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4465| 0| NULL)); 4466| 0| fail_if_error(yr_string_set_destroy((yyvsp[0].string_set))); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4467| 0| } 4468| 0|#line 4469 "libyara/grammar.c" 4469| 0| break; 4470| | 4471| 0| case 125: /* $@10: %empty */ ------------------ | Branch (4471:3): [True: 0, False: 3] ------------------ 4472| 0|#line 2381 "libyara/grammar.y" 4473| 0| { 4474| | // Push end-of-list marker 4475| 0| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4476| 0| } 4477| 0|#line 4478 "libyara/grammar.c" 4478| 0| break; 4479| | 4480| 0| case 126: /* string_set: '(' $@10 string_enumeration ')' */ ------------------ | Branch (4480:3): [True: 0, False: 3] ------------------ 4481| 0|#line 2386 "libyara/grammar.y" 4482| 0| { 4483| 0| (yyval.string_set) = (yyvsp[-1].string_set); 4484| 0| } 4485| 0|#line 4486 "libyara/grammar.c" 4486| 0| break; 4487| | 4488| 0| case 127: /* string_set: "" */ ------------------ | Branch (4488:3): [True: 0, False: 3] ------------------ 4489| 0|#line 2390 "libyara/grammar.y" 4490| 0| { 4491| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, YR_UNDEFINED)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4492| | 4493| 0| YR_STRING_SET strings; 4494| 0| fail_if_error(yr_parser_emit_pushes_for_strings( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4495| 0| yyscanner, "$*", &strings)); 4496| | 4497| 0| (yyval.string_set) = strings; 4498| 0| } 4499| 0|#line 4500 "libyara/grammar.c" 4500| 0| break; 4501| | 4502| 0| case 128: /* string_enumeration: string_enumeration_item */ ------------------ | Branch (4502:3): [True: 0, False: 3] ------------------ 4503| 0|#line 2403 "libyara/grammar.y" 4504| 0| { (yyval.string_set) = (yyvsp[0].string_set); } 4505| 0|#line 4506 "libyara/grammar.c" 4506| 0| break; 4507| | 4508| 0| case 129: /* string_enumeration: string_enumeration ',' string_enumeration_item */ ------------------ | Branch (4508:3): [True: 0, False: 3] ------------------ 4509| 0|#line 2405 "libyara/grammar.y" 4510| 0| { 4511| 0| YR_STRING_SET_ELEMENT* tail = (yyvsp[-2].string_set).head; 4512| 0| while (tail->next != NULL) { ------------------ | Branch (4512:14): [True: 0, False: 0] ------------------ 4513| 0| tail = tail->next; 4514| 0| } 4515| | // Combine the linked lists by linking the tail of $1 to the head of $3 4516| 0| tail->next = (yyvsp[0].string_set).head; 4517| 0| (yyvsp[-2].string_set).count += (yyvsp[0].string_set).count; 4518| 0| (yyval.string_set) = (yyvsp[-2].string_set); 4519| 0| } 4520| 0|#line 4521 "libyara/grammar.c" 4521| 0| break; 4522| | 4523| 0| case 130: /* string_enumeration_item: "string identifier" */ ------------------ | Branch (4523:3): [True: 0, False: 3] ------------------ 4524| 0|#line 2420 "libyara/grammar.y" 4525| 0| { 4526| 0| YR_STRING_SET strings; 4527| 0| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &strings); 4528| 0| yr_free((yyvsp[0].c_string)); 4529| | 4530| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4531| | 4532| 0| (yyval.string_set) = strings; 4533| 0| } 4534| 0|#line 4535 "libyara/grammar.c" 4535| 0| break; 4536| | 4537| 0| case 131: /* string_enumeration_item: "string identifier with wildcard" */ ------------------ | Branch (4537:3): [True: 0, False: 3] ------------------ 4538| 0|#line 2430 "libyara/grammar.y" 4539| 0| { 4540| 0| YR_STRING_SET strings; 4541| 0| int result = yr_parser_emit_pushes_for_strings(yyscanner, (yyvsp[0].c_string), &strings); 4542| 0| yr_free((yyvsp[0].c_string)); 4543| | 4544| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4545| | 4546| 0| (yyval.string_set) = strings; 4547| 0| } 4548| 0|#line 4549 "libyara/grammar.c" 4549| 0| break; 4550| | 4551| 0| case 132: /* $@11: %empty */ ------------------ | Branch (4551:3): [True: 0, False: 3] ------------------ 4552| 0|#line 2444 "libyara/grammar.y" 4553| 0| { 4554| | // Push end-of-list marker 4555| 0| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4556| 0| } 4557| 0|#line 4558 "libyara/grammar.c" 4558| 0| break; 4559| | 4560| 0| case 133: /* rule_set: '(' $@11 rule_enumeration ')' */ ------------------ | Branch (4560:3): [True: 0, False: 3] ------------------ 4561| 0|#line 2449 "libyara/grammar.y" 4562| 0| { 4563| 0| (yyval.integer) = (yyvsp[-1].integer); 4564| 0| } 4565| 0|#line 4566 "libyara/grammar.c" 4566| 0| break; 4567| | 4568| 0| case 134: /* rule_enumeration: rule_enumeration_item */ ------------------ | Branch (4568:3): [True: 0, False: 3] ------------------ 4569| 0|#line 2456 "libyara/grammar.y" 4570| 0| { (yyval.integer) = (yyvsp[0].integer); } 4571| 0|#line 4572 "libyara/grammar.c" 4572| 0| break; 4573| | 4574| 0| case 135: /* rule_enumeration: rule_enumeration ',' rule_enumeration_item */ ------------------ | Branch (4574:3): [True: 0, False: 3] ------------------ 4575| 0|#line 2457 "libyara/grammar.y" 4576| 0| { (yyval.integer) = (yyvsp[-2].integer) + (yyvsp[0].integer); } 4577| 0|#line 4578 "libyara/grammar.c" 4578| 0| break; 4579| | 4580| 0| case 136: /* rule_enumeration_item: "identifier" */ ------------------ | Branch (4580:3): [True: 0, False: 3] ------------------ 4581| 0|#line 2463 "libyara/grammar.y" 4582| 0| { 4583| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4584| | 4585| 0| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4586| 0| compiler->arena, 4587| 0| YR_NAMESPACES_TABLE, ------------------ | | 57| 0|#define YR_NAMESPACES_TABLE 0 ------------------ 4588| 0| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4589| | 4590| 0| uint32_t rule_idx = yr_hash_table_lookup_uint32( 4591| 0| compiler->rules_table, (yyvsp[0].c_string), ns->name); 4592| | 4593| 0| if (rule_idx != UINT32_MAX) ------------------ | Branch (4593:13): [True: 0, False: 0] ------------------ 4594| 0| { 4595| 0| result = yr_parser_emit_with_arg( 4596| 0| yyscanner, 4597| 0| OP_PUSH_RULE, ------------------ | | 75| 0|#define OP_PUSH_RULE 27 ------------------ 4598| 0| rule_idx, 4599| 0| NULL, 4600| 0| NULL); 4601| 0| } 4602| 0| else 4603| 0| { 4604| 0| yr_compiler_set_error_extra_info(compiler, (yyvsp[0].c_string)); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4605| 0| result = ERROR_UNDEFINED_IDENTIFIER; ------------------ | | 65| 0|#define ERROR_UNDEFINED_IDENTIFIER 20 ------------------ 4606| 0| } 4607| | 4608| 0| yr_free((yyvsp[0].c_string)); 4609| | 4610| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4611| | 4612| 0| (yyval.integer) = 1; 4613| 0| } 4614| 0|#line 4615 "libyara/grammar.c" 4615| 0| break; 4616| | 4617| 0| case 137: /* rule_enumeration_item: "identifier" '*' */ ------------------ | Branch (4617:3): [True: 0, False: 3] ------------------ 4618| 0|#line 2496 "libyara/grammar.y" 4619| 0| { 4620| 0| int count = 0; 4621| 0| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 4622| 0| compiler->arena, 4623| 0| YR_NAMESPACES_TABLE, ------------------ | | 57| 0|#define YR_NAMESPACES_TABLE 0 ------------------ 4624| 0| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 4625| | 4626| 0| yr_hash_table_add_uint32( 4627| 0| compiler->wildcard_identifiers_table, 4628| 0| (yyvsp[-1].c_string), 4629| 0| ns->name, 4630| 0| 1); 4631| | 4632| 0| int result = yr_parser_emit_pushes_for_rules(yyscanner, (yyvsp[-1].c_string), &count); 4633| 0| yr_free((yyvsp[-1].c_string)); 4634| | 4635| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4636| | 4637| 0| (yyval.integer) = count; 4638| 0| } 4639| 0|#line 4640 "libyara/grammar.c" 4640| 0| break; 4641| | 4642| 0| case 138: /* for_expression: primary_expression */ ------------------ | Branch (4642:3): [True: 0, False: 3] ------------------ 4643| 0|#line 2521 "libyara/grammar.y" 4644| 0| { 4645| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER && !IS_UNDEFINED((yyvsp[0].expression).value.integer)) ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (4645:13): [True: 0, False: 0] | Branch (4645:70): [True: 0, False: 0] ------------------ 4646| 0| { 4647| 0| if ((yyvsp[0].expression).value.integer == 0) ------------------ | Branch (4647:15): [True: 0, False: 0] ------------------ 4648| 0| { 4649| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 4650| 0| "consider using \"none\" keyword, it is less ambiguous."); 4651| 0| } 4652| | 4653| 0| if ((yyvsp[0].expression).value.integer < 0) ------------------ | Branch (4653:15): [True: 0, False: 0] ------------------ 4654| 0| { 4655| 0| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 4656| 0| "%" PRId64, (yyvsp[0].expression).value.integer); 4657| | 4658| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4659| 0| } 4660| 0| } 4661| | 4662| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (4662:13): [True: 0, False: 0] ------------------ 4663| 0| { 4664| 0| yr_compiler_set_error_extra_info_fmt(compiler, ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 4665| 0| "%a", (yyvsp[0].expression).value.double_); 4666| | 4667| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4668| 0| } 4669| | 4670| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_STRING) ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ | Branch (4670:13): [True: 0, False: 0] ------------------ 4671| 0| { 4672| 0| SIZED_STRING* ss = yr_arena_ref_to_ptr(compiler->arena, 4673| 0| &(yyvsp[0].expression).value.sized_string_ref); 4674| | // If the expression is an external string variable we need to get 4675| | // it some other way. 4676| 0| if (ss != NULL) ------------------ | Branch (4676:15): [True: 0, False: 0] ------------------ 4677| 0| { 4678| 0| yr_compiler_set_error_extra_info_fmt(compiler, "%s", ss->c_string); ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 4679| 0| } 4680| 0| else 4681| 0| { 4682| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4683| 0| "string in for_expression is invalid"); 4684| 0| } 4685| | 4686| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4687| 0| } 4688| | 4689| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_REGEXP) ------------------ | | 49| 0|#define EXPRESSION_TYPE_REGEXP 8 ------------------ | Branch (4689:13): [True: 0, False: 0] ------------------ 4690| 0| { 4691| 0| yr_compiler_set_error_extra_info(compiler, ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 4692| 0| "regexp in for_expression is invalid"); 4693| | 4694| 0| fail_with_error(ERROR_INVALID_VALUE); ------------------ | | 120| 0| { \ | | 121| 0| compiler->last_error = e; \ | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 123| 0| switch (e) \ | | 124| 0| { \ | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | ------------------ | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | ------------------ | | | Branch (125:7): [True: 0, False: 0] | | ------------------ | | 126| 0| YYABORT; \ | | ------------------ | | | | 1313| 0|#define YYABORT goto yyabortlab | | ------------------ | | 127| 0| default: \ | | ------------------ | | | Branch (127:7): [True: 0, False: 0] | | ------------------ | | 128| 0| YYERROR; \ | | ------------------ | | | | 1314| 0|#define YYERROR goto yyerrorlab | | ------------------ | | 129| 0| } \ | | 130| 0| } ------------------ 4695| 0| } 4696| | 4697| 0| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4698| 0| } 4699| 0|#line 4700 "libyara/grammar.c" 4700| 0| break; 4701| | 4702| 0| case 139: /* for_expression: for_quantifier */ ------------------ | Branch (4702:3): [True: 0, False: 3] ------------------ 4703| 0|#line 2577 "libyara/grammar.y" 4704| 0| { 4705| 0| (yyval.expression).value.integer = (yyvsp[0].expression).value.integer; 4706| 0| } 4707| 0|#line 4708 "libyara/grammar.c" 4708| 0| break; 4709| | 4710| 0| case 140: /* for_quantifier: "" */ ------------------ | Branch (4710:3): [True: 0, False: 3] ------------------ 4711| 0|#line 2584 "libyara/grammar.y" 4712| 0| { 4713| 0| yr_parser_emit_push_const(yyscanner, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4714| 0| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4715| 0| (yyval.expression).value.integer = FOR_EXPRESSION_ALL; ------------------ | | 108| 0|#define FOR_EXPRESSION_ALL 1 ------------------ 4716| 0| } 4717| 0|#line 4718 "libyara/grammar.c" 4718| 0| break; 4719| | 4720| 0| case 141: /* for_quantifier: "" */ ------------------ | Branch (4720:3): [True: 0, False: 3] ------------------ 4721| 0|#line 2590 "libyara/grammar.y" 4722| 0| { 4723| 0| yr_parser_emit_push_const(yyscanner, 1); 4724| 0| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4725| 0| (yyval.expression).value.integer = FOR_EXPRESSION_ANY; ------------------ | | 109| 0|#define FOR_EXPRESSION_ANY 2 ------------------ 4726| 0| } 4727| 0|#line 4728 "libyara/grammar.c" 4728| 0| break; 4729| | 4730| 0| case 142: /* for_quantifier: "" */ ------------------ | Branch (4730:3): [True: 0, False: 3] ------------------ 4731| 0|#line 2596 "libyara/grammar.y" 4732| 0| { 4733| 0| yr_parser_emit_push_const(yyscanner, 0); 4734| 0| (yyval.expression).type = EXPRESSION_TYPE_QUANTIFIER; ------------------ | | 52| 0|#define EXPRESSION_TYPE_QUANTIFIER 64 ------------------ 4735| 0| (yyval.expression).value.integer = FOR_EXPRESSION_NONE; ------------------ | | 110| 0|#define FOR_EXPRESSION_NONE 3 ------------------ 4736| 0| } 4737| 0|#line 4738 "libyara/grammar.c" 4738| 0| break; 4739| | 4740| 0| case 143: /* primary_expression: '(' primary_expression ')' */ ------------------ | Branch (4740:3): [True: 0, False: 3] ------------------ 4741| 0|#line 2606 "libyara/grammar.y" 4742| 0| { 4743| 0| (yyval.expression) = (yyvsp[-1].expression); 4744| 0| } 4745| 0|#line 4746 "libyara/grammar.c" 4746| 0| break; 4747| | 4748| 0| case 144: /* primary_expression: "" */ ------------------ | Branch (4748:3): [True: 0, False: 3] ------------------ 4749| 0|#line 2610 "libyara/grammar.y" 4750| 0| { 4751| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4752| 0| yyscanner, OP_FILESIZE, NULL)); 4753| | 4754| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4755| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4756| 0| } 4757| 0|#line 4758 "libyara/grammar.c" 4758| 0| break; 4759| | 4760| 0| case 145: /* primary_expression: "" */ ------------------ | Branch (4760:3): [True: 0, False: 3] ------------------ 4761| 0|#line 2618 "libyara/grammar.y" 4762| 0| { 4763| 0| yywarning(yyscanner, ------------------ | | 50| 0|#define yywarning yara_yywarning ------------------ 4764| 0| "using deprecated \"entrypoint\" keyword. Use the \"entry_point\" " 4765| 0| "function from PE module instead."); 4766| | 4767| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4768| 0| yyscanner, OP_ENTRYPOINT, NULL)); 4769| | 4770| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4771| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4772| 0| } 4773| 0|#line 4774 "libyara/grammar.c" 4774| 0| break; 4775| | 4776| 0| case 146: /* primary_expression: "integer function" '(' primary_expression ')' */ ------------------ | Branch (4776:3): [True: 0, False: 3] ------------------ 4777| 0|#line 2630 "libyara/grammar.y" 4778| 0| { 4779| 0| check_type((yyvsp[-1].expression), EXPRESSION_TYPE_INTEGER, "intXXXX or uintXXXX"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 4780| | 4781| | // _INTEGER_FUNCTION_ could be any of int8, int16, int32, uint8, 4782| | // uint32, etc. $1 contains an index that added to OP_READ_INT results 4783| | // in the proper OP_INTXX opcode. 4784| | 4785| 0| fail_if_error(yr_parser_emit( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4786| 0| yyscanner, (uint8_t) (OP_READ_INT + (yyvsp[-3].integer)), NULL)); 4787| | 4788| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4789| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4790| 0| } 4791| 0|#line 4792 "libyara/grammar.c" 4792| 0| break; 4793| | 4794| 0| case 147: /* primary_expression: "integer number" */ ------------------ | Branch (4794:3): [True: 0, False: 3] ------------------ 4795| 0|#line 2644 "libyara/grammar.y" 4796| 0| { 4797| 0| fail_if_error(yr_parser_emit_push_const(yyscanner, (yyvsp[0].integer))); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4798| | 4799| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4800| 0| (yyval.expression).value.integer = (yyvsp[0].integer); 4801| 0| } 4802| 0|#line 4803 "libyara/grammar.c" 4803| 0| break; 4804| | 4805| 0| case 148: /* primary_expression: "floating point number" */ ------------------ | Branch (4805:3): [True: 0, False: 3] ------------------ 4806| 0|#line 2651 "libyara/grammar.y" 4807| 0| { 4808| 0| fail_if_error(yr_parser_emit_with_arg_double( ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4809| 0| yyscanner, OP_PUSH, (yyvsp[0].double_), NULL, NULL)); 4810| | 4811| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4812| 0| } 4813| 0|#line 4814 "libyara/grammar.c" 4814| 0| break; 4815| | 4816| 0| case 149: /* primary_expression: "text string" */ ------------------ | Branch (4816:3): [True: 0, False: 3] ------------------ 4817| 0|#line 2658 "libyara/grammar.y" 4818| 0| { 4819| 0| YR_ARENA_REF ref; 4820| | 4821| 0| int result = _yr_compiler_store_data( 4822| 0| compiler, 4823| 0| (yyvsp[0].sized_string), 4824| 0| (yyvsp[0].sized_string)->length + sizeof(SIZED_STRING), 4825| 0| &ref); 4826| | 4827| 0| yr_free((yyvsp[0].sized_string)); 4828| | 4829| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (4829:13): [True: 0, False: 0] ------------------ 4830| 0| result = yr_parser_emit_with_arg_reloc( 4831| 0| yyscanner, 4832| 0| OP_PUSH, ------------------ | | 61| 0|#define OP_PUSH 13 ------------------ 4833| 0| yr_arena_ref_to_ptr(compiler->arena, &ref), 4834| 0| NULL, 4835| 0| NULL); 4836| | 4837| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4838| | 4839| 0| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ 4840| 0| (yyval.expression).value.sized_string_ref = ref; 4841| 0| } 4842| 0|#line 4843 "libyara/grammar.c" 4843| 0| break; 4844| | 4845| 0| case 150: /* primary_expression: "string count" "" range */ ------------------ | Branch (4845:3): [True: 0, False: 3] ------------------ 4846| 0|#line 2683 "libyara/grammar.y" 4847| 0| { 4848| 0| int result = yr_parser_reduce_string_identifier( 4849| 0| yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 124| 0|#define OP_COUNT_IN 76 ------------------ yyscanner, (yyvsp[-2].c_string), OP_COUNT_IN, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4850| | 4851| 0| yr_free((yyvsp[-2].c_string)); 4852| | 4853| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4854| | 4855| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4856| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4857| 0| } 4858| 0|#line 4859 "libyara/grammar.c" 4859| 0| break; 4860| | 4861| 0| case 151: /* primary_expression: "string count" */ ------------------ | Branch (4861:3): [True: 0, False: 3] ------------------ 4862| 0|#line 2695 "libyara/grammar.y" 4863| 0| { 4864| 0| int result = yr_parser_reduce_string_identifier( 4865| 0| yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 68| 0|#define OP_COUNT 20 ------------------ yyscanner, (yyvsp[0].c_string), OP_COUNT, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4866| | 4867| 0| yr_free((yyvsp[0].c_string)); 4868| | 4869| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4870| | 4871| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4872| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4873| 0| } 4874| 0|#line 4875 "libyara/grammar.c" 4875| 0| break; 4876| | 4877| 0| case 152: /* primary_expression: "string offset" '[' primary_expression ']' */ ------------------ | Branch (4877:3): [True: 0, False: 3] ------------------ 4878| 0|#line 2707 "libyara/grammar.y" 4879| 0| { 4880| 0| int result = yr_parser_reduce_string_identifier( 4881| 0| yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 0|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[-3].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4882| | 4883| 0| yr_free((yyvsp[-3].c_string)); 4884| | 4885| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4886| | 4887| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4888| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4889| 0| } 4890| 0|#line 4891 "libyara/grammar.c" 4891| 0| break; 4892| | 4893| 0| case 153: /* primary_expression: "string offset" */ ------------------ | Branch (4893:3): [True: 0, False: 3] ------------------ 4894| 0|#line 2719 "libyara/grammar.y" 4895| 0| { 4896| 0| int result = yr_parser_emit_push_const(yyscanner, 1); 4897| | 4898| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (4898:13): [True: 0, False: 0] ------------------ 4899| 0| result = yr_parser_reduce_string_identifier( 4900| 0| yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 73| 0|#define OP_OFFSET 25 ------------------ yyscanner, (yyvsp[0].c_string), OP_OFFSET, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4901| | 4902| 0| yr_free((yyvsp[0].c_string)); 4903| | 4904| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4905| | 4906| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4907| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4908| 0| } 4909| 0|#line 4910 "libyara/grammar.c" 4910| 0| break; 4911| | 4912| 0| case 154: /* primary_expression: "string length" '[' primary_expression ']' */ ------------------ | Branch (4912:3): [True: 0, False: 3] ------------------ 4913| 0|#line 2734 "libyara/grammar.y" 4914| 0| { 4915| 0| int result = yr_parser_reduce_string_identifier( 4916| 0| yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 0|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[-3].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4917| | 4918| 0| yr_free((yyvsp[-3].c_string)); 4919| | 4920| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4921| | 4922| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4923| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4924| 0| } 4925| 0|#line 4926 "libyara/grammar.c" 4926| 0| break; 4927| | 4928| 0| case 155: /* primary_expression: "string length" */ ------------------ | Branch (4928:3): [True: 0, False: 3] ------------------ 4929| 0|#line 2746 "libyara/grammar.y" 4930| 0| { 4931| 0| int result = yr_parser_emit_push_const(yyscanner, 1); 4932| | 4933| 0| if (result == ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (4933:13): [True: 0, False: 0] ------------------ 4934| 0| result = yr_parser_reduce_string_identifier( 4935| 0| yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 69| 0|#define OP_LENGTH 21 ------------------ yyscanner, (yyvsp[0].c_string), OP_LENGTH, YR_UNDEFINED); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4936| | 4937| 0| yr_free((yyvsp[0].c_string)); 4938| | 4939| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4940| | 4941| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4942| 0| (yyval.expression).value.integer = YR_UNDEFINED; ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 4943| 0| } 4944| 0|#line 4945 "libyara/grammar.c" 4945| 0| break; 4946| | 4947| 0| case 156: /* primary_expression: identifier */ ------------------ | Branch (4947:3): [True: 0, False: 3] ------------------ 4948| 0|#line 2761 "libyara/grammar.y" 4949| 0| { 4950| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4951| | 4952| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_OBJECT) ------------------ | | 50| 0|#define EXPRESSION_TYPE_OBJECT 16 ------------------ | Branch (4952:13): [True: 0, False: 0] ------------------ 4953| 0| { 4954| 0| result = yr_parser_emit( 4955| 0| yyscanner, OP_OBJ_VALUE, NULL); ------------------ | | 65| 0|#define OP_OBJ_VALUE 17 ------------------ 4956| | 4957| 0| switch((yyvsp[0].expression).value.object->type) 4958| 0| { 4959| 0| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 0|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (4959:13): [True: 0, False: 0] ------------------ 4960| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 4961| 0| (yyval.expression).value.integer = (yyvsp[0].expression).value.object->value.i; 4962| 0| break; 4963| 0| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (4963:13): [True: 0, False: 0] ------------------ 4964| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 4965| 0| break; 4966| 0| case OBJECT_TYPE_STRING: ------------------ | | 59| 0|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (4966:13): [True: 0, False: 0] ------------------ 4967| 0| (yyval.expression).type = EXPRESSION_TYPE_STRING; ------------------ | | 48| 0|#define EXPRESSION_TYPE_STRING 4 ------------------ 4968| 0| (yyval.expression).value.sized_string_ref = YR_ARENA_NULL_REF; ------------------ | | 43| 0| (YR_ARENA_REF) \ | | 44| 0| { \ | | 45| 0| UINT32_MAX, UINT32_MAX \ | | 46| 0| } ------------------ 4969| 0| break; 4970| 0| default: ------------------ | Branch (4970:13): [True: 0, False: 0] ------------------ 4971| | // In a primary expression any identifier that corresponds to an 4972| | // object must be of type integer, float or string. If "foobar" is 4973| | // either a function, structure, dictionary or array you can not 4974| | // use it as: 4975| | // condition: foobar 4976| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); | | ------------------ | | | Branch (330:7): [True: 0, False: 0] | | ------------------ ------------------ 4977| 0| compiler, 4978| 0| "wrong usage of identifier \"%s\"", 4979| 0| expression_identifier((yyvsp[0].expression))); 4980| | 4981| 0| result = ERROR_WRONG_TYPE; ------------------ | | 69| 0|#define ERROR_WRONG_TYPE 24 ------------------ 4982| 0| } 4983| 0| } 4984| 0| else 4985| 0| { 4986| 0| (yyval.expression) = (yyvsp[0].expression); 4987| 0| } 4988| | 4989| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 4990| 0| } 4991| 0|#line 4992 "libyara/grammar.c" 4992| 0| break; 4993| | 4994| 0| case 157: /* primary_expression: '-' primary_expression */ ------------------ | Branch (4994:3): [True: 0, False: 3] ------------------ 4995| 0|#line 2804 "libyara/grammar.y" 4996| 0| { 4997| 0| int result = ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 4998| | 4999| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER | EXPRESSION_TYPE_FLOAT, "-"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5000| | 5001| 0| if ((yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5001:13): [True: 0, False: 0] ------------------ 5002| 0| { 5003| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5004| 0| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (5004:46): [True: 0, False: 0] ------------------ 5005| 0| YR_UNDEFINED : -((yyvsp[0].expression).value.integer); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 5006| 0| result = yr_parser_emit(yyscanner, OP_INT_MINUS, NULL); ------------------ | | 152| 0|#define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 141| 0|#define OP_INT_BEGIN 100 | | ------------------ | | #define OP_INT_MINUS (OP_INT_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 0|#define _OP_MINUS 10 | | ------------------ ------------------ 5007| 0| } 5008| 0| else if ((yyvsp[0].expression).type == EXPRESSION_TYPE_FLOAT) ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ | Branch (5008:18): [True: 0, False: 0] ------------------ 5009| 0| { 5010| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5011| 0| result = yr_parser_emit(yyscanner, OP_DBL_MINUS, NULL); ------------------ | | 166| 0|#define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 155| 0|#define OP_DBL_BEGIN 120 | | ------------------ | | #define OP_DBL_MINUS (OP_DBL_BEGIN + _OP_MINUS) | | ------------------ | | | | 139| 0|#define _OP_MINUS 10 | | ------------------ ------------------ 5012| 0| } 5013| | 5014| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5015| 0| } 5016| 0|#line 5017 "libyara/grammar.c" 5017| 0| break; 5018| | 5019| 0| case 158: /* primary_expression: primary_expression '+' primary_expression */ ------------------ | Branch (5019:3): [True: 0, False: 3] ------------------ 5020| 0|#line 2825 "libyara/grammar.y" 5021| 0| { 5022| 0| int result = yr_parser_reduce_operation( 5023| 0| yyscanner, "+", (yyvsp[-2].expression), (yyvsp[0].expression)); 5024| | 5025| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5025:13): [True: 0, False: 0] ------------------ 5026| 0| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5026:13): [True: 0, False: 0] ------------------ 5027| 0| { 5028| 0| int64_t i1 = (yyvsp[-2].expression).value.integer; 5029| 0| int64_t i2 = (yyvsp[0].expression).value.integer; 5030| | 5031| 0| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5031:15): [True: 0, False: 0] | Branch (5031:36): [True: 0, False: 0] ------------------ 5032| 0| ( 5033| 0| (i2 > 0 && i1 > INT64_MAX - i2) || ------------------ | Branch (5033:18): [True: 0, False: 0] | Branch (5033:28): [True: 0, False: 0] ------------------ 5034| 0| (i2 < 0 && i1 < INT64_MIN - i2) ------------------ | Branch (5034:18): [True: 0, False: 0] | Branch (5034:28): [True: 0, False: 0] ------------------ 5035| 0| )) 5036| 0| { 5037| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 5038| 0| compiler, "%" PRId64 " + %" PRId64, i1, i2); 5039| | 5040| 0| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 0|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5041| 0| } 5042| 0| else 5043| 0| { 5044| 0| (yyval.expression).value.integer = OPERATION(+, i1, i2); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5045| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5046| 0| } 5047| 0| } 5048| 0| else 5049| 0| { 5050| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5051| 0| } 5052| | 5053| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5054| 0| } 5055| 0|#line 5056 "libyara/grammar.c" 5056| 0| break; 5057| | 5058| 0| case 159: /* primary_expression: primary_expression '-' primary_expression */ ------------------ | Branch (5058:3): [True: 0, False: 3] ------------------ 5059| 0|#line 2860 "libyara/grammar.y" 5060| 0| { 5061| 0| int result = yr_parser_reduce_operation( 5062| 0| yyscanner, "-", (yyvsp[-2].expression), (yyvsp[0].expression)); 5063| | 5064| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5064:13): [True: 0, False: 0] ------------------ 5065| 0| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5065:13): [True: 0, False: 0] ------------------ 5066| 0| { 5067| 0| int64_t i1 = (yyvsp[-2].expression).value.integer; 5068| 0| int64_t i2 = (yyvsp[0].expression).value.integer; 5069| | 5070| 0| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5070:15): [True: 0, False: 0] | Branch (5070:36): [True: 0, False: 0] ------------------ 5071| 0| ( 5072| 0| (i2 < 0 && i1 > INT64_MAX + i2) || ------------------ | Branch (5072:18): [True: 0, False: 0] | Branch (5072:28): [True: 0, False: 0] ------------------ 5073| 0| (i2 > 0 && i1 < INT64_MIN + i2) ------------------ | Branch (5073:18): [True: 0, False: 0] | Branch (5073:28): [True: 0, False: 0] ------------------ 5074| 0| )) 5075| 0| { 5076| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 5077| 0| compiler, "%" PRId64 " - %" PRId64, i1, i2); 5078| | 5079| 0| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 0|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5080| 0| } 5081| 0| else 5082| 0| { 5083| 0| (yyval.expression).value.integer = OPERATION(-, i1, i2); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5084| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5085| 0| } 5086| 0| } 5087| 0| else 5088| 0| { 5089| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5090| 0| } 5091| | 5092| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5093| 0| } 5094| 0|#line 5095 "libyara/grammar.c" 5095| 0| break; 5096| | 5097| 0| case 160: /* primary_expression: primary_expression '*' primary_expression */ ------------------ | Branch (5097:3): [True: 0, False: 3] ------------------ 5098| 0|#line 2895 "libyara/grammar.y" 5099| 0| { 5100| 0| int result = yr_parser_reduce_operation( 5101| 0| yyscanner, "*", (yyvsp[-2].expression), (yyvsp[0].expression)); 5102| | 5103| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5103:13): [True: 0, False: 0] ------------------ 5104| 0| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5104:13): [True: 0, False: 0] ------------------ 5105| 0| { 5106| 0| int64_t i1 = (yyvsp[-2].expression).value.integer; 5107| 0| int64_t i2 = (yyvsp[0].expression).value.integer; 5108| | 5109| 0| if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ if (!IS_UNDEFINED(i1) && !IS_UNDEFINED(i2) && ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5109:15): [True: 0, False: 0] | Branch (5109:36): [True: 0, False: 0] ------------------ 5110| 0| ( 5111| 0| i2 != 0 && llabs(i1) > INT64_MAX / llabs(i2) ------------------ | Branch (5111:17): [True: 0, False: 0] | Branch (5111:28): [True: 0, False: 0] ------------------ 5112| 0| )) 5113| 0| { 5114| 0| yr_compiler_set_error_extra_info_fmt( ------------------ | | 326| 0| snprintf( \ | | 327| 0| compiler->last_error_extra_info, \ | | 328| 0| sizeof(compiler->last_error_extra_info), \ | | 329| 0| fmt, \ | | 330| 0| __VA_ARGS__); ------------------ 5115| 0| compiler, "%" PRId64 " * %" PRId64, i1, i2); 5116| | 5117| 0| result = ERROR_INTEGER_OVERFLOW; ------------------ | | 99| 0|#define ERROR_INTEGER_OVERFLOW 52 ------------------ 5118| 0| } 5119| 0| else 5120| 0| { 5121| 0| (yyval.expression).value.integer = OPERATION(*, i1, i2); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5122| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5123| 0| } 5124| 0| } 5125| 0| else 5126| 0| { 5127| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5128| 0| } 5129| | 5130| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5131| 0| } 5132| 0|#line 5133 "libyara/grammar.c" 5133| 0| break; 5134| | 5135| 0| case 161: /* primary_expression: primary_expression '\\' primary_expression */ ------------------ | Branch (5135:3): [True: 0, False: 3] ------------------ 5136| 0|#line 2929 "libyara/grammar.y" 5137| 0| { 5138| 0| int result = yr_parser_reduce_operation( 5139| 0| yyscanner, "\\", (yyvsp[-2].expression), (yyvsp[0].expression)); 5140| | 5141| 0| if ((yyvsp[-2].expression).type == EXPRESSION_TYPE_INTEGER && ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5141:13): [True: 0, False: 0] ------------------ 5142| 0| (yyvsp[0].expression).type == EXPRESSION_TYPE_INTEGER) ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ | Branch (5142:13): [True: 0, False: 0] ------------------ 5143| 0| { 5144| 0| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (5144:15): [True: 0, False: 0] ------------------ 5145| 0| { 5146| 0| (yyval.expression).value.integer = OPERATION(/, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5147| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5148| 0| } 5149| 0| else 5150| 0| { 5151| 0| result = ERROR_DIVISION_BY_ZERO; ------------------ | | 91| 0|#define ERROR_DIVISION_BY_ZERO 44 ------------------ 5152| 0| } 5153| 0| } 5154| 0| else 5155| 0| { 5156| 0| (yyval.expression).type = EXPRESSION_TYPE_FLOAT; ------------------ | | 51| 0|#define EXPRESSION_TYPE_FLOAT 32 ------------------ 5157| 0| } 5158| | 5159| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5160| 0| } 5161| 0|#line 5162 "libyara/grammar.c" 5162| 0| break; 5163| | 5164| 0| case 162: /* primary_expression: primary_expression '%' primary_expression */ ------------------ | Branch (5164:3): [True: 0, False: 3] ------------------ 5165| 0|#line 2954 "libyara/grammar.y" 5166| 0| { 5167| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5168| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "%"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5169| | 5170| 0| fail_if_error(yr_parser_emit(yyscanner, OP_MOD, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5171| | 5172| 0| if ((yyvsp[0].expression).value.integer != 0) ------------------ | Branch (5172:13): [True: 0, False: 0] ------------------ 5173| 0| { 5174| 0| (yyval.expression).value.integer = OPERATION(%, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5175| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5176| 0| } 5177| 0| else 5178| 0| { 5179| 0| fail_if_error(ERROR_DIVISION_BY_ZERO); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, Folded] | | | Branch (135:31): [True: 0, Folded] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5180| 0| } 5181| 0| } 5182| 0|#line 5183 "libyara/grammar.c" 5183| 0| break; 5184| | 5185| 0| case 163: /* primary_expression: primary_expression '^' primary_expression */ ------------------ | Branch (5185:3): [True: 0, False: 3] ------------------ 5186| 0|#line 2971 "libyara/grammar.y" 5187| 0| { 5188| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5189| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5190| | 5191| 0| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_XOR, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5192| | 5193| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5194| 0| (yyval.expression).value.integer = OPERATION(^, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5195| 0| } 5196| 0|#line 5197 "libyara/grammar.c" 5197| 0| break; 5198| | 5199| 0| case 164: /* primary_expression: primary_expression '&' primary_expression */ ------------------ | Branch (5199:3): [True: 0, False: 3] ------------------ 5200| 0|#line 2981 "libyara/grammar.y" 5201| 0| { 5202| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5203| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "^"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5204| | 5205| 0| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_AND, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5206| | 5207| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5208| 0| (yyval.expression).value.integer = OPERATION(&, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5209| 0| } 5210| 0|#line 5211 "libyara/grammar.c" 5211| 0| break; 5212| | 5213| 0| case 165: /* primary_expression: primary_expression '|' primary_expression */ ------------------ | Branch (5213:3): [True: 0, False: 3] ------------------ 5214| 0|#line 2991 "libyara/grammar.y" 5215| 0| { 5216| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5217| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "|"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5218| | 5219| 0| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_OR, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5220| | 5221| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5222| 0| (yyval.expression).value.integer = OPERATION(|, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5223| 0| } 5224| 0|#line 5225 "libyara/grammar.c" 5225| 0| break; 5226| | 5227| 0| case 166: /* primary_expression: '~' primary_expression */ ------------------ | Branch (5227:3): [True: 0, False: 3] ------------------ 5228| 0|#line 3001 "libyara/grammar.y" 5229| 0| { 5230| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "~"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5231| | 5232| 0| fail_if_error(yr_parser_emit(yyscanner, OP_BITWISE_NOT, NULL)); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5233| | 5234| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5235| 0| (yyval.expression).value.integer = ((yyvsp[0].expression).value.integer == YR_UNDEFINED) ? ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ | Branch (5235:44): [True: 0, False: 0] ------------------ 5236| 0| YR_UNDEFINED : ~((yyvsp[0].expression).value.integer); ------------------ | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 5237| 0| } 5238| 0|#line 5239 "libyara/grammar.c" 5239| 0| break; 5240| | 5241| 0| case 167: /* primary_expression: primary_expression "<<" primary_expression */ ------------------ | Branch (5241:3): [True: 0, False: 3] ------------------ 5242| 0|#line 3011 "libyara/grammar.y" 5243| 0| { 5244| 0| int result; 5245| | 5246| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5247| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, "<<"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5248| | 5249| 0| result = yr_parser_emit(yyscanner, OP_SHL, NULL); ------------------ | | 56| 0|#define OP_SHL 8 ------------------ 5250| | 5251| 0| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5251:13): [True: 0, False: 0] | Branch (5251:67): [True: 0, False: 0] ------------------ 5252| 0| result = ERROR_INVALID_OPERAND; ------------------ | | 101| 0|#define ERROR_INVALID_OPERAND 54 ------------------ 5253| 0| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5253:18): [True: 0, False: 0] | Branch (5253:72): [True: 0, False: 0] ------------------ 5254| 0| (yyval.expression).value.integer = 0; 5255| 0| else 5256| 0| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5257| | 5258| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5259| | 5260| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5261| 0| } 5262| 0|#line 5263 "libyara/grammar.c" 5263| 0| break; 5264| | 5265| 0| case 168: /* primary_expression: primary_expression ">>" primary_expression */ ------------------ | Branch (5265:3): [True: 0, False: 3] ------------------ 5266| 0|#line 3031 "libyara/grammar.y" 5267| 0| { 5268| 0| int result; 5269| | 5270| 0| check_type((yyvsp[-2].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5271| 0| check_type((yyvsp[0].expression), EXPRESSION_TYPE_INTEGER, ">>"); ------------------ | | 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 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( \ | | | | ------------------ | | | | | | 320| 0| strlcpy( \ | | | | | | 321| 0| compiler->last_error_extra_info, \ | | | | | | 322| 0| info, \ | | | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | | | ------------------ | | | | 163| 0| compiler, "wrong type \"boolean\" for " op " operator"); \ | | | | 164| 0| break; \ | | | | 165| 0| } \ | | | | 166| 0| cleanup; \ | | | | 167| 0| compiler->last_error = ERROR_WRONG_TYPE; \ | | | | ------------------ | | | | | | 69| 0|#define ERROR_WRONG_TYPE 24 | | | | ------------------ | | | | 168| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 169| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 170| 0| } | | ------------------ ------------------ 5272| | 5273| 0| result = yr_parser_emit(yyscanner, OP_SHR, NULL); ------------------ | | 57| 0|#define OP_SHR 9 ------------------ 5274| | 5275| 0| if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer < 0) ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5275:13): [True: 0, False: 0] | Branch (5275:67): [True: 0, False: 0] ------------------ 5276| 0| result = ERROR_INVALID_OPERAND; ------------------ | | 101| 0|#define ERROR_INVALID_OPERAND 54 ------------------ 5277| 0| else if (!IS_UNDEFINED((yyvsp[0].expression).value.integer) && (yyvsp[0].expression).value.integer >= 64) ------------------ | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ | Branch (5277:18): [True: 0, False: 0] | Branch (5277:72): [True: 0, False: 0] ------------------ 5278| 0| (yyval.expression).value.integer = 0; 5279| 0| else 5280| 0| (yyval.expression).value.integer = OPERATION(<<, (yyvsp[-2].expression).value.integer, (yyvsp[0].expression).value.integer); ------------------ | | 197| 0| (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 39| 0|#define IS_UNDEFINED(x) ((size_t)(x) == (size_t) YR_UNDEFINED) | | | | ------------------ | | | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | | | ------------------ | | | | | Branch (39:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | (IS_UNDEFINED(op1) || IS_UNDEFINED(op2)) ? (YR_UNDEFINED) : (op1 operator op2) | | ------------------ | | | | 38| 0|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL | | ------------------ ------------------ 5281| | 5282| 0| (yyval.expression).type = EXPRESSION_TYPE_INTEGER; ------------------ | | 47| 0|#define EXPRESSION_TYPE_INTEGER 2 ------------------ 5283| | 5284| 0| fail_if_error(result); ------------------ | | 135| 0| if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 40| 0|#define ERROR_SUCCESS 0 | | ------------------ | | if (e != ERROR_SUCCESS && e != ERROR_UNKNOWN_ESCAPE_SEQUENCE) \ | | ------------------ | | | | 113| 0|#define ERROR_UNKNOWN_ESCAPE_SEQUENCE 66 | | ------------------ | | | Branch (135:9): [True: 0, False: 0] | | | Branch (135:31): [True: 0, False: 0] | | ------------------ | | 136| 0| { \ | | 137| 0| fail_with_error(e); \ | | ------------------ | | | | 120| 0| { \ | | | | 121| 0| compiler->last_error = e; \ | | | | 122| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 123| 0| switch (e) \ | | | | 124| 0| { \ | | | | 125| 0| case ERROR_INSUFFICIENT_MEMORY: \ | | | | ------------------ | | | | | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 | | | | ------------------ | | | | | Branch (125:7): [True: 0, False: 0] | | | | ------------------ | | | | 126| 0| YYABORT; \ | | | | ------------------ | | | | | | 1313| 0|#define YYABORT goto yyabortlab | | | | ------------------ | | | | 127| 0| default: \ | | | | ------------------ | | | | | Branch (127:7): [True: 0, False: 0] | | | | ------------------ | | | | 128| 0| YYERROR; \ | | | | ------------------ | | | | | | 1314| 0|#define YYERROR goto yyerrorlab | | | | ------------------ | | | | 129| 0| } \ | | | | 130| 0| } | | ------------------ | | 138| 0| } ------------------ 5285| 0| } 5286| 0|#line 5287 "libyara/grammar.c" 5287| 0| break; 5288| | 5289| 0| case 169: /* primary_expression: regexp */ ------------------ | Branch (5289:3): [True: 0, False: 3] ------------------ 5290| 0|#line 3051 "libyara/grammar.y" 5291| 0| { 5292| 0| (yyval.expression) = (yyvsp[0].expression); 5293| 0| } 5294| 0|#line 5295 "libyara/grammar.c" 5295| 0| break; 5296| | 5297| | 5298| 0|#line 5299 "libyara/grammar.c" 5299| | 5300| 2| default: break; ------------------ | Branch (5300:7): [True: 2, False: 1] ------------------ 5301| 3| } 5302| | /* User semantic actions sometimes alter yychar, and that requires 5303| | that yytoken be updated with the new translation. We take the 5304| | approach of translating immediately before every use of yytoken. 5305| | One alternative is translating here after every semantic action, 5306| | but that translation would be missed if the semantic action invokes 5307| | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 5308| | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 5309| | incorrect destructor might then be invoked immediately. In the 5310| | case of YYERROR or YYBACKUP, subsequent parser actions might lead 5311| | to an incorrect destructor call or verbose syntax error message 5312| | before the lookahead is translated. */ 5313| 3| YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 5314| | 5315| 3| YYPOPSTACK (yylen); ------------------ | | 1950| 3|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5316| 3| yylen = 0; 5317| | 5318| 3| *++yyvsp = yyval; 5319| | 5320| | /* Now 'shift' the result of the reduction. Determine what state 5321| | that goes to, based on the state we popped back to and the rule 5322| | number reduced by. */ 5323| 3| { 5324| 3| const int yylhs = yyr1[yyn] - YYNTOKENS; ------------------ | | 885| 3|#define YYNTOKENS 84 ------------------ 5325| 3| const int yyi = yypgoto[yylhs] + *yyssp; 5326| 3| yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp ------------------ | | 882| 4|#define YYLAST 480 ------------------ | Branch (5326:16): [True: 1, False: 2] | Branch (5326:28): [True: 1, False: 0] | Branch (5326:45): [True: 0, False: 1] ------------------ 5327| 3| ? yytable[yyi] 5328| 3| : yydefgoto[yylhs]); 5329| 3| } 5330| | 5331| 3| goto yynewstate; 5332| | 5333| | 5334| |/*--------------------------------------. 5335| || yyerrlab -- here on detecting error. | 5336| |`--------------------------------------*/ 5337| 0|yyerrlab: 5338| | /* Make sure we have latest lookahead translation. See comments at 5339| | user semantic actions for why this is necessary. */ 5340| 0| yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 51| 0|#define yychar yara_yychar ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 312| 0|#define YYEMPTY -2 ------------------ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); ------------------ | | 900| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 894| 0|#define YYMAXUTOK 319 | | ------------------ | | | Branch (900:4): [True: 0, False: 0] | | | Branch (900:18): [True: 0, False: 0] | | ------------------ | | 901| 0| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 902| 0| : YYSYMBOL_YYUNDEF) ------------------ | Branch (5340:13): [True: 0, False: 0] ------------------ 5341| | /* If not already recovering from an error, report this error. */ 5342| 0| if (!yyerrstatus) ------------------ | Branch (5342:7): [True: 0, False: 0] ------------------ 5343| 0| { 5344| 0| ++yynerrs; ------------------ | | 53| 0|#define yynerrs yara_yynerrs ------------------ 5345| 0| { 5346| 0| yypcontext_t yyctx 5347| 0| = {yyssp, yytoken}; 5348| 0| char const *yymsgp = YY_("syntax error"); ------------------ | | 684| 0|# define YY_(Msgid) Msgid ------------------ 5349| 0| int yysyntax_error_status; 5350| 0| yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5351| 0| if (yysyntax_error_status == 0) ------------------ | Branch (5351:13): [True: 0, False: 0] ------------------ 5352| 0| yymsgp = yymsg; 5353| 0| else if (yysyntax_error_status == -1) ------------------ | Branch (5353:18): [True: 0, False: 0] ------------------ 5354| 0| { 5355| 0| if (yymsg != yymsgbuf) ------------------ | Branch (5355:17): [True: 0, False: 0] ------------------ 5356| 0| YYSTACK_FREE (yymsg); ------------------ | | 792| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5357| 0| yymsg = YY_CAST (char *, ------------------ | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) ------------------ 5358| 0| YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); 5359| 0| if (yymsg) ------------------ | Branch (5359:17): [True: 0, False: 0] ------------------ 5360| 0| { 5361| 0| yysyntax_error_status 5362| 0| = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); 5363| 0| yymsgp = yymsg; 5364| 0| } 5365| 0| else 5366| 0| { 5367| 0| yymsg = yymsgbuf; 5368| 0| yymsg_alloc = sizeof yymsgbuf; 5369| 0| yysyntax_error_status = YYENOMEM; 5370| 0| } 5371| 0| } 5372| 0| yyerror (yyscanner, compiler, yymsgp); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 5373| 0| if (yysyntax_error_status == YYENOMEM) ------------------ | Branch (5373:13): [True: 0, False: 0] ------------------ 5374| 0| YYNOMEM; ------------------ | | 1315| 0|#define YYNOMEM goto yyexhaustedlab ------------------ 5375| 0| } 5376| 0| } 5377| | 5378| 0| if (yyerrstatus == 3) ------------------ | Branch (5378:7): [True: 0, False: 0] ------------------ 5379| 0| { 5380| | /* If just tried and failed to reuse lookahead token after an 5381| | error, discard it. */ 5382| | 5383| 0| if (yychar <= _END_OF_FILE_) ------------------ | | 51| 0|#define yychar yara_yychar ------------------ if (yychar <= _END_OF_FILE_) ------------------ | | 313| 0|#define _END_OF_FILE_ 0 ------------------ | Branch (5383:11): [True: 0, False: 0] ------------------ 5384| 0| { 5385| | /* Return failure if at end of input. */ 5386| 0| if (yychar == _END_OF_FILE_) ------------------ | | 51| 0|#define yychar yara_yychar ------------------ if (yychar == _END_OF_FILE_) ------------------ | | 313| 0|#define _END_OF_FILE_ 0 ------------------ | Branch (5386:15): [True: 0, False: 0] ------------------ 5387| 0| YYABORT; ------------------ | | 1313| 0|#define YYABORT goto yyabortlab ------------------ 5388| 0| } 5389| 0| else 5390| 0| { 5391| 0| yydestruct ("Error: discarding", 5392| 0| yytoken, &yylval, yyscanner, compiler); 5393| 0| yychar = YYEMPTY; ------------------ | | 51| 0|#define yychar yara_yychar ------------------ yychar = YYEMPTY; ------------------ | | 312| 0|#define YYEMPTY -2 ------------------ 5394| 0| } 5395| 0| } 5396| | 5397| | /* Else will try to reuse lookahead token after shifting the error 5398| | token. */ 5399| 0| goto yyerrlab1; 5400| | 5401| | 5402| |/*---------------------------------------------------. 5403| || yyerrorlab -- error raised explicitly by YYERROR. | 5404| |`---------------------------------------------------*/ 5405| 0|yyerrorlab: 5406| | /* Pacify compilers when the user code never invokes YYERROR and the 5407| | label yyerrorlab therefore never appears in user code. */ 5408| 0| if (0) ------------------ | Branch (5408:7): [Folded, False: 0] ------------------ 5409| 0| YYERROR; ------------------ | | 1314| 0|#define YYERROR goto yyerrorlab ------------------ 5410| 0| ++yynerrs; ------------------ | | 53| 0|#define yynerrs yara_yynerrs ------------------ 5411| | 5412| | /* Do not reclaim the symbols of the rule whose action triggered 5413| | this YYERROR. */ 5414| 0| YYPOPSTACK (yylen); ------------------ | | 1950| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5415| 0| yylen = 0; 5416| 0| YY_STACK_PRINT (yyss, yyssp); 5417| 0| yystate = *yyssp; 5418| 0| goto yyerrlab1; 5419| | 5420| | 5421| |/*-------------------------------------------------------------. 5422| || yyerrlab1 -- common code for both syntax error and YYERROR. | 5423| |`-------------------------------------------------------------*/ 5424| 0|yyerrlab1: 5425| 0| yyerrstatus = 3; /* Each real token shifted decrements this. */ 5426| | 5427| | /* Pop stack until we find a state that shifts the error token. */ 5428| 0| for (;;) 5429| 0| { 5430| 0| yyn = yypact[yystate]; 5431| 0| if (!yypact_value_is_default (yyn)) ------------------ | | 1021| 0| ((Yyn) == YYPACT_NINF) | | ------------------ | | | | 1018| 0|#define YYPACT_NINF (-170) | | ------------------ ------------------ | Branch (5431:11): [True: 0, False: 0] ------------------ 5432| 0| { 5433| 0| yyn += YYSYMBOL_YYerror; 5434| 0| if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) ------------------ | | 882| 0|#define YYLAST 480 ------------------ | Branch (5434:15): [True: 0, False: 0] | Branch (5434:27): [True: 0, False: 0] | Branch (5434:44): [True: 0, False: 0] ------------------ 5435| 0| { 5436| 0| yyn = yytable[yyn]; 5437| 0| if (0 < yyn) ------------------ | Branch (5437:19): [True: 0, False: 0] ------------------ 5438| 0| break; 5439| 0| } 5440| 0| } 5441| | 5442| | /* Pop the current state because it cannot handle the error token. */ 5443| 0| if (yyssp == yyss) ------------------ | Branch (5443:11): [True: 0, False: 0] ------------------ 5444| 0| YYABORT; ------------------ | | 1313| 0|#define YYABORT goto yyabortlab ------------------ 5445| | 5446| | 5447| 0| yydestruct ("Error: popping", 5448| 0| YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, compiler); ------------------ | | 967| 0|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5449| 0| YYPOPSTACK (1); ------------------ | | 1950| 0|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5450| 0| yystate = *yyssp; 5451| 0| YY_STACK_PRINT (yyss, yyssp); 5452| 0| } 5453| | 5454| 0| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 5455| 0| *++yyvsp = yylval; 5456| 0| YY_IGNORE_MAYBE_UNINITIALIZED_END 5457| | 5458| | 5459| | /* Shift the error token. */ 5460| 0| YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 5461| | 5462| 0| yystate = yyn; 5463| 0| goto yynewstate; 5464| | 5465| | 5466| |/*-------------------------------------. 5467| || yyacceptlab -- YYACCEPT comes here. | 5468| |`-------------------------------------*/ 5469| 1|yyacceptlab: 5470| 1| yyresult = 0; 5471| 1| goto yyreturnlab; 5472| | 5473| | 5474| |/*-----------------------------------. 5475| || yyabortlab -- YYABORT comes here. | 5476| |`-----------------------------------*/ 5477| 0|yyabortlab: 5478| 0| yyresult = 1; 5479| 0| goto yyreturnlab; 5480| | 5481| | 5482| |/*-----------------------------------------------------------. 5483| || yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 5484| |`-----------------------------------------------------------*/ 5485| 0|yyexhaustedlab: 5486| 0| yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ yyerror (yyscanner, compiler, YY_("memory exhausted")); ------------------ | | 684| 0|# define YY_(Msgid) Msgid ------------------ 5487| 0| yyresult = 2; 5488| 0| goto yyreturnlab; 5489| | 5490| | 5491| |/*----------------------------------------------------------. 5492| || yyreturnlab -- parsing is finished, clean up and return. | 5493| |`----------------------------------------------------------*/ 5494| 1|yyreturnlab: 5495| 1| if (yychar != YYEMPTY) ------------------ | | 51| 1|#define yychar yara_yychar ------------------ if (yychar != YYEMPTY) ------------------ | | 312| 1|#define YYEMPTY -2 ------------------ | Branch (5495:7): [True: 0, False: 1] ------------------ 5496| 0| { 5497| | /* Make sure we have latest lookahead translation. See comments at 5498| | user semantic actions for why this is necessary. */ 5499| 0| yytoken = YYTRANSLATE (yychar); ------------------ | | 900| 0| (0 <= (YYX) && (YYX) <= YYMAXUTOK \ | | ------------------ | | | | 894| 0|#define YYMAXUTOK 319 | | ------------------ | | | Branch (900:4): [True: 0, False: 0] | | | Branch (900:18): [True: 0, False: 0] | | ------------------ | | 901| 0| ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ | | ------------------ | | | | 210| 0|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ | | 902| 0| : YYSYMBOL_YYUNDEF) ------------------ 5500| 0| yydestruct ("Cleanup: discarding lookahead", 5501| 0| yytoken, &yylval, yyscanner, compiler); 5502| 0| } 5503| | /* Do not reclaim the symbols of the rule whose action triggered 5504| | this YYABORT or YYACCEPT. */ 5505| 1| YYPOPSTACK (yylen); ------------------ | | 1950| 1|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5506| 1| YY_STACK_PRINT (yyss, yyssp); 5507| 3| while (yyssp != yyss) ------------------ | Branch (5507:10): [True: 2, False: 1] ------------------ 5508| 2| { 5509| 2| yydestruct ("Cleanup: popping", 5510| 2| YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, compiler); ------------------ | | 967| 2|#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) | | ------------------ | | | | 210| 2|# define YY_CAST(Type, Val) ((Type) (Val)) | | ------------------ ------------------ 5511| 2| YYPOPSTACK (1); ------------------ | | 1950| 2|#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ------------------ 5512| 2| } 5513| 1|#ifndef yyoverflow 5514| 1| if (yyss != yyssa) ------------------ | Branch (5514:7): [True: 0, False: 1] ------------------ 5515| 0| YYSTACK_FREE (yyss); ------------------ | | 792| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5516| 1|#endif 5517| 1| if (yymsg != yymsgbuf) ------------------ | Branch (5517:7): [True: 0, False: 1] ------------------ 5518| 0| YYSTACK_FREE (yymsg); ------------------ | | 792| 0|# define YYSTACK_FREE YYFREE | | ------------------ | | | | 106| 0|#define YYFREE yr_free | | ------------------ ------------------ 5519| 1| return yyresult; 5520| 0|} grammar.c:yydestruct: 1766| 2|{ 1767| 2| YY_USE (yyvaluep); ------------------ | | 707| 2|# define YY_USE(E) ((void) (E)) ------------------ 1768| 2| YY_USE (yyscanner); ------------------ | | 707| 2|# define YY_USE(E) ((void) (E)) ------------------ 1769| 2| YY_USE (compiler); ------------------ | | 707| 2|# define YY_USE(E) ((void) (E)) ------------------ 1770| 2| if (!yymsg) ------------------ | Branch (1770:7): [True: 0, False: 2] ------------------ 1771| 0| yymsg = "Deleting"; 1772| 2| YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 1773| | 1774| 2| YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1775| 2| switch (yykind) 1776| 2| { 1777| 0| case YYSYMBOL__IDENTIFIER_: /* "identifier" */ ------------------ | Branch (1777:5): [True: 0, False: 2] ------------------ 1778| 0|#line 313 "libyara/grammar.y" 1779| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1780| 0|#line 1781 "libyara/grammar.c" 1781| 0| break; 1782| | 1783| 0| case YYSYMBOL__STRING_IDENTIFIER_: /* "string identifier" */ ------------------ | Branch (1783:5): [True: 0, False: 2] ------------------ 1784| 0|#line 317 "libyara/grammar.y" 1785| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1786| 0|#line 1787 "libyara/grammar.c" 1787| 0| break; 1788| | 1789| 0| case YYSYMBOL__STRING_COUNT_: /* "string count" */ ------------------ | Branch (1789:5): [True: 0, False: 2] ------------------ 1790| 0|#line 314 "libyara/grammar.y" 1791| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1792| 0|#line 1793 "libyara/grammar.c" 1793| 0| break; 1794| | 1795| 0| case YYSYMBOL__STRING_OFFSET_: /* "string offset" */ ------------------ | Branch (1795:5): [True: 0, False: 2] ------------------ 1796| 0|#line 315 "libyara/grammar.y" 1797| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1798| 0|#line 1799 "libyara/grammar.c" 1799| 0| break; 1800| | 1801| 0| case YYSYMBOL__STRING_LENGTH_: /* "string length" */ ------------------ | Branch (1801:5): [True: 0, False: 2] ------------------ 1802| 0|#line 316 "libyara/grammar.y" 1803| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1804| 0|#line 1805 "libyara/grammar.c" 1805| 0| break; 1806| | 1807| 0| case YYSYMBOL__STRING_IDENTIFIER_WITH_WILDCARD_: /* "string identifier with wildcard" */ ------------------ | Branch (1807:5): [True: 0, False: 2] ------------------ 1808| 0|#line 318 "libyara/grammar.y" 1809| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1810| 0|#line 1811 "libyara/grammar.c" 1811| 0| break; 1812| | 1813| 0| case YYSYMBOL__TEXT_STRING_: /* "text string" */ ------------------ | Branch (1813:5): [True: 0, False: 2] ------------------ 1814| 0|#line 319 "libyara/grammar.y" 1815| 0| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1816| 0|#line 1817 "libyara/grammar.c" 1817| 0| break; 1818| | 1819| 0| case YYSYMBOL__HEX_STRING_: /* "hex string" */ ------------------ | Branch (1819:5): [True: 0, False: 2] ------------------ 1820| 0|#line 320 "libyara/grammar.y" 1821| 0| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1822| 0|#line 1823 "libyara/grammar.c" 1823| 0| break; 1824| | 1825| 0| case YYSYMBOL__REGEXP_: /* "regular expression" */ ------------------ | Branch (1825:5): [True: 0, False: 2] ------------------ 1826| 0|#line 321 "libyara/grammar.y" 1827| 0| { yr_free(((*yyvaluep).sized_string)); ((*yyvaluep).sized_string) = NULL; } 1828| 0|#line 1829 "libyara/grammar.c" 1829| 0| break; 1830| | 1831| 0| case YYSYMBOL_string_modifiers: /* string_modifiers */ ------------------ | Branch (1831:5): [True: 0, False: 2] ------------------ 1832| 0|#line 337 "libyara/grammar.y" 1833| 0| { 1834| 0| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1834:7): [True: 0, False: 0] ------------------ 1835| 0| { 1836| 0| yr_free(((*yyvaluep).modifier).alphabet); 1837| 0| ((*yyvaluep).modifier).alphabet = NULL; 1838| 0| } 1839| 0|} 1840| 0|#line 1841 "libyara/grammar.c" 1841| 0| break; 1842| | 1843| 0| case YYSYMBOL_string_modifier: /* string_modifier */ ------------------ | Branch (1843:5): [True: 0, False: 2] ------------------ 1844| 0|#line 329 "libyara/grammar.y" 1845| 0| { 1846| 0| if (((*yyvaluep).modifier).alphabet != NULL) ------------------ | Branch (1846:7): [True: 0, False: 0] ------------------ 1847| 0| { 1848| 0| yr_free(((*yyvaluep).modifier).alphabet); 1849| 0| ((*yyvaluep).modifier).alphabet = NULL; 1850| 0| } 1851| 0|} 1852| 0|#line 1853 "libyara/grammar.c" 1853| 0| break; 1854| | 1855| 0| case YYSYMBOL_arguments: /* arguments */ ------------------ | Branch (1855:5): [True: 0, False: 2] ------------------ 1856| 0|#line 326 "libyara/grammar.y" 1857| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1858| 0|#line 1859 "libyara/grammar.c" 1859| 0| break; 1860| | 1861| 0| case YYSYMBOL_arguments_list: /* arguments_list */ ------------------ | Branch (1861:5): [True: 0, False: 2] ------------------ 1862| 0|#line 327 "libyara/grammar.y" 1863| 0| { yr_free(((*yyvaluep).c_string)); ((*yyvaluep).c_string) = NULL; } 1864| 0|#line 1865 "libyara/grammar.c" 1865| 0| break; 1866| | 1867| 0| case YYSYMBOL_string_set: /* string_set */ ------------------ | Branch (1867:5): [True: 0, False: 2] ------------------ 1868| 0|#line 325 "libyara/grammar.y" 1869| 0| { yr_string_set_destroy(((*yyvaluep).string_set)); ((*yyvaluep).string_set).head = NULL; } 1870| 0|#line 1871 "libyara/grammar.c" 1871| 0| break; 1872| | 1873| 0| case YYSYMBOL_string_enumeration: /* string_enumeration */ ------------------ | Branch (1873:5): [True: 0, False: 2] ------------------ 1874| 0|#line 323 "libyara/grammar.y" 1875| 0| { yr_string_set_destroy(((*yyvaluep).string_set)); ((*yyvaluep).string_set).head = NULL; } 1876| 0|#line 1877 "libyara/grammar.c" 1877| 0| break; 1878| | 1879| 0| case YYSYMBOL_string_enumeration_item: /* string_enumeration_item */ ------------------ | Branch (1879:5): [True: 0, False: 2] ------------------ 1880| 0|#line 324 "libyara/grammar.y" 1881| 0| { yr_string_set_destroy(((*yyvaluep).string_set)); ((*yyvaluep).string_set).head = NULL; } 1882| 0|#line 1883 "libyara/grammar.c" 1883| 0| break; 1884| | 1885| 2| default: ------------------ | Branch (1885:7): [True: 2, False: 0] ------------------ 1886| 2| break; 1887| 2| } 1888| 2| YY_IGNORE_MAYBE_UNINITIALIZED_END 1889| 2|} yr_hash: 94| 8|{ 95| 8| const uint8_t* b = (uint8_t*) buffer; 96| | 97| 8| uint32_t result = seed; 98| 8| size_t i; 99| | 100| 8| if (len == 0) ------------------ | Branch (100:7): [True: 0, False: 8] ------------------ 101| 0| return result; 102| | 103| 44| for (i = len - 1; i > 0; i--) ------------------ | Branch (103:21): [True: 36, False: 8] ------------------ 104| 36| { 105| 36| result ^= ROTATE_INT32(byte_to_int32[*b], i); ------------------ | | 46| 36|#define ROTATE_INT32(x, shift) rotl32(x, shift % 32) ------------------ 106| 36| b++; 107| 36| } 108| | 109| 8| result ^= byte_to_int32[*b]; 110| 8| return result; 111| 8|} yr_hash_table_create: 178| 5|{ 179| 5| YR_HASH_TABLE* new_table; 180| 5| int i; 181| | 182| 5| new_table = (YR_HASH_TABLE*) yr_malloc( 183| 5| sizeof(YR_HASH_TABLE) + size * sizeof(YR_HASH_TABLE_ENTRY*)); 184| | 185| 5| if (new_table == NULL) ------------------ | Branch (185:7): [True: 0, False: 5] ------------------ 186| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 187| | 188| 5| new_table->size = size; 189| | 190| 27.0k| for (i = 0; i < size; i++) new_table->buckets[i] = NULL; ------------------ | Branch (190:15): [True: 27.0k, False: 5] ------------------ 191| | 192| 5| *table = new_table; 193| | 194| 5| return ERROR_SUCCESS; ------------------ | | 40| 5|#define ERROR_SUCCESS 0 ------------------ 195| 5|} yr_hash_table_clean: 200| 5|{ 201| 5| YR_HASH_TABLE_ENTRY* entry; 202| 5| YR_HASH_TABLE_ENTRY* next_entry; 203| | 204| 5| int i; 205| | 206| 5| if (table == NULL) ------------------ | Branch (206:7): [True: 0, False: 5] ------------------ 207| 0| return; 208| | 209| 27.0k| for (i = 0; i < table->size; i++) ------------------ | Branch (209:15): [True: 27.0k, False: 5] ------------------ 210| 27.0k| { 211| 27.0k| entry = table->buckets[i]; 212| | 213| 27.0k| while (entry != NULL) ------------------ | Branch (213:12): [True: 3, False: 27.0k] ------------------ 214| 3| { 215| 3| next_entry = entry->next; 216| | 217| 3| if (free_value != NULL) ------------------ | Branch (217:11): [True: 1, False: 2] ------------------ 218| 1| free_value(entry->value); 219| | 220| 3| if (entry->ns != NULL) ------------------ | Branch (220:11): [True: 1, False: 2] ------------------ 221| 1| yr_free(entry->ns); 222| | 223| 3| yr_free(entry->key); 224| 3| yr_free(entry); 225| | 226| 3| entry = next_entry; 227| 3| } 228| | 229| | table->buckets[i] = NULL; 230| 27.0k| } 231| 5|} yr_hash_table_destroy: 236| 5|{ 237| 5| yr_hash_table_clean(table, free_value); 238| 5| yr_free(table); 239| 5|} yr_hash_table_lookup_raw_key: 278| 3|{ 279| | return _yr_hash_table_lookup(table, key, key_length, ns, false); 280| 3|} yr_hash_table_add_raw_key: 297| 3|{ 298| 3| YR_HASH_TABLE_ENTRY* entry; 299| 3| uint32_t bucket_index; 300| | 301| 3| entry = (YR_HASH_TABLE_ENTRY*) yr_malloc(sizeof(YR_HASH_TABLE_ENTRY)); 302| | 303| 3| if (entry == NULL) ------------------ | Branch (303:7): [True: 0, False: 3] ------------------ 304| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 305| | 306| 3| entry->key = yr_malloc(key_length); 307| | 308| 3| if (entry->key == NULL) ------------------ | Branch (308:7): [True: 0, False: 3] ------------------ 309| 0| { 310| 0| yr_free(entry); 311| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 312| 0| } 313| | 314| 3| if (ns != NULL) ------------------ | Branch (314:7): [True: 1, False: 2] ------------------ 315| 1| { 316| 1| entry->ns = yr_strdup(ns); 317| | 318| 1| if (entry->ns == NULL) ------------------ | Branch (318:9): [True: 0, False: 1] ------------------ 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| 1| } 326| 2| else 327| 2| { 328| 2| entry->ns = NULL; 329| 2| } 330| | 331| 3| entry->key_length = key_length; 332| 3| entry->value = value; 333| | 334| 3| memcpy(entry->key, key, key_length); 335| | 336| 3| bucket_index = yr_hash(0, key, key_length); 337| | 338| 3| if (ns != NULL) ------------------ | Branch (338:7): [True: 1, False: 2] ------------------ 339| 1| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 340| | 341| 3| bucket_index = bucket_index % table->size; 342| | 343| 3| entry->next = table->buckets[bucket_index]; 344| 3| table->buckets[bucket_index] = entry; 345| | 346| 3| return ERROR_SUCCESS; ------------------ | | 40| 3|#define ERROR_SUCCESS 0 ------------------ 347| 3|} yr_hash_table_lookup: 353| 1|{ 354| 1| return yr_hash_table_lookup_raw_key(table, (void*) key, strlen(key), ns); 355| 1|} yr_hash_table_add: 370| 1|{ 371| 1| return yr_hash_table_add_raw_key(table, (void*) key, strlen(key), ns, value); 372| 1|} yr_hash_table_add_uint32_raw_key: 399| 2|{ 400| | // Don't allow values equal to UINT32_MAX or UINT32_MAX - 1. 401| 2| if (value >= UINT32_MAX - 1) ------------------ | Branch (401:7): [True: 0, False: 2] ------------------ 402| 0| return ERROR_INVALID_ARGUMENT; ------------------ | | 76| 0|#define ERROR_INVALID_ARGUMENT 29 ------------------ 403| | 404| | // Add +1 to the value in order to avoid putting a NULL pointer in the 405| | // hash table once the integer is casted to a pointer. This is undone 406| | // by yr_hash_table_lookup_uint32. 407| 2| return yr_hash_table_add_raw_key( 408| 2| table, key, key_length, ns, (void*) (size_t) (value + 1)); 409| 2|} yr_hash_table_lookup_uint32_raw_key: 416| 2|{ 417| 2| void* ptr = yr_hash_table_lookup_raw_key(table, key, key_length, ns); 418| | 419| 2| if (ptr == NULL) ------------------ | Branch (419:7): [True: 2, False: 0] ------------------ 420| 2| 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| 0| return ((uint32_t) (size_t) (uint8_t*) ptr) - 1; 425| 2|} hash.c:rotl32: 41| 36|{ 42| 36| assert(shift < 32); ------------------ | Branch (42:3): [True: 0, False: 36] | Branch (42:3): [True: 36, False: 0] ------------------ 43| 36| return (x << shift) | (x >> (-shift & 31)); 44| 36|} hash.c:_yr_hash_table_lookup: 124| 3|{ 125| 3| YR_HASH_TABLE_ENTRY* entry; 126| 3| YR_HASH_TABLE_ENTRY* prev_entry; 127| | 128| 3| void* result; 129| | 130| 3| uint32_t bucket_index = yr_hash(0, key, key_length); 131| | 132| 3| if (ns != NULL) ------------------ | Branch (132:7): [True: 1, False: 2] ------------------ 133| 1| bucket_index = yr_hash(bucket_index, (uint8_t*) ns, strlen(ns)); 134| | 135| 3| bucket_index = bucket_index % table->size; 136| 3| prev_entry = NULL; 137| 3| entry = table->buckets[bucket_index]; 138| | 139| 3| while (entry != NULL) ------------------ | Branch (139:10): [True: 0, False: 3] ------------------ 140| 0| { 141| 0| int key_match = 142| 0| ((entry->key_length == key_length) && ------------------ | Branch (142:10): [True: 0, False: 0] ------------------ 143| 0| (memcmp(entry->key, key, key_length) == 0)); ------------------ | Branch (143:10): [True: 0, False: 0] ------------------ 144| | 145| 0| int ns_match = 146| 0| ((entry->ns == ns) || ------------------ | Branch (146:10): [True: 0, False: 0] ------------------ 147| 0| (entry->ns != NULL && ns != NULL && strcmp(entry->ns, ns) == 0)); ------------------ | Branch (147:11): [True: 0, False: 0] | Branch (147:32): [True: 0, False: 0] | Branch (147:46): [True: 0, False: 0] ------------------ 148| | 149| 0| if (key_match && ns_match) ------------------ | Branch (149:9): [True: 0, False: 0] | Branch (149:22): [True: 0, False: 0] ------------------ 150| 0| { 151| 0| result = entry->value; 152| | 153| 0| if (remove) ------------------ | Branch (153:11): [True: 0, False: 0] ------------------ 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| 0| return result; 168| 0| } 169| | 170| 0| prev_entry = entry; 171| 0| entry = entry->next; 172| 0| } 173| | 174| 3| return NULL; 175| 3|} yara_yylex: 1278| 3|{ 1279| 3| yy_state_type yy_current_state; 1280| 3| char *yy_cp, *yy_bp; 1281| 3| int yy_act; 1282| 3| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 1283| | 1284| 3| yylval = yylval_param; ------------------ | | 1097| 3| # define yylval yyg->yylval_r ------------------ 1285| | 1286| 3| if ( !yyg->yy_init ) ------------------ | Branch (1286:7): [True: 1, False: 2] ------------------ 1287| 1| { 1288| 1| yyg->yy_init = 1; 1289| | 1290| |#ifdef YY_USER_INIT 1291| | YY_USER_INIT; 1292| |#endif 1293| | 1294| 1| if ( ! yyg->yy_start ) ------------------ | Branch (1294:8): [True: 1, False: 0] ------------------ 1295| 1| yyg->yy_start = 1; /* first start state */ 1296| | 1297| 1| if ( ! yyin ) ------------------ | | 344| 1|#define yyin yyg->yyin_r ------------------ | Branch (1297:8): [True: 1, False: 0] ------------------ 1298| 1| yyin = stdin; ------------------ | | 344| 1|#define yyin yyg->yyin_r ------------------ 1299| | 1300| 1| if ( ! yyout ) ------------------ | | 345| 1|#define yyout yyg->yyout_r ------------------ | Branch (1300:8): [True: 1, False: 0] ------------------ 1301| 1| yyout = stdout; ------------------ | | 345| 1|#define yyout yyg->yyout_r ------------------ 1302| | 1303| 1| if ( ! YY_CURRENT_BUFFER ) { ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (1303:8): [True: 0, False: 1] ------------------ 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| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1|#define yy_load_buffer_state yara_yy_load_buffer_state ------------------ 1310| 1| } 1311| | 1312| 3| { 1313| 3|#line 163 "libyara/lexer.l" 1314| | 1315| | 1316| 3|#line 1316 "libyara/lexer.c" 1317| | 1318| 6| while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ ------------------ | Branch (1318:23): [True: 6, Folded] ------------------ 1319| 6| { 1320| 6| yy_cp = yyg->yy_c_buf_p; 1321| | 1322| | /* Support of yytext. */ 1323| 6| *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| 6| yy_bp = yy_cp; 1329| | 1330| 6| yy_current_state = yyg->yy_start; 1331| 6|yy_match: 1332| 6| do 1333| 20| { 1334| 20| YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ------------------ | | 334| 20|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ 1335| 20| if ( yy_accept[yy_current_state] ) ------------------ | Branch (1335:9): [True: 14, False: 6] ------------------ 1336| 14| { 1337| 14| yyg->yy_last_accepting_state = yy_current_state; 1338| 14| yyg->yy_last_accepting_cpos = yy_cp; 1339| 14| } 1340| 31| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (1340:12): [True: 11, False: 20] ------------------ 1341| 11| { 1342| 11| yy_current_state = (int) yy_def[yy_current_state]; 1343| 11| if ( yy_current_state >= 295 ) ------------------ | Branch (1343:10): [True: 5, False: 6] ------------------ 1344| 5| yy_c = yy_meta[yy_c]; 1345| 11| } 1346| 20| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 1347| 20| ++yy_cp; 1348| 20| } 1349| 20| while ( yy_current_state != 294 ); ------------------ | Branch (1349:11): [True: 14, False: 6] ------------------ 1350| 6| yy_cp = yyg->yy_last_accepting_cpos; 1351| 6| yy_current_state = yyg->yy_last_accepting_state; 1352| | 1353| 7|yy_find_action: 1354| 7| yy_act = yy_accept[yy_current_state]; 1355| | 1356| 7| YY_DO_BEFORE_ACTION; ------------------ | | 578| 7| yyg->yytext_ptr = yy_bp; \ | | ------------------ | | | | 567| 7|#define yytext_ptr yytext_r | | ------------------ | | 579| 7| yyleng = (int) (yy_cp - yy_bp); \ | | ------------------ | | | | 347| 7|#define yyleng yyg->yyleng_r | | ------------------ | | 580| 7| yyg->yy_hold_char = *yy_cp; \ | | 581| 7| *yy_cp = '\0'; \ | | 582| 7| yyg->yy_c_buf_p = yy_cp; ------------------ 1357| | 1358| 7| if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] ) ------------------ | | 584| 14|#define YY_END_OF_BUFFER 87 ------------------ | Branch (1358:8): [True: 5, False: 2] | Branch (1358:38): [True: 1, False: 4] ------------------ 1359| 1| { 1360| 1| int yyl; 1361| 2| for ( yyl = 0; yyl < yyleng; ++yyl ) ------------------ | | 347| 2|#define yyleng yyg->yyleng_r ------------------ | Branch (1361:19): [True: 1, False: 1] ------------------ 1362| 1| if ( yytext[yyl] == '\n' ) ------------------ | | 348| 1|#define yytext yyg->yytext_r ------------------ | Branch (1362:10): [True: 0, False: 1] ------------------ 1363| | 1364| 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] | | ------------------ ------------------ 1365| 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] | | ------------------ ------------------ 1366| 0| }while(0) ------------------ | Branch (1366:12): [Folded, False: 0] ------------------ 1367| 1|; 1368| 1| } 1369| | 1370| 8|do_action: /* This label is used only to access EOF actions. */ 1371| | 1372| 8| switch ( yy_act ) 1373| 8| { /* beginning of action switch */ 1374| 0| case 0: /* must back up */ ------------------ | Branch (1374:4): [True: 0, False: 8] ------------------ 1375| | /* undo the effects of YY_DO_BEFORE_ACTION */ 1376| 0| *yy_cp = yyg->yy_hold_char; 1377| 0| yy_cp = yyg->yy_last_accepting_cpos; 1378| 0| yy_current_state = yyg->yy_last_accepting_state; 1379| 0| goto yy_find_action; 1380| | 1381| 0|case 1: ------------------ | Branch (1381:1): [True: 0, False: 8] ------------------ 1382| 0|YY_RULE_SETUP 1383| 0|#line 165 "libyara/lexer.l" 1384| 0|{ return _DOT_DOT_; } ------------------ | | 127| 0|#define _DOT_DOT_ 259 ------------------ 1385| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1386| 0|case 2: ------------------ | Branch (1386:1): [True: 0, False: 8] ------------------ 1387| 0|YY_RULE_SETUP 1388| 0|#line 166 "libyara/lexer.l" 1389| 0|{ return _LT_; } ------------------ | | 180| 0|#define _LT_ 312 ------------------ 1390| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1391| 0|case 3: ------------------ | Branch (1391:1): [True: 0, False: 8] ------------------ 1392| 0|YY_RULE_SETUP 1393| 0|#line 167 "libyara/lexer.l" 1394| 0|{ return _GT_; } ------------------ | | 182| 0|#define _GT_ 314 ------------------ 1395| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1396| 0|case 4: ------------------ | Branch (1396:1): [True: 0, False: 8] ------------------ 1397| 0|YY_RULE_SETUP 1398| 0|#line 168 "libyara/lexer.l" 1399| 0|{ return _LE_; } ------------------ | | 181| 0|#define _LE_ 313 ------------------ 1400| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1401| 0|case 5: ------------------ | Branch (1401:1): [True: 0, False: 8] ------------------ 1402| 0|YY_RULE_SETUP 1403| 0|#line 169 "libyara/lexer.l" 1404| 0|{ return _GE_; } ------------------ | | 183| 0|#define _GE_ 315 ------------------ 1405| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1406| 0|case 6: ------------------ | Branch (1406:1): [True: 0, False: 8] ------------------ 1407| 0|YY_RULE_SETUP 1408| 0|#line 170 "libyara/lexer.l" 1409| 0|{ return _EQ_; } ------------------ | | 178| 0|#define _EQ_ 310 ------------------ 1410| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1411| 0|case 7: ------------------ | Branch (1411:1): [True: 0, False: 8] ------------------ 1412| 0|YY_RULE_SETUP 1413| 0|#line 171 "libyara/lexer.l" 1414| 0|{ return _NEQ_; } ------------------ | | 179| 0|#define _NEQ_ 311 ------------------ 1415| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1416| 0|case 8: ------------------ | Branch (1416:1): [True: 0, False: 8] ------------------ 1417| 0|YY_RULE_SETUP 1418| 0|#line 172 "libyara/lexer.l" 1419| 0|{ return _SHIFT_LEFT_; } ------------------ | | 184| 0|#define _SHIFT_LEFT_ 316 ------------------ 1420| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1421| 0|case 9: ------------------ | Branch (1421:1): [True: 0, False: 8] ------------------ 1422| 0|YY_RULE_SETUP 1423| 0|#line 173 "libyara/lexer.l" 1424| 0|{ return _SHIFT_RIGHT_; } ------------------ | | 185| 0|#define _SHIFT_RIGHT_ 317 ------------------ 1425| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1426| 0|case 10: ------------------ | Branch (1426:1): [True: 0, False: 8] ------------------ 1427| 0|YY_RULE_SETUP 1428| 0|#line 174 "libyara/lexer.l" 1429| 0|{ return _PRIVATE_; } ------------------ | | 129| 0|#define _PRIVATE_ 261 ------------------ 1430| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1431| 0|case 11: ------------------ | Branch (1431:1): [True: 0, False: 8] ------------------ 1432| 0|YY_RULE_SETUP 1433| 0|#line 175 "libyara/lexer.l" 1434| 0|{ return _GLOBAL_; } ------------------ | | 130| 0|#define _GLOBAL_ 262 ------------------ 1435| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1436| 0|case 12: ------------------ | Branch (1436:1): [True: 0, False: 8] ------------------ 1437| 0|YY_RULE_SETUP 1438| 0|#line 176 "libyara/lexer.l" 1439| 0|{ return _RULE_; } ------------------ | | 128| 0|#define _RULE_ 260 ------------------ 1440| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1441| 0|case 13: ------------------ | Branch (1441:1): [True: 0, False: 8] ------------------ 1442| 0|YY_RULE_SETUP 1443| 0|#line 177 "libyara/lexer.l" 1444| 0|{ return _META_; } ------------------ | | 131| 0|#define _META_ 263 ------------------ 1445| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1446| 0|case 14: ------------------ | Branch (1446:1): [True: 0, False: 8] ------------------ 1447| 0|YY_RULE_SETUP 1448| 0|#line 178 "libyara/lexer.l" 1449| 0|{ return _STRINGS_; } ------------------ | | 132| 0|#define _STRINGS_ 264 ------------------ 1450| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1451| 0|case 15: ------------------ | Branch (1451:1): [True: 0, False: 8] ------------------ 1452| 0|YY_RULE_SETUP 1453| 0|#line 179 "libyara/lexer.l" 1454| 0|{ return _ASCII_; } ------------------ | | 146| 0|#define _ASCII_ 278 ------------------ 1455| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1456| 0|case 16: ------------------ | Branch (1456:1): [True: 0, False: 8] ------------------ 1457| 0|YY_RULE_SETUP 1458| 0|#line 180 "libyara/lexer.l" 1459| 0|{ return _WIDE_; } ------------------ | | 147| 0|#define _WIDE_ 279 ------------------ 1460| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1461| 0|case 17: ------------------ | Branch (1461:1): [True: 0, False: 8] ------------------ 1462| 0|YY_RULE_SETUP 1463| 0|#line 181 "libyara/lexer.l" 1464| 0|{ return _XOR_; } ------------------ | | 148| 0|#define _XOR_ 280 ------------------ 1465| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1466| 0|case 18: ------------------ | Branch (1466:1): [True: 0, False: 8] ------------------ 1467| 0|YY_RULE_SETUP 1468| 0|#line 182 "libyara/lexer.l" 1469| 0|{ return _BASE64_; } ------------------ | | 149| 0|#define _BASE64_ 281 ------------------ 1470| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1471| 0|case 19: ------------------ | Branch (1471:1): [True: 0, False: 8] ------------------ 1472| 0|YY_RULE_SETUP 1473| 0|#line 183 "libyara/lexer.l" 1474| 0|{ return _BASE64_WIDE_; } ------------------ | | 150| 0|#define _BASE64_WIDE_ 282 ------------------ 1475| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1476| 0|case 20: ------------------ | Branch (1476:1): [True: 0, False: 8] ------------------ 1477| 0|YY_RULE_SETUP 1478| 0|#line 184 "libyara/lexer.l" 1479| 0|{ return _FULLWORD_; } ------------------ | | 152| 0|#define _FULLWORD_ 284 ------------------ 1480| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1481| 0|case 21: ------------------ | Branch (1481:1): [True: 0, False: 8] ------------------ 1482| 0|YY_RULE_SETUP 1483| 0|#line 185 "libyara/lexer.l" 1484| 0|{ return _NOCASE_; } ------------------ | | 151| 0|#define _NOCASE_ 283 ------------------ 1485| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1486| 0|case 22: ------------------ | Branch (1486:1): [True: 0, False: 8] ------------------ 1487| 0|YY_RULE_SETUP 1488| 0|#line 186 "libyara/lexer.l" 1489| 0|{ return _CONDITION_; } ------------------ | | 133| 0|#define _CONDITION_ 265 ------------------ 1490| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1491| 0|case 23: ------------------ | Branch (1491:1): [True: 0, False: 8] ------------------ 1492| 0|YY_RULE_SETUP 1493| 0|#line 187 "libyara/lexer.l" 1494| 0|{ return _TRUE_; } ------------------ | | 172| 0|#define _TRUE_ 304 ------------------ 1495| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1496| 0|case 24: ------------------ | Branch (1496:1): [True: 0, False: 8] ------------------ 1497| 0|YY_RULE_SETUP 1498| 0|#line 188 "libyara/lexer.l" 1499| 0|{ return _FALSE_; } ------------------ | | 173| 0|#define _FALSE_ 305 ------------------ 1500| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1501| 0|case 25: ------------------ | Branch (1501:1): [True: 0, False: 8] ------------------ 1502| 0|YY_RULE_SETUP 1503| 0|#line 189 "libyara/lexer.l" 1504| 0|{ return _NOT_; } ------------------ | | 176| 0|#define _NOT_ 308 ------------------ 1505| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1506| 0|case 26: ------------------ | Branch (1506:1): [True: 0, False: 8] ------------------ 1507| 0|YY_RULE_SETUP 1508| 0|#line 190 "libyara/lexer.l" 1509| 0|{ return _AND_; } ------------------ | | 175| 0|#define _AND_ 307 ------------------ 1510| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1511| 0|case 27: ------------------ | Branch (1511:1): [True: 0, False: 8] ------------------ 1512| 0|YY_RULE_SETUP 1513| 0|#line 191 "libyara/lexer.l" 1514| 0|{ return _OR_; } ------------------ | | 174| 0|#define _OR_ 306 ------------------ 1515| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1516| 0|case 28: ------------------ | Branch (1516:1): [True: 0, False: 8] ------------------ 1517| 0|YY_RULE_SETUP 1518| 0|#line 192 "libyara/lexer.l" 1519| 0|{ return _AT_; } ------------------ | | 153| 0|#define _AT_ 285 ------------------ 1520| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1521| 0|case 29: ------------------ | Branch (1521:1): [True: 0, False: 8] ------------------ 1522| 0|YY_RULE_SETUP 1523| 0|#line 193 "libyara/lexer.l" 1524| 0|{ return _IN_; } ------------------ | | 159| 0|#define _IN_ 291 ------------------ 1525| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1526| 0|case 30: ------------------ | Branch (1526:1): [True: 0, False: 8] ------------------ 1527| 0|YY_RULE_SETUP 1528| 0|#line 194 "libyara/lexer.l" 1529| 0|{ return _OF_; } ------------------ | | 160| 0|#define _OF_ 292 ------------------ 1530| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1531| 0|case 31: ------------------ | Branch (1531:1): [True: 0, False: 8] ------------------ 1532| 0|YY_RULE_SETUP 1533| 0|#line 195 "libyara/lexer.l" 1534| 0|{ return _THEM_; } ------------------ | | 162| 0|#define _THEM_ 294 ------------------ 1535| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1536| 0|case 32: ------------------ | Branch (1536:1): [True: 0, False: 8] ------------------ 1537| 0|YY_RULE_SETUP 1538| 0|#line 196 "libyara/lexer.l" 1539| 0|{ return _FOR_; } ------------------ | | 161| 0|#define _FOR_ 293 ------------------ 1540| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1541| 0|case 33: ------------------ | Branch (1541:1): [True: 0, False: 8] ------------------ 1542| 0|YY_RULE_SETUP 1543| 0|#line 197 "libyara/lexer.l" 1544| 0|{ return _ALL_; } ------------------ | | 156| 0|#define _ALL_ 288 ------------------ 1545| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1546| 0|case 34: ------------------ | Branch (1546:1): [True: 0, False: 8] ------------------ 1547| 0|YY_RULE_SETUP 1548| 0|#line 198 "libyara/lexer.l" 1549| 0|{ return _ANY_; } ------------------ | | 157| 0|#define _ANY_ 289 ------------------ 1550| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1551| 0|case 35: ------------------ | Branch (1551:1): [True: 0, False: 8] ------------------ 1552| 0|YY_RULE_SETUP 1553| 0|#line 199 "libyara/lexer.l" 1554| 0|{ return _NONE_; } ------------------ | | 158| 0|#define _NONE_ 290 ------------------ 1555| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1556| 0|case 36: ------------------ | Branch (1556:1): [True: 0, False: 8] ------------------ 1557| 0|YY_RULE_SETUP 1558| 0|#line 200 "libyara/lexer.l" 1559| 0|{ return _ENTRYPOINT_; } ------------------ | | 155| 0|#define _ENTRYPOINT_ 287 ------------------ 1560| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1561| 0|case 37: ------------------ | Branch (1561:1): [True: 0, False: 8] ------------------ 1562| 0|YY_RULE_SETUP 1563| 0|#line 201 "libyara/lexer.l" 1564| 0|{ return _FILESIZE_; } ------------------ | | 154| 0|#define _FILESIZE_ 286 ------------------ 1565| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1566| 0|case 38: ------------------ | Branch (1566:1): [True: 0, False: 8] ------------------ 1567| 0|YY_RULE_SETUP 1568| 0|#line 202 "libyara/lexer.l" 1569| 0|{ return _MATCHES_; } ------------------ | | 163| 0|#define _MATCHES_ 295 ------------------ 1570| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1571| 0|case 39: ------------------ | Branch (1571:1): [True: 0, False: 8] ------------------ 1572| 0|YY_RULE_SETUP 1573| 0|#line 203 "libyara/lexer.l" 1574| 0|{ return _CONTAINS_; } ------------------ | | 164| 0|#define _CONTAINS_ 296 ------------------ 1575| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1576| 0|case 40: ------------------ | Branch (1576:1): [True: 0, False: 8] ------------------ 1577| 0|YY_RULE_SETUP 1578| 0|#line 204 "libyara/lexer.l" 1579| 0|{ return _STARTSWITH_; } ------------------ | | 165| 0|#define _STARTSWITH_ 297 ------------------ 1580| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1581| 0|case 41: ------------------ | Branch (1581:1): [True: 0, False: 8] ------------------ 1582| 0|YY_RULE_SETUP 1583| 0|#line 205 "libyara/lexer.l" 1584| 0|{ return _ENDSWITH_; } ------------------ | | 166| 0|#define _ENDSWITH_ 298 ------------------ 1585| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1586| 0|case 42: ------------------ | Branch (1586:1): [True: 0, False: 8] ------------------ 1587| 0|YY_RULE_SETUP 1588| 0|#line 206 "libyara/lexer.l" 1589| 0|{ return _ICONTAINS_; } ------------------ | | 167| 0|#define _ICONTAINS_ 299 ------------------ 1590| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1591| 0|case 43: ------------------ | Branch (1591:1): [True: 0, False: 8] ------------------ 1592| 0|YY_RULE_SETUP 1593| 0|#line 207 "libyara/lexer.l" 1594| 0|{ return _ISTARTSWITH_; } ------------------ | | 168| 0|#define _ISTARTSWITH_ 300 ------------------ 1595| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1596| 0|case 44: ------------------ | Branch (1596:1): [True: 0, False: 8] ------------------ 1597| 0|YY_RULE_SETUP 1598| 0|#line 208 "libyara/lexer.l" 1599| 0|{ return _IENDSWITH_; } ------------------ | | 169| 0|#define _IENDSWITH_ 301 ------------------ 1600| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1601| 0|case 45: ------------------ | Branch (1601:1): [True: 0, False: 8] ------------------ 1602| 0|YY_RULE_SETUP 1603| 0|#line 209 "libyara/lexer.l" 1604| 0|{ return _IEQUALS_; } ------------------ | | 170| 0|#define _IEQUALS_ 302 ------------------ 1605| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1606| 1|case 46: ------------------ | Branch (1606:1): [True: 1, False: 7] ------------------ 1607| 1|YY_RULE_SETUP 1608| 1|#line 210 "libyara/lexer.l" 1609| 1|{ return _IMPORT_; } ------------------ | | 171| 1|#define _IMPORT_ 303 ------------------ 1610| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1611| 0|case 47: ------------------ | Branch (1611:1): [True: 0, False: 8] ------------------ 1612| 0|YY_RULE_SETUP 1613| 0|#line 211 "libyara/lexer.l" 1614| 0|{ return _DEFINED_; } ------------------ | | 177| 0|#define _DEFINED_ 309 ------------------ 1615| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1616| 0|case 48: ------------------ | Branch (1616:1): [True: 0, False: 8] ------------------ 1617| 0|YY_RULE_SETUP 1618| 0|#line 214 "libyara/lexer.l" 1619| 0|{ BEGIN(comment); } ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(comment); } ------------------ | | 1043| 0|#define comment 4 ------------------ 1620| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1621| 0|case 49: ------------------ | Branch (1621:1): [True: 0, False: 8] ------------------ 1622| 0|YY_RULE_SETUP 1623| 0|#line 215 "libyara/lexer.l" 1624| 0|{ BEGIN(INITIAL); } ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ { BEGIN(INITIAL); } ------------------ | | 1039| 0|#define INITIAL 0 ------------------ 1625| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1626| 0|case 50: ------------------ | Branch (1626:1): [True: 0, False: 8] ------------------ 1627| |/* rule 50 can match eol */ 1628| 0|YY_RULE_SETUP 1629| 0|#line 216 "libyara/lexer.l" 1630| 0|{ /* skip comments */ } 1631| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1632| 0|case 51: ------------------ | Branch (1632:1): [True: 0, False: 8] ------------------ 1633| 0|YY_RULE_SETUP 1634| 0|#line 219 "libyara/lexer.l" 1635| 0|{ /* skip single-line comments */ } 1636| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1637| 0|case 52: ------------------ | Branch (1637:1): [True: 0, False: 8] ------------------ 1638| 0|YY_RULE_SETUP 1639| 0|#line 222 "libyara/lexer.l" 1640| 0|{ 1641| 0| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1642| 0| yyextra->lex_buf_len = 0; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1643| 0| BEGIN(include); ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(include); ------------------ | | 1042| 0|#define include 3 ------------------ 1644| 0| } 1645| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1646| 0|case 53: ------------------ | Branch (1646:1): [True: 0, False: 8] ------------------ 1647| |/* rule 53 can match eol */ 1648| 0|YY_RULE_SETUP 1649| 0|#line 229 "libyara/lexer.l" 1650| 0|{ yytext_to_buffer; } ------------------ | | 991| 0| { \ | | 992| 0| char *yptr = yytext; \ | | ------------------ | | | | 348| 0|#define yytext yyg->yytext_r | | ------------------ | | 993| 0| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 0, False: 0] | | | | ------------------ | | | | 985| 0| { \ | | | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 0| } | | ------------------ | | 994| 0| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 0, False: 0] | | ------------------ | | 995| 0| { \ | | 996| 0| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 0| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 0| } \ | | 999| 0| } ------------------ 1651| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1652| 0|case 54: ------------------ | Branch (1652:1): [True: 0, False: 8] ------------------ 1653| 0|YY_RULE_SETUP 1654| 0|#line 232 "libyara/lexer.l" 1655| 0|{ 1656| | 1657| 0| if (compiler->include_callback != NULL) ------------------ | Branch (1657:7): [True: 0, False: 0] ------------------ 1658| 0| { 1659| | #ifdef _MSC_VER 1660| | char* b = NULL; 1661| | #endif 1662| 0| char* s = NULL; 1663| 0| char* f; 1664| | 1665| 0| char buffer[1024]; 1666| 0| const char* included_rules; 1667| 0| char* current_file_name; 1668| 0| char* include_path; 1669| | 1670| 0| *yyextra->lex_buf_ptr = '\0'; // null-terminate included file path ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1671| | 1672| 0| current_file_name = yr_compiler_get_current_file_name(compiler); 1673| | 1674| 0| if (current_file_name == NULL || ------------------ | Branch (1674:9): [True: 0, False: 0] ------------------ 1675| 0| compiler->include_callback != _yr_compiler_default_include_callback || ------------------ | Branch (1675:9): [True: 0, False: 0] ------------------ 1676| 0| is_absolute_path(yyextra->lex_buf)) ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ | Branch (1676:9): [True: 0, False: 0] ------------------ 1677| 0| { 1678| 0| include_path = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1679| 0| } 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| 0| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1711| 0| compiler->arena, 1712| 0| YR_NAMESPACES_TABLE, ------------------ | | 57| 0|#define YR_NAMESPACES_TABLE 0 ------------------ 1713| 0| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1714| | 1715| 0| included_rules = compiler->include_callback( 1716| 0| include_path, 1717| 0| current_file_name, 1718| 0| ns->name, 1719| 0| compiler->incl_clbk_user_data); 1720| | 1721| 0| if (included_rules != NULL) ------------------ | Branch (1721:9): [True: 0, False: 0] ------------------ 1722| 0| { 1723| 0| int error_code = _yr_compiler_push_file_name(compiler, include_path); 1724| | 1725| 0| if (error_code != ERROR_SUCCESS) ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ | Branch (1725:11): [True: 0, False: 0] ------------------ 1726| 0| { 1727| 0| if (error_code == ERROR_INCLUDES_CIRCULAR_REFERENCE) ------------------ | | 67| 0|#define ERROR_INCLUDES_CIRCULAR_REFERENCE 22 ------------------ | Branch (1727:13): [True: 0, False: 0] ------------------ 1728| 0| { 1729| 0| yyerror(yyscanner, compiler, "includes circular reference"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1730| 0| } 1731| 0| else if (error_code == ERROR_INCLUDE_DEPTH_EXCEEDED) ------------------ | | 68| 0|#define ERROR_INCLUDE_DEPTH_EXCEEDED 23 ------------------ | Branch (1731:18): [True: 0, False: 0] ------------------ 1732| 0| { 1733| 0| yyerror(yyscanner, compiler, "includes depth exceeded"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1734| 0| } 1735| | 1736| 0| if (compiler->include_free != NULL) ------------------ | Branch (1736:13): [True: 0, False: 0] ------------------ 1737| 0| { 1738| 0| compiler->include_free(included_rules, compiler->incl_clbk_user_data); 1739| 0| } 1740| | 1741| 0| yyterminate(); ------------------ | | 1232| 0|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 0|#define YY_NULL 0 | | ------------------ ------------------ 1742| 0| } 1743| | 1744| | // Workaround for flex issue: https://github.com/westes/flex/issues/58 1745| 0| yypush_buffer_state(YY_CURRENT_BUFFER, yyscanner); ------------------ | | 74| 0|#define yypush_buffer_state yara_yypush_buffer_state ------------------ yypush_buffer_state(YY_CURRENT_BUFFER, yyscanner); ------------------ | | 509| 0|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 0, False: 0] | | ------------------ | | 510| 0| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 0| : NULL) ------------------ 1746| 0| yy_scan_string(included_rules, yyscanner); ------------------ | | 38| 0|#define yy_scan_string yara_yy_scan_string ------------------ 1747| 0| yyset_lineno(1, yyscanner); ------------------ | | 188| 0|#define yyset_lineno yara_yyset_lineno ------------------ 1748| | 1749| 0| if (compiler->include_free != NULL) ------------------ | Branch (1749:11): [True: 0, False: 0] ------------------ 1750| 0| { 1751| 0| compiler->include_free(included_rules, compiler->incl_clbk_user_data); 1752| 0| } 1753| 0| } 1754| 0| else 1755| 0| { 1756| 0| char* err_msg_fmt; 1757| 0| char err_msg[512]; 1758| | 1759| 0| if (compiler->include_callback == _yr_compiler_default_include_callback) ------------------ | Branch (1759:11): [True: 0, False: 0] ------------------ 1760| 0| { 1761| 0| err_msg_fmt = "can't open include file: %s"; 1762| 0| } 1763| 0| else 1764| 0| { 1765| 0| err_msg_fmt = "callback failed to provide include resource: %s"; 1766| 0| } 1767| | 1768| 0| snprintf( 1769| 0| err_msg, 1770| 0| sizeof(err_msg), 1771| 0| err_msg_fmt, 1772| 0| yyextra->lex_buf); ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 1773| | 1774| 0| yyerror(yyscanner, compiler, err_msg); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1775| 0| } 1776| | 1777| 0| } 1778| 0| else // not allowing includes 1779| 0| { 1780| 0| yyerror(yyscanner, compiler, "includes are disabled"); ------------------ | | 48| 0|#define yyerror yara_yyerror ------------------ 1781| 0| } 1782| | 1783| 0| BEGIN(INITIAL); ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 0|#define INITIAL 0 ------------------ 1784| 0|} 1785| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1786| 1|case YY_STATE_EOF(INITIAL): ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1786:1): [True: 1, False: 7] ------------------ 1787| 1|case YY_STATE_EOF(str): ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1787:1): [True: 0, False: 8] ------------------ 1788| 1|case YY_STATE_EOF(regexp): ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1788:1): [True: 0, False: 8] ------------------ 1789| 1|case YY_STATE_EOF(include): ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1789:1): [True: 0, False: 8] ------------------ 1790| 1|case YY_STATE_EOF(comment): ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ | Branch (1790:1): [True: 0, False: 8] ------------------ 1791| 1|#line 364 "libyara/lexer.l" 1792| 1|{ 1793| | 1794| 1| yypop_buffer_state(yyscanner); ------------------ | | 80| 1|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 1795| | 1796| 1| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (1796:7): [True: 1, False: 0] ------------------ 1797| 1| yyterminate(); ------------------ | | 1232| 1|#define yyterminate() return YY_NULL | | ------------------ | | | | 329| 1|#define YY_NULL 0 | | ------------------ ------------------ 1798| | 1799| 0| return _END_OF_INCLUDED_FILE_; ------------------ | | 126| 0|#define _END_OF_INCLUDED_FILE_ 258 ------------------ 1800| 1|} 1801| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1802| 0|case 55: ------------------ | Branch (1802:1): [True: 0, False: 8] ------------------ 1803| 0|YY_RULE_SETUP 1804| 0|#line 375 "libyara/lexer.l" 1805| 0|{ 1806| | 1807| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1808| | 1809| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1809:7): [True: 0, False: 0] ------------------ 1810| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1811| | 1812| 0| return _STRING_IDENTIFIER_WITH_WILDCARD_; ------------------ | | 139| 0|#define _STRING_IDENTIFIER_WITH_WILDCARD_ 271 ------------------ 1813| 0|} 1814| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1815| 0|case 56: ------------------ | Branch (1815:1): [True: 0, False: 8] ------------------ 1816| 0|YY_RULE_SETUP 1817| 0|#line 386 "libyara/lexer.l" 1818| 0|{ 1819| | 1820| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1821| | 1822| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1822:7): [True: 0, False: 0] ------------------ 1823| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1824| | 1825| 0| return _STRING_IDENTIFIER_; ------------------ | | 135| 0|#define _STRING_IDENTIFIER_ 267 ------------------ 1826| 0|} 1827| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1828| 0|case 57: ------------------ | Branch (1828:1): [True: 0, False: 8] ------------------ 1829| 0|YY_RULE_SETUP 1830| 0|#line 397 "libyara/lexer.l" 1831| 0|{ 1832| | 1833| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1834| | 1835| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1835:7): [True: 0, False: 0] ------------------ 1836| 0| { 1837| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1838| 0| } 1839| 0| else 1840| 0| { 1841| 0| yylval->c_string[0] = '$'; /* replace # by $*/ ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1842| 0| } 1843| | 1844| 0| return _STRING_COUNT_; ------------------ | | 136| 0|#define _STRING_COUNT_ 268 ------------------ 1845| 0|} 1846| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1847| 0|case 58: ------------------ | Branch (1847:1): [True: 0, False: 8] ------------------ 1848| 0|YY_RULE_SETUP 1849| 0|#line 414 "libyara/lexer.l" 1850| 0|{ 1851| | 1852| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1853| | 1854| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1854:7): [True: 0, False: 0] ------------------ 1855| 0| { 1856| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1857| 0| } 1858| 0| else 1859| 0| { 1860| 0| yylval->c_string[0] = '$'; /* replace @ by $*/ ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1861| 0| } 1862| | 1863| 0| return _STRING_OFFSET_; ------------------ | | 137| 0|#define _STRING_OFFSET_ 269 ------------------ 1864| 0|} 1865| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1866| 0|case 59: ------------------ | Branch (1866:1): [True: 0, False: 8] ------------------ 1867| 0|YY_RULE_SETUP 1868| 0|#line 431 "libyara/lexer.l" 1869| 0|{ 1870| | 1871| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1872| | 1873| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1873:7): [True: 0, False: 0] ------------------ 1874| 0| { 1875| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1876| 0| } 1877| 0| else 1878| 0| { 1879| 0| yylval->c_string[0] = '$'; /* replace ! by $*/ ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1880| 0| } 1881| | 1882| 0| return _STRING_LENGTH_; ------------------ | | 138| 0|#define _STRING_LENGTH_ 270 ------------------ 1883| 0|} 1884| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1885| 0|case 60: ------------------ | Branch (1885:1): [True: 0, False: 8] ------------------ 1886| 0|YY_RULE_SETUP 1887| 0|#line 448 "libyara/lexer.l" 1888| 0|{ 1889| | 1890| 0| char* text = yytext; ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1891| | 1892| 0| if (*text == 'u') ------------------ | Branch (1892:7): [True: 0, False: 0] ------------------ 1893| 0| { 1894| 0| yylval->integer = 3; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1895| 0| text++; 1896| 0| } 1897| 0| else 1898| 0| { 1899| 0| yylval->integer = 0; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1900| 0| } 1901| | 1902| 0| if (strstr(text, "int8") == text) ------------------ | Branch (1902:7): [True: 0, False: 0] ------------------ 1903| 0| { 1904| 0| yylval->integer += 0; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1905| 0| text += 4; 1906| 0| } 1907| 0| else if (strstr(text, "int16") == text) ------------------ | Branch (1907:12): [True: 0, False: 0] ------------------ 1908| 0| { 1909| 0| yylval->integer += 1; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1910| 0| text += 5; 1911| 0| } 1912| 0| else if (strstr(text, "int32") == text) ------------------ | Branch (1912:12): [True: 0, False: 0] ------------------ 1913| 0| { 1914| 0| yylval->integer += 2; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1915| 0| text += 5; 1916| 0| } 1917| | 1918| 0| if (strcmp(text, "be") == 0) ------------------ | Branch (1918:7): [True: 0, False: 0] ------------------ 1919| 0| { 1920| 0| yylval->integer += 6; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1921| 0| } 1922| | 1923| 0| return _INTEGER_FUNCTION_; ------------------ | | 142| 0|#define _INTEGER_FUNCTION_ 274 ------------------ 1924| 0|} 1925| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1926| 0|case 61: ------------------ | Branch (1926:1): [True: 0, False: 8] ------------------ 1927| 0|YY_RULE_SETUP 1928| 0|#line 487 "libyara/lexer.l" 1929| 0|{ 1930| | 1931| 0| if (strlen(yytext) > 128) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (1931:7): [True: 0, False: 0] ------------------ 1932| 0| syntax_error("identifier too long"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 1933| | 1934| 0| yylval->c_string = yr_strdup(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->c_string = yr_strdup(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1935| | 1936| 0| if (yylval->c_string == NULL) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1936:7): [True: 0, False: 0] ------------------ 1937| 0| error(ERROR_INSUFFICIENT_MEMORY); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1938| | 1939| 0| return _IDENTIFIER_; ------------------ | | 134| 0|#define _IDENTIFIER_ 266 ------------------ 1940| 0|} 1941| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1942| 0|case 62: ------------------ | Branch (1942:1): [True: 0, False: 8] ------------------ 1943| 0|YY_RULE_SETUP 1944| 0|#line 501 "libyara/lexer.l" 1945| 0|{ 1946| | 1947| 0| char *endptr; 1948| | 1949| 0| errno = 0; 1950| 0| yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 10); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1951| | 1952| 0| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1952:7): [True: 0, False: 0] | Branch (1952:39): [True: 0, False: 0] ------------------ 1953| 0| { 1954| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 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); \ | | ------------------ | | | | 48| 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| 0| else if (strstr(yytext, "KB") != NULL) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (1957:12): [True: 0, False: 0] ------------------ 1958| 0| { 1959| 0| if (yylval->integer > LLONG_MAX / 1024) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1959:9): [True: 0, False: 0] ------------------ 1960| 0| { 1961| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 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); \ | | ------------------ | | | | 48| 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| 0| else 1965| 0| { 1966| 0| yylval->integer *= 1024; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1967| 0| } 1968| 0| } 1969| 0| else if (strstr(yytext, "MB") != NULL) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (1969:12): [True: 0, False: 0] ------------------ 1970| 0| { 1971| 0| if (yylval->integer > LLONG_MAX / 1048576) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (1971:9): [True: 0, False: 0] ------------------ 1972| 0| { 1973| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1974| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 1975| 0| } 1976| 0| else 1977| 0| { 1978| 0| yylval->integer *= 1048576; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 1979| 0| } 1980| 0| } 1981| | 1982| 0| return _NUMBER_; ------------------ | | 140| 0|#define _NUMBER_ 272 ------------------ 1983| 0|} 1984| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1985| 0|case 63: ------------------ | Branch (1985:1): [True: 0, False: 8] ------------------ 1986| 0|YY_RULE_SETUP 1987| 0|#line 541 "libyara/lexer.l" 1988| 0|{ 1989| 0| yylval->double_ = atof(yytext); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->double_ = atof(yytext); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 1990| 0| return _DOUBLE_; ------------------ | | 141| 0|#define _DOUBLE_ 273 ------------------ 1991| 0|} 1992| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 1993| 0|case 64: ------------------ | Branch (1993:1): [True: 0, False: 8] ------------------ 1994| 0|YY_RULE_SETUP 1995| 0|#line 546 "libyara/lexer.l" 1996| 0|{ 1997| | 1998| 0| char *endptr; 1999| | 2000| 0| errno = 0; 2001| 0| yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext, &endptr, 16); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2002| | 2003| 0| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (2003:7): [True: 0, False: 0] | Branch (2003:39): [True: 0, False: 0] ------------------ 2004| 0| { 2005| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2006| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 2007| 0| } 2008| | 2009| 0| return _NUMBER_; ------------------ | | 140| 0|#define _NUMBER_ 272 ------------------ 2010| 0|} 2011| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2012| 0|case 65: ------------------ | Branch (2012:1): [True: 0, False: 8] ------------------ 2013| 0|YY_RULE_SETUP 2014| 0|#line 562 "libyara/lexer.l" 2015| 0|{ 2016| | 2017| 0| char *endptr; 2018| | 2019| 0| errno = 0; 2020| 0| yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ yylval->integer = strtoll(yytext + 2, &endptr, 8); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2021| | 2022| 0| if (yylval->integer == LLONG_MAX && errno == ERANGE) ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ | Branch (2022:7): [True: 0, False: 0] | Branch (2022:39): [True: 0, False: 0] ------------------ 2023| 0| { 2024| 0| yr_compiler_set_error_extra_info(compiler, yytext); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 2025| 0| error(ERROR_INTEGER_OVERFLOW); ------------------ | | 971| 0| { \ | | 972| 0| compiler->last_error = error_code; \ | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 974| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 975| 0| } ------------------ 2026| 0| } 2027| | 2028| 0| return _NUMBER_; ------------------ | | 140| 0|#define _NUMBER_ 272 ------------------ 2029| 0|} 2030| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2031| 1|case 66: ------------------ | Branch (2031:1): [True: 1, False: 7] ------------------ 2032| 1|YY_RULE_SETUP 2033| 1|#line 579 "libyara/lexer.l" 2034| 1|{ /* saw closing quote - all done */ 2035| | 2036| 1| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 1| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 1| str_len + sizeof(SIZED_STRING)); \ | | 1004| 1| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 1] | | ------------------ | | 1005| 1| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 1| else \ | | 1010| 1| { \ | | 1011| 1| str->length = (uint32_t) (str_len); \ | | 1012| 1| str->flags = 0; \ | | 1013| 1| } \ ------------------ 2037| | 2038| 1| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ 2039| 1| memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ memcpy(s->c_string, yyextra->lex_buf, yyextra->lex_buf_len + 1); ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ 2040| | 2041| 1| yylval->sized_string = s; ------------------ | | 1097| 1| # define yylval yyg->yylval_r ------------------ 2042| | 2043| 1| BEGIN(INITIAL); ------------------ | | 357| 1|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 1|#define INITIAL 0 ------------------ 2044| | 2045| 1| return _TEXT_STRING_; ------------------ | | 143| 1|#define _TEXT_STRING_ 275 ------------------ 2046| 1|} 2047| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2048| 0|case 67: ------------------ | Branch (2048:1): [True: 0, False: 8] ------------------ 2049| 0|YY_RULE_SETUP 2050| 0|#line 594 "libyara/lexer.l" 2051| 0|{ 2052| | 2053| 0| lex_check_space_ok("\t", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2054| 0| *yyextra->lex_buf_ptr++ = '\t'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2055| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2056| 0|} 2057| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2058| 0|case 68: ------------------ | Branch (2058:1): [True: 0, False: 8] ------------------ 2059| 0|YY_RULE_SETUP 2060| 0|#line 602 "libyara/lexer.l" 2061| 0|{ 2062| | 2063| 0| lex_check_space_ok("\r", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2064| 0| *yyextra->lex_buf_ptr++ = '\r'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2065| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2066| 0|} 2067| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2068| 0|case 69: ------------------ | Branch (2068:1): [True: 0, False: 8] ------------------ 2069| 0|YY_RULE_SETUP 2070| 0|#line 610 "libyara/lexer.l" 2071| 0|{ 2072| | 2073| 0| lex_check_space_ok("\n", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2074| 0| *yyextra->lex_buf_ptr++ = '\n'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2075| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2076| 0|} 2077| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2078| 0|case 70: ------------------ | Branch (2078:1): [True: 0, False: 8] ------------------ 2079| 0|YY_RULE_SETUP 2080| 0|#line 618 "libyara/lexer.l" 2081| 0|{ 2082| | 2083| 0| lex_check_space_ok("\"", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2084| 0| *yyextra->lex_buf_ptr++ = '\"'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2085| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2086| 0|} 2087| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2088| 0|case 71: ------------------ | Branch (2088:1): [True: 0, False: 8] ------------------ 2089| 0|YY_RULE_SETUP 2090| 0|#line 626 "libyara/lexer.l" 2091| 0|{ 2092| | 2093| 0| lex_check_space_ok("\\", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2094| 0| *yyextra->lex_buf_ptr++ = '\\'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2095| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2096| 0|} 2097| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2098| 0|case 72: ------------------ | Branch (2098:1): [True: 0, False: 8] ------------------ 2099| 0|YY_RULE_SETUP 2100| 0|#line 634 "libyara/lexer.l" 2101| 0|{ 2102| | 2103| 0| int result; 2104| | 2105| 0| sscanf(yytext + 2, "%x", &result); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2106| 0| lex_check_space_ok("X", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2107| 0| *yyextra->lex_buf_ptr++ = result; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2108| 0| yyextra->lex_buf_len++; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2109| 0|} 2110| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2111| 1|case 73: ------------------ | Branch (2111:1): [True: 1, False: 7] ------------------ 2112| 1|YY_RULE_SETUP 2113| 1|#line 645 "libyara/lexer.l" 2114| 1|{ yytext_to_buffer; } ------------------ | | 991| 1| { \ | | 992| 1| char *yptr = yytext; \ | | ------------------ | | | | 348| 1|#define yytext yyg->yytext_r | | ------------------ | | 993| 1| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 1| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 0, False: 1] | | | | ------------------ | | | | 985| 1| { \ | | | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 0| } | | ------------------ | | 994| 4| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 3, False: 1] | | ------------------ | | 995| 3| { \ | | 996| 3| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 3|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 3| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 3|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 3| } \ | | 999| 1| } ------------------ 2115| 1| YY_BREAK ------------------ | | 1269| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2116| 0|case 74: ------------------ | Branch (2116:1): [True: 0, False: 8] ------------------ 2117| |/* rule 74 can match eol */ 2118| 0|YY_RULE_SETUP 2119| 0|#line 648 "libyara/lexer.l" 2120| 0|{ 2121| 0| syntax_error("unterminated string"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2122| 0|} 2123| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2124| 0|case 75: ------------------ | Branch (2124:1): [True: 0, False: 8] ------------------ 2125| |/* rule 75 can match eol */ 2126| 0|YY_RULE_SETUP 2127| 0|#line 653 "libyara/lexer.l" 2128| 0|{ 2129| 0| syntax_error("illegal escape sequence"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2130| 0|} 2131| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2132| 0|case 76: ------------------ | Branch (2132:1): [True: 0, False: 8] ------------------ 2133| 0|YY_RULE_SETUP 2134| 0|#line 658 "libyara/lexer.l" 2135| 0|{ 2136| | 2137| 0| if (yyextra->lex_buf_len > 0) ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ | Branch (2137:7): [True: 0, False: 0] ------------------ 2138| 0| { 2139| 0| alloc_sized_string(s, yyextra->lex_buf_len); ------------------ | | 1002| 0| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 0| str_len + sizeof(SIZED_STRING)); \ | | 1004| 0| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 0] | | ------------------ | | 1005| 0| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 0| else \ | | 1010| 0| { \ | | 1011| 0| str->length = (uint32_t) (str_len); \ | | 1012| 0| str->flags = 0; \ | | 1013| 0| } \ ------------------ 2140| | 2141| 0| if (yytext[1] == 'i') ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (2141:9): [True: 0, False: 0] ------------------ 2142| 0| s->flags |= SIZED_STRING_FLAGS_NO_CASE; ------------------ | | 39| 0|#define SIZED_STRING_FLAGS_NO_CASE 1 ------------------ 2143| | 2144| 0| if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ if (yytext[1] == 's' || yytext[2] == 's') ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (2144:9): [True: 0, False: 0] | Branch (2144:29): [True: 0, False: 0] ------------------ 2145| 0| s->flags |= SIZED_STRING_FLAGS_DOT_ALL; ------------------ | | 43| 0|#define SIZED_STRING_FLAGS_DOT_ALL 2 ------------------ 2146| | 2147| 0| *yyextra->lex_buf_ptr = '\0'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2148| 0| strlcpy(s->c_string, yyextra->lex_buf, s->length + 1); ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2149| | 2150| 0| yylval->sized_string = s; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 2151| 0| } 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); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2155| 0| } 2156| | 2157| 0| BEGIN(INITIAL); ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(INITIAL); ------------------ | | 1039| 0|#define INITIAL 0 ------------------ 2158| 0| return _REGEXP_; ------------------ | | 145| 0|#define _REGEXP_ 277 ------------------ 2159| 0|} 2160| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2161| 0|case 77: ------------------ | Branch (2161:1): [True: 0, False: 8] ------------------ 2162| 0|YY_RULE_SETUP 2163| 0|#line 685 "libyara/lexer.l" 2164| 0|{ 2165| | 2166| 0| lex_check_space_ok("/", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2167| 0| *yyextra->lex_buf_ptr++ = '/'; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2168| 0| yyextra->lex_buf_len++ ; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2169| 0|} 2170| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2171| 0|case 78: ------------------ | Branch (2171:1): [True: 0, False: 8] ------------------ 2172| 0|YY_RULE_SETUP 2173| 0|#line 693 "libyara/lexer.l" 2174| 0|{ 2175| | 2176| 0| lex_check_space_ok("\\.", yyextra->lex_buf_len, YR_LEX_BUF_SIZE); ------------------ | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | ------------------ | | | Branch (984:9): [True: 0, False: 0] | | ------------------ | | 985| 0| { \ | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 987| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 988| 0| } ------------------ 2177| | 2178| 0| if (yytext[1] == 0) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (2178:7): [True: 0, False: 0] ------------------ 2179| 0| syntax_error("malformed regular expression"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2180| | 2181| 0| *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[0]; ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2182| 0| *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ *yyextra->lex_buf_ptr++ = yytext[1]; ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2183| 0| yyextra->lex_buf_len += 2; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2184| 0|} 2185| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2186| 0|case 79: ------------------ | Branch (2186:1): [True: 0, False: 8] ------------------ 2187| 0|YY_RULE_SETUP 2188| 0|#line 706 "libyara/lexer.l" 2189| 0|{ yytext_to_buffer; } ------------------ | | 991| 0| { \ | | 992| 0| char *yptr = yytext; \ | | ------------------ | | | | 348| 0|#define yytext yyg->yytext_r | | ------------------ | | 993| 0| lex_check_space_ok(yptr, yyextra->lex_buf_len, YR_LEX_BUF_SIZE); \ | | ------------------ | | | | 984| 0| if (strlen(data) + current_size >= max_length - 1) \ | | | | ------------------ | | | | | Branch (984:9): [True: 0, False: 0] | | | | ------------------ | | | | 985| 0| { \ | | | | 986| 0| yyerror(yyscanner, compiler, "out of space in lex_buf"); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 987| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 988| 0| } | | ------------------ | | 994| 0| while(*yptr) \ | | ------------------ | | | Branch (994:13): [True: 0, False: 0] | | ------------------ | | 995| 0| { \ | | 996| 0| *yyextra->lex_buf_ptr++ = *yptr++; \ | | ------------------ | | | | 346| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 997| 0| yyextra->lex_buf_len++; \ | | ------------------ | | | | 346| 0|#define yyextra yyg->yyextra_r | | ------------------ | | 998| 0| } \ | | 999| 0| } ------------------ 2190| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2191| 0|case 80: ------------------ | Branch (2191:1): [True: 0, False: 8] ------------------ 2192| |/* rule 80 can match eol */ 2193| 0|YY_RULE_SETUP 2194| 0|#line 709 "libyara/lexer.l" 2195| 0|{ 2196| 0| syntax_error("unterminated regular expression"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2197| 0|} 2198| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2199| 1|case 81: ------------------ | Branch (2199:1): [True: 1, False: 7] ------------------ 2200| 1|YY_RULE_SETUP 2201| 1|#line 714 "libyara/lexer.l" 2202| 1|{ 2203| | 2204| 1| yylval->sized_string = NULL; ------------------ | | 1097| 1| # define yylval yyg->yylval_r ------------------ 2205| 1| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ 2206| 1| yyextra->lex_buf_len = 0; ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ 2207| 1| BEGIN(str); ------------------ | | 357| 1|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(str); ------------------ | | 1040| 1|#define str 1 ------------------ 2208| 1|} 2209| 1| YY_BREAK ------------------ | | 1269| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2210| 0|case 82: ------------------ | Branch (2210:1): [True: 0, False: 8] ------------------ 2211| 0|YY_RULE_SETUP 2212| 0|#line 723 "libyara/lexer.l" 2213| 0|{ 2214| | 2215| 0| yylval->sized_string = NULL; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 2216| 0| yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ yyextra->lex_buf_ptr = yyextra->lex_buf; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2217| 0| yyextra->lex_buf_len = 0; ------------------ | | 346| 0|#define yyextra yyg->yyextra_r ------------------ 2218| 0| BEGIN(regexp); ------------------ | | 357| 0|#define BEGIN yyg->yy_start = 1 + 2 * ------------------ BEGIN(regexp); ------------------ | | 1041| 0|#define regexp 2 ------------------ 2219| 0|} 2220| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2221| 0|case 83: ------------------ | Branch (2221:1): [True: 0, False: 8] ------------------ 2222| |/* rule 83 can match eol */ 2223| 0|YY_RULE_SETUP 2224| 0|#line 732 "libyara/lexer.l" 2225| 0|{ 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| 0| alloc_sized_string(s, strlen(yytext)); ------------------ | | 1002| 0| SIZED_STRING* str = (SIZED_STRING*) yr_malloc( \ | | 1003| 0| str_len + sizeof(SIZED_STRING)); \ | | 1004| 0| if (str == NULL) \ | | ------------------ | | | Branch (1004:7): [True: 0, False: 0] | | ------------------ | | 1005| 0| { \ | | 1006| 0| yyerror(yyscanner, compiler, "not enough memory"); \ | | ------------------ | | | | 48| 0|#define yyerror yara_yyerror | | ------------------ | | 1007| 0| yyterminate(); \ | | ------------------ | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | ------------------ | | | | | | 329| 0|#define YY_NULL 0 | | | | ------------------ | | ------------------ | | 1008| 0| } \ | | 1009| 0| else \ | | 1010| 0| { \ | | 1011| 0| str->length = (uint32_t) (str_len); \ | | 1012| 0| str->flags = 0; \ | | 1013| 0| } \ ------------------ 2234| | 2235| 0| strlcpy(s->c_string, yytext, s->length + 1); ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2236| 0| yylval->sized_string = s; ------------------ | | 1097| 0| # define yylval yyg->yylval_r ------------------ 2237| | 2238| 0| return _HEX_STRING_; ------------------ | | 144| 0|#define _HEX_STRING_ 276 ------------------ 2239| 0|} 2240| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2241| 1|case 84: ------------------ | Branch (2241:1): [True: 1, False: 7] ------------------ 2242| |/* rule 84 can match eol */ 2243| 1|YY_RULE_SETUP 2244| 1|#line 749 "libyara/lexer.l" 2245| |/* skip whitespace */ 2246| 1| YY_BREAK ------------------ | | 1269| 1|#define YY_BREAK /*LINTED*/break; ------------------ 2247| 0|case 85: ------------------ | Branch (2247:1): [True: 0, False: 8] ------------------ 2248| 0|YY_RULE_SETUP 2249| 0|#line 751 "libyara/lexer.l" 2250| 0|{ 2251| | 2252| 0| if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ if (yytext[0] >= 32 && yytext[0] < 127) ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ | Branch (2252:7): [True: 0, False: 0] | Branch (2252:26): [True: 0, False: 0] ------------------ 2253| 0| { 2254| 0| return yytext[0]; ------------------ | | 348| 0|#define yytext yyg->yytext_r ------------------ 2255| 0| } 2256| 0| else 2257| 0| { 2258| 0| syntax_error("non-ascii character"); ------------------ | | 978| 0| { \ | | 979| 0| yr_compiler_set_error_extra_info(compiler, error_msg); \ | | ------------------ | | | | 320| 0| strlcpy( \ | | | | 321| 0| compiler->last_error_extra_info, \ | | | | 322| 0| info, \ | | | | 323| 0| sizeof(compiler->last_error_extra_info)); | | ------------------ | | 980| 0| error(ERROR_SYNTAX_ERROR); \ | | ------------------ | | | | 971| 0| { \ | | | | 972| 0| compiler->last_error = error_code; \ | | | | 973| 0| yyerror(yyscanner, compiler, NULL); \ | | | | ------------------ | | | | | | 48| 0|#define yyerror yara_yyerror | | | | ------------------ | | | | 974| 0| yyterminate(); \ | | | | ------------------ | | | | | | 1232| 0|#define yyterminate() return YY_NULL | | | | | | ------------------ | | | | | | | | 329| 0|#define YY_NULL 0 | | | | | | ------------------ | | | | ------------------ | | | | 975| 0| } | | ------------------ | | 981| 0| } ------------------ 2259| 0| } 2260| 0|} 2261| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2262| 0|case 86: ------------------ | Branch (2262:1): [True: 0, False: 8] ------------------ 2263| 0|YY_RULE_SETUP 2264| 0|#line 763 "libyara/lexer.l" 2265| 0|ECHO; 2266| 0| YY_BREAK ------------------ | | 1269| 0|#define YY_BREAK /*LINTED*/break; ------------------ 2267| 0|#line 2267 "libyara/lexer.c" 2268| | 2269| 2| case YY_END_OF_BUFFER: ------------------ | | 584| 2|#define YY_END_OF_BUFFER 87 ------------------ | Branch (2269:2): [True: 2, False: 6] ------------------ 2270| 2| { 2271| | /* Amount of text matched not including the EOB char. */ 2272| 2| int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; ------------------ | | 567| 2|#define yytext_ptr yytext_r ------------------ 2273| | 2274| | /* Undo the effects of YY_DO_BEFORE_ACTION. */ 2275| 2| *yy_cp = yyg->yy_hold_char; 2276| 2| YY_RESTORE_YY_MORE_OFFSET 2277| | 2278| 2| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ------------------ | | 515| 2|#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|#define YY_BUFFER_NEW 0 ------------------ | Branch (2278:8): [True: 1, False: 1] ------------------ 2279| 1| { 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| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2290| 1| YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; ------------------ | | 344| 1|#define yyin yyg->yyin_r ------------------ 2291| 1| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ------------------ | | 515| 1|#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|#define YY_BUFFER_NORMAL 1 ------------------ 2292| 1| } 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| if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2301:8): [True: 0, False: 2] ------------------ 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| else switch ( yy_get_next_buffer( yyscanner ) ) ------------------ | Branch (2338:17): [True: 2, False: 0] ------------------ 2339| 2| { 2340| 1| case EOB_ACT_END_OF_FILE: ------------------ | | 398| 1|#define EOB_ACT_END_OF_FILE 1 ------------------ | Branch (2340:4): [True: 1, False: 1] ------------------ 2341| 1| { 2342| 1| yyg->yy_did_buffer_switch_on_eof = 0; 2343| | 2344| 1| if ( yywrap( yyscanner ) ) ------------------ | | 206| 1|#define yywrap yara_yywrap | | ------------------ | | | | 561| 1|#define yara_yywrap(yyscanner) (/*CONSTCOND*/1) | | | | ------------------ | | | | | Branch (561:32): [True: 1, Folded] | | | | ------------------ | | ------------------ ------------------ 2345| 1| { 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| yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1|#define yytext_ptr yytext_r ------------------ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1|#define YY_MORE_ADJ 0 ------------------ 2356| | 2357| 1| yy_act = YY_STATE_EOF(YY_START); ------------------ | | 365| 1|#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) | | ------------------ | | | | 584| 1|#define YY_END_OF_BUFFER 87 | | ------------------ ------------------ 2358| 1| goto do_action; 2359| 1| } 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| } 2368| | 2369| 0| case EOB_ACT_CONTINUE_SCAN: ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ | Branch (2369:4): [True: 0, False: 2] ------------------ 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| case EOB_ACT_LAST_MATCH: ------------------ | | 399| 1|#define EOB_ACT_LAST_MATCH 2 ------------------ | Branch (2379:4): [True: 1, False: 1] ------------------ 2380| 1| yyg->yy_c_buf_p = 2381| 1| &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2382| | 2383| 1| yy_current_state = yy_get_previous_state( yyscanner ); 2384| | 2385| 1| yy_cp = yyg->yy_c_buf_p; 2386| 1| yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 567| 1|#define yytext_ptr yytext_r ------------------ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; ------------------ | | 895| 1|#define YY_MORE_ADJ 0 ------------------ 2387| 1| goto yy_find_action; 2388| 2| } 2389| 0| break; 2390| 2| } 2391| | 2392| 0| default: ------------------ | Branch (2392:2): [True: 0, False: 8] ------------------ 2393| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2394| 8| "fatal flex scanner internal error--no action found" ); 2395| 8| } /* end of action switch */ 2396| 8| } /* end of scanning one token */ 2397| 3| } /* end of user's declarations */ 2398| 3|} /* end of yylex */ yara_yy_switch_to_buffer: 2714| 1|{ 2715| 1| 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| yyensure_buffer_stack (yyscanner); ------------------ | | 86| 1|#define yyensure_buffer_stack yara_yyensure_buffer_stack ------------------ 2723| 1| if ( YY_CURRENT_BUFFER == new_buffer ) ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (2723:7): [True: 0, False: 1] ------------------ 2724| 0| return; 2725| | 2726| 1| if ( YY_CURRENT_BUFFER ) ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1] | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : 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| YY_CURRENT_BUFFER_LVALUE = new_buffer; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2735| 1| yy_load_buffer_state( yyscanner ); ------------------ | | 62| 1|#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| yyg->yy_did_buffer_switch_on_eof = 1; 2743| 1|} yara_yy_delete_buffer: 2789| 1|{ 2790| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2791| | 2792| 1| if ( ! b ) ------------------ | Branch (2792:7): [True: 0, False: 1] ------------------ 2793| 0| return; 2794| | 2795| 1| if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (2795:7): [True: 1, False: 0] ------------------ 2796| 1| YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2797| | 2798| 1| if ( b->yy_is_our_buffer ) ------------------ | Branch (2798:7): [True: 1, False: 0] ------------------ 2799| 1| yyfree( (void *) b->yy_ch_buf , yyscanner ); ------------------ | | 236| 1|#define yyfree yara_yyfree ------------------ 2800| | 2801| 1| yyfree( (void *) b , yyscanner ); ------------------ | | 236| 1|#define yyfree yara_yyfree ------------------ 2802| 1|} yara_yypop_buffer_state: 2899| 1|{ 2900| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2901| 1| if (!YY_CURRENT_BUFFER) ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (2901:6): [True: 0, False: 1] ------------------ 2902| 0| return; 2903| | 2904| 1| yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 26| 1|#define yy_delete_buffer yara_yy_delete_buffer ------------------ yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ 2905| 1| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2906| 1| if (yyg->yy_buffer_stack_top > 0) ------------------ | Branch (2906:6): [True: 0, False: 1] ------------------ 2907| 0| --yyg->yy_buffer_stack_top; 2908| | 2909| 1| if (YY_CURRENT_BUFFER) { ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1] | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : 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|} yara_yy_scan_buffer: 2969| 1|{ 2970| 1| YY_BUFFER_STATE b; 2971| | 2972| 1| if ( size < 2 || ------------------ | Branch (2972:7): [True: 0, False: 1] ------------------ 2973| 1| base[size-2] != YY_END_OF_BUFFER_CHAR || ------------------ | | 368| 2|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2973:7): [True: 0, False: 1] ------------------ 2974| 1| base[size-1] != YY_END_OF_BUFFER_CHAR ) ------------------ | | 368| 1|#define YY_END_OF_BUFFER_CHAR 0 ------------------ | Branch (2974:7): [True: 0, False: 1] ------------------ 2975| | /* They forgot to leave room for the EOB's. */ 2976| 0| return NULL; 2977| | 2978| 1| b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); ------------------ | | 224| 1|#define yyalloc yara_yyalloc ------------------ 2979| 1| if ( ! b ) ------------------ | Branch (2979:7): [True: 0, False: 1] ------------------ 2980| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2981| | 2982| 1| b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ 2983| 1| b->yy_buf_pos = b->yy_ch_buf = base; 2984| 1| b->yy_is_our_buffer = 0; 2985| 1| b->yy_input_file = NULL; 2986| 1| b->yy_n_chars = b->yy_buf_size; 2987| 1| b->yy_is_interactive = 0; 2988| 1| b->yy_at_bol = 1; 2989| 1| b->yy_fill_buffer = 0; 2990| 1| b->yy_buffer_status = YY_BUFFER_NEW; ------------------ | | 486| 1|#define YY_BUFFER_NEW 0 ------------------ 2991| | 2992| 1| yy_switch_to_buffer( b , yyscanner ); ------------------ | | 68| 1|#define yy_switch_to_buffer yara_yy_switch_to_buffer ------------------ 2993| | 2994| 1| return b; 2995| 1|} yara_yy_scan_string: 3006| 1|{ 3007| | 3008| 1| return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); ------------------ | | 44| 1|#define yy_scan_bytes yara_yy_scan_bytes ------------------ 3009| 1|} yara_yy_scan_bytes: 3019| 1|{ 3020| 1| YY_BUFFER_STATE b; 3021| 1| char *buf; 3022| 1| yy_size_t n; 3023| 1| int i; 3024| | 3025| | /* Get memory for full buffer, including space for trailing EOB's. */ 3026| 1| n = (yy_size_t) (_yybytes_len + 2); 3027| 1| buf = (char *) yyalloc( n , yyscanner ); ------------------ | | 224| 1|#define yyalloc yara_yyalloc ------------------ 3028| 1| if ( ! buf ) ------------------ | Branch (3028:7): [True: 0, False: 1] ------------------ 3029| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3030| | 3031| 13| for ( i = 0; i < _yybytes_len; ++i ) ------------------ | Branch (3031:15): [True: 12, False: 1] ------------------ 3032| 12| buf[i] = yybytes[i]; 3033| | 3034| 1| buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 1|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 3035| | 3036| 1| b = yy_scan_buffer( buf, n , yyscanner); ------------------ | | 32| 1|#define yy_scan_buffer yara_yy_scan_buffer ------------------ 3037| 1| if ( ! b ) ------------------ | Branch (3037:7): [True: 0, False: 1] ------------------ 3038| 0| YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3039| | 3040| | /* It's okay to grow etc. this buffer, and we should throw it 3041| | * away when we're done. 3042| | */ 3043| 1| b->yy_is_our_buffer = 1; 3044| | 3045| 1| return b; 3046| 1|} yara_yyget_extra: 3083| 4|{ 3084| 4| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3085| 4| return yyextra; ------------------ | | 346| 4|#define yyextra yyg->yyextra_r ------------------ 3086| 4|} yara_yyset_extra: 3156| 1|{ 3157| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3158| 1| yyextra = user_defined ; ------------------ | | 346| 1|#define yyextra yyg->yyextra_r ------------------ 3159| 1|} yara_yyset_lineno: 3166| 1|{ 3167| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3168| | 3169| | /* lineno is only valid if an input buffer exists. */ 3170| 1| if (! YY_CURRENT_BUFFER ) ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ | Branch (3170:13): [True: 0, False: 1] ------------------ 3171| 0| YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 3172| | 3173| 1| yylineno = _line_number; ------------------ | | 349| 1|#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) | | ------------------ | | | | 515| 1|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ ------------------ 3174| 1|} yara_yylex_init: 3242| 1|{ 3243| 1| if (ptr_yy_globals == NULL){ ------------------ | Branch (3243:9): [True: 0, False: 1] ------------------ 3244| 0| errno = EINVAL; 3245| 0| return 1; 3246| 0| } 3247| | 3248| 1| *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); ------------------ | | 224| 1|#define yyalloc yara_yyalloc ------------------ 3249| | 3250| 1| if (*ptr_yy_globals == NULL){ ------------------ | Branch (3250:9): [True: 0, False: 1] ------------------ 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| memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); 3257| | 3258| 1| return yy_init_globals ( *ptr_yy_globals ); 3259| 1|} yara_yylex_destroy: 3330| 1|{ 3331| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3332| | 3333| | /* Pop the buffer stack, destroying each element. */ 3334| 1| while(YY_CURRENT_BUFFER){ ------------------ | | 509| 1|#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ | | ------------------ | | | Branch (509:27): [True: 0, False: 1] | | | Branch (509:29): [True: 1, False: 0] | | ------------------ | | 510| 1| ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ | | 511| 1| : NULL) ------------------ 3335| 0| yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); ------------------ | | 26| 0|#define yy_delete_buffer yara_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) ------------------ 3336| 0| YY_CURRENT_BUFFER_LVALUE = NULL; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 3337| 0| yypop_buffer_state(yyscanner); ------------------ | | 80| 0|#define yypop_buffer_state yara_yypop_buffer_state ------------------ 3338| 0| } 3339| | 3340| | /* Destroy the stack itself. */ 3341| 1| yyfree(yyg->yy_buffer_stack , yyscanner); ------------------ | | 236| 1|#define yyfree yara_yyfree ------------------ 3342| 1| yyg->yy_buffer_stack = NULL; 3343| | 3344| | /* Destroy the start condition stack. */ 3345| 1| yyfree( yyg->yy_start_stack , yyscanner ); ------------------ | | 236| 1|#define yyfree yara_yyfree ------------------ 3346| 1| 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| yy_init_globals( yyscanner); 3351| | 3352| | /* Destroy the main struct (reentrant only). */ 3353| 1| yyfree ( yyscanner , yyscanner ); ------------------ | | 236| 1|#define yyfree yara_yyfree ------------------ 3354| | yyscanner = NULL; 3355| 1| return 0; 3356| 1|} yara_yyalloc: 3386| 4|{ 3387| 4| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3388| 4| (void)yyg; 3389| 4| return malloc(size); 3390| 4|} yara_yyfree: 3408| 5|{ 3409| 5| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 3410| 5| (void)yyg; 3411| 5| free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3412| 5|} yr_lex_parse_rules_string: 3582| 1|{ 3583| 1| yyscan_t yyscanner; 3584| | 3585| 1| compiler->errors = 0; 3586| | 3587| 1| if (rules_string == NULL) ------------------ | Branch (3587:7): [True: 0, False: 1] ------------------ 3588| 0| return 0; 3589| | 3590| 1| if (yylex_init(&yyscanner) != 0) ------------------ | | 104| 1|#define yylex_init yara_yylex_init ------------------ | Branch (3590:7): [True: 0, False: 1] ------------------ 3591| 0| { 3592| 0| compiler->errors = 1; 3593| 0| compiler->last_error = ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 3594| 0| return compiler->errors; 3595| 0| } 3596| | 3597| 1| if (setjmp(compiler->error_recovery) != 0) ------------------ | Branch (3597:7): [True: 0, False: 1] ------------------ 3598| 0| return compiler->errors; 3599| | 3600| | #if YYDEBUG 3601| | yydebug = 1; 3602| | #endif 3603| | 3604| 1| yyset_extra(compiler, yyscanner); ------------------ | | 140| 1|#define yyset_extra yara_yyset_extra ------------------ 3605| 1| yy_scan_string(rules_string, yyscanner); ------------------ | | 38| 1|#define yy_scan_string yara_yy_scan_string ------------------ 3606| 1| yyset_lineno(1, yyscanner); ------------------ | | 188| 1|#define yyset_lineno yara_yyset_lineno ------------------ 3607| 1| yyparse(yyscanner, compiler); ------------------ | | 46| 1|#define yyparse yara_yyparse ------------------ 3608| 1| yylex_destroy(yyscanner); ------------------ | | 116| 1|#define yylex_destroy yara_yylex_destroy ------------------ 3609| | 3610| 1| return compiler->errors; 3611| 1|} lexer.c:yy_get_next_buffer: 2408| 2|{ 2409| 2| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2410| 2| char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2411| 2| char *source = yyg->yytext_ptr; ------------------ | | 567| 2|#define yytext_ptr yytext_r ------------------ 2412| 2| int number_to_move, i; 2413| 2| int ret_val; 2414| | 2415| 2| if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2415:7): [True: 0, False: 2] ------------------ 2416| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2417| 2| "fatal flex scanner internal error--end of buffer missed" ); 2418| | 2419| 2| if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2419:7): [True: 2, False: 0] ------------------ 2420| 2| { /* Don't try to fill the buffer, so this is an EOF. */ 2421| 2| if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 567| 2|#define yytext_ptr yytext_r ------------------ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) ------------------ | | 895| 2|#define YY_MORE_ADJ 0 ------------------ | Branch (2421:8): [True: 1, False: 1] ------------------ 2422| 1| { 2423| | /* We matched a single character, the EOB, so 2424| | * treat this as a final EOF. 2425| | */ 2426| 1| return EOB_ACT_END_OF_FILE; ------------------ | | 398| 1|#define EOB_ACT_END_OF_FILE 1 ------------------ 2427| 1| } 2428| | 2429| 1| else 2430| 1| { 2431| | /* We matched some text prior to the EOB, first 2432| | * process it. 2433| | */ 2434| 1| return EOB_ACT_LAST_MATCH; ------------------ | | 399| 1|#define EOB_ACT_LAST_MATCH 2 ------------------ 2435| 1| } 2436| 2| } 2437| | 2438| | /* Try to read more data. */ 2439| | 2440| | /* First move last chars to start of buffer. */ 2441| 0| number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ 2442| | 2443| 0| for ( i = 0; i < number_to_move; ++i ) ------------------ | Branch (2443:15): [True: 0, False: 0] ------------------ 2444| 0| *(dest++) = *(source++); 2445| | 2446| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ | Branch (2446:7): [True: 0, False: 0] ------------------ 2447| | /* don't do the read, it's not guaranteed to return an EOF, 2448| | * just force an EOF 2449| | */ 2450| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2451| | 2452| 0| else 2453| 0| { 2454| 0| int num_to_read = 2455| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2456| | 2457| 0| while ( num_to_read <= 0 ) ------------------ | Branch (2457:11): [True: 0, False: 0] ------------------ 2458| 0| { /* Not enough room in the buffer - grow it. */ 2459| | 2460| | /* just a shorter name for the current buffer */ 2461| 0| YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2462| | 2463| 0| int yy_c_buf_p_offset = 2464| 0| (int) (yyg->yy_c_buf_p - b->yy_ch_buf); 2465| | 2466| 0| if ( b->yy_is_our_buffer ) ------------------ | Branch (2466:9): [True: 0, False: 0] ------------------ 2467| 0| { 2468| 0| int new_size = b->yy_buf_size * 2; 2469| | 2470| 0| if ( new_size <= 0 ) ------------------ | Branch (2470:10): [True: 0, False: 0] ------------------ 2471| 0| b->yy_buf_size += b->yy_buf_size / 8; 2472| 0| else 2473| 0| b->yy_buf_size *= 2; 2474| | 2475| 0| b->yy_ch_buf = (char *) 2476| | /* Include room in for 2 EOB chars. */ 2477| 0| yyrealloc( (void *) b->yy_ch_buf, ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2478| 0| (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); 2479| 0| } 2480| 0| else 2481| | /* Can't grow it, we don't own it. */ 2482| 0| b->yy_ch_buf = NULL; 2483| | 2484| 0| if ( ! b->yy_ch_buf ) ------------------ | Branch (2484:9): [True: 0, False: 0] ------------------ 2485| 0| YY_FATAL_ERROR( ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2486| 0| "fatal error - scanner input buffer overflow" ); 2487| | 2488| 0| yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 2489| | 2490| 0| num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2491| 0| number_to_move - 1; 2492| | 2493| 0| } 2494| | 2495| 0| if ( num_to_read > YY_READ_BUF_SIZE ) ------------------ | | 1179| 0|#define YY_READ_BUF_SIZE 8192 ------------------ | Branch (2495:8): [True: 0, False: 0] ------------------ 2496| 0| num_to_read = YY_READ_BUF_SIZE; ------------------ | | 1179| 0|#define YY_READ_BUF_SIZE 8192 ------------------ 2497| | 2498| | /* Read in more data. */ 2499| 0| YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ------------------ | | 1196| 0| if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ | | ------------------ | | | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] | | ------------------ | | | Branch (1196:7): [True: 0, False: 0] | | ------------------ | | 1197| 0| { \ | | 1198| 0| int c = '*'; \ | | 1199| 0| int n; \ | | 1200| 0| for ( n = 0; n < max_size && \ | | ------------------ | | | Branch (1200:16): [True: 0, False: 0] | | ------------------ | | 1201| 0| (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1201:9): [True: 0, False: 0] | | | Branch (1201:38): [True: 0, False: 0] | | ------------------ | | 1202| 0| buf[n] = (char) c; \ | | 1203| 0| if ( c == '\n' ) \ | | ------------------ | | | Branch (1203:8): [True: 0, False: 0] | | ------------------ | | 1204| 0| buf[n++] = (char) c; \ | | 1205| 0| if ( c == EOF && ferror( yyin ) ) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1205:8): [True: 0, False: 0] | | | Branch (1205:20): [True: 0, False: 0] | | ------------------ | | 1206| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) | | ------------------ | | 1207| 0| result = n; \ | | 1208| 0| } \ | | 1209| 0| else \ | | 1210| 0| { \ | | 1211| 0| errno=0; \ | | 1212| 0| while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | | Branch (1212:11): [True: 0, False: 0] | | | Branch (1212:78): [True: 0, False: 0] | | ------------------ | | 1213| 0| { \ | | 1214| 0| if( errno != EINTR) \ | | ------------------ | | | Branch (1214:8): [True: 0, False: 0] | | ------------------ | | 1215| 0| { \ | | 1216| 0| YY_FATAL_ERROR( "input in flex scanner failed" ); \ | | ------------------ | | | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) | | ------------------ | | 1217| 0| break; \ | | 1218| 0| } \ | | 1219| 0| errno=0; \ | | 1220| 0| clearerr(yyin); \ | | ------------------ | | | | 344| 0|#define yyin yyg->yyin_r | | ------------------ | | 1221| 0| } \ | | 1222| 0| }\ ------------------ 2500| 0| yyg->yy_n_chars, num_to_read ); 2501| | 2502| 0| YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2503| 0| } 2504| | 2505| 0| if ( yyg->yy_n_chars == 0 ) ------------------ | Branch (2505:7): [True: 0, False: 0] ------------------ 2506| 0| { 2507| 0| if ( number_to_move == YY_MORE_ADJ ) ------------------ | | 895| 0|#define YY_MORE_ADJ 0 ------------------ | Branch (2507:8): [True: 0, False: 0] ------------------ 2508| 0| { 2509| 0| ret_val = EOB_ACT_END_OF_FILE; ------------------ | | 398| 0|#define EOB_ACT_END_OF_FILE 1 ------------------ 2510| 0| yyrestart( yyin , yyscanner); ------------------ | | 98| 0|#define yyrestart yara_yyrestart ------------------ yyrestart( yyin , yyscanner); ------------------ | | 344| 0|#define yyin yyg->yyin_r ------------------ 2511| 0| } 2512| | 2513| 0| else 2514| 0| { 2515| 0| ret_val = EOB_ACT_LAST_MATCH; ------------------ | | 399| 0|#define EOB_ACT_LAST_MATCH 2 ------------------ 2516| 0| YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2517| 0| YY_BUFFER_EOF_PENDING; ------------------ | | 498| 0|#define YY_BUFFER_EOF_PENDING 2 ------------------ 2518| 0| } 2519| 0| } 2520| | 2521| 0| else 2522| 0| ret_val = EOB_ACT_CONTINUE_SCAN; ------------------ | | 397| 0|#define EOB_ACT_CONTINUE_SCAN 0 ------------------ 2523| | 2524| 0| if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2524:6): [True: 0, False: 0] ------------------ 2525| | /* Extend the array by 50%, plus the number we really need. */ 2526| 0| int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); 2527| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2528| 0| (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2529| 0| if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ | Branch (2529:8): [True: 0, False: 0] ------------------ 2530| 0| YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2531| | /* "- 2" to take care of EOB's */ 2532| 0| YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2533| 0| } 2534| | 2535| 0| yyg->yy_n_chars += number_to_move; 2536| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2537| 0| YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; ------------------ | | 368| 0|#define YY_END_OF_BUFFER_CHAR 0 ------------------ 2538| | 2539| 0| yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 567| 0|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ------------------ | | 515| 0|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2540| | 2541| 0| return ret_val; 2542| 2|} lexer.c:yy_get_previous_state: 2547| 1|{ 2548| 1| yy_state_type yy_current_state; 2549| 1| char *yy_cp; 2550| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2551| | 2552| 1| yy_current_state = yyg->yy_start; 2553| | 2554| 2| for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) ------------------ | | 567| 1|#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|#define YY_MORE_ADJ 0 ------------------ | Branch (2554:47): [True: 1, False: 1] ------------------ 2555| 1| { 2556| 1| YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ------------------ | | 334| 1|#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) ------------------ | Branch (2556:19): [True: 1, False: 0] ------------------ 2557| 1| if ( yy_accept[yy_current_state] ) ------------------ | Branch (2557:8): [True: 0, False: 1] ------------------ 2558| 0| { 2559| 0| yyg->yy_last_accepting_state = yy_current_state; 2560| 0| yyg->yy_last_accepting_cpos = yy_cp; 2561| 0| } 2562| 1| while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ------------------ | Branch (2562:11): [True: 0, False: 1] ------------------ 2563| 0| { 2564| 0| yy_current_state = (int) yy_def[yy_current_state]; 2565| 0| if ( yy_current_state >= 295 ) ------------------ | Branch (2565:9): [True: 0, False: 0] ------------------ 2566| 0| yy_c = yy_meta[yy_c]; 2567| 0| } 2568| 1| yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; 2569| 1| } 2570| | 2571| 1| return yy_current_state; 2572| 1|} lexer.c:yara_yy_load_buffer_state: 2746| 2|{ 2747| 2| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2748| 2| yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2749| 2| yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 567| 2|#define yytext_ptr yytext_r ------------------ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2750| 2| yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 344| 2|#define yyin yyg->yyin_r ------------------ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ------------------ | | 515| 2|#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] ------------------ 2751| 2| yyg->yy_hold_char = *yyg->yy_c_buf_p; 2752| 2|} lexer.c:yara_yyensure_buffer_stack: 2919| 1|{ 2920| 1| yy_size_t num_to_alloc; 2921| 1| struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; 2922| | 2923| 1| if (!yyg->yy_buffer_stack) { ------------------ | Branch (2923:6): [True: 1, 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| num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ 2930| 1| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc ------------------ | | 224| 1|#define yyalloc yara_yyalloc ------------------ 2931| 1| (num_to_alloc * sizeof(struct yy_buffer_state*) 2932| 1| , yyscanner); 2933| 1| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2933:8): [True: 0, False: 1] ------------------ 2934| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2935| | 2936| 1| memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 2937| | 2938| 1| yyg->yy_buffer_stack_max = num_to_alloc; 2939| 1| yyg->yy_buffer_stack_top = 0; 2940| 1| return; 2941| 1| } 2942| | 2943| 0| if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ ------------------ | Branch (2943:6): [True: 0, False: 0] ------------------ 2944| | 2945| | /* Increase the buffer to prepare for a possible push. */ 2946| 0| yy_size_t grow_size = 8 /* arbitrary grow size */; 2947| | 2948| 0| num_to_alloc = yyg->yy_buffer_stack_max + grow_size; 2949| 0| yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc ------------------ | | 230| 0|#define yyrealloc yara_yyrealloc ------------------ 2950| 0| (yyg->yy_buffer_stack, 2951| 0| num_to_alloc * sizeof(struct yy_buffer_state*) 2952| 0| , yyscanner); 2953| 0| if ( ! yyg->yy_buffer_stack ) ------------------ | Branch (2953:8): [True: 0, False: 0] ------------------ 2954| 0| YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); ------------------ | | 80| 0|#define YY_FATAL_ERROR(msg) yara_yyfatal(yyscanner, msg) ------------------ 2955| | 2956| | /* zero only the new slots.*/ 2957| 0| memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); 2958| 0| yyg->yy_buffer_stack_max = num_to_alloc; 2959| 0| } 2960| 0|} lexer.c:yy_init_globals: 3296| 2|{ 3297| 2| 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| yyg->yy_buffer_stack = NULL; 3303| 2| yyg->yy_buffer_stack_top = 0; 3304| 2| yyg->yy_buffer_stack_max = 0; 3305| 2| yyg->yy_c_buf_p = NULL; 3306| 2| yyg->yy_init = 0; 3307| 2| yyg->yy_start = 0; 3308| | 3309| 2| yyg->yy_start_stack_ptr = 0; 3310| 2| yyg->yy_start_stack_depth = 0; 3311| 2| 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| yyin = NULL; ------------------ | | 344| 2|#define yyin yyg->yyin_r ------------------ 3319| 2| yyout = NULL; ------------------ | | 345| 2|#define yyout yyg->yyout_r ------------------ 3320| 2|#endif 3321| | 3322| | /* For future reference: Set errno on error, since we are called by 3323| | * yylex_init() 3324| | */ 3325| 2| return 0; 3326| 2|} yr_initialize: 242| 1|{ 243| 1| YR_DEBUG_FPRINTF(2, stderr, "+ %s() {\n", __FUNCTION__); 244| | 245| 1| uint32_t def_stack_size = DEFAULT_STACK_SIZE; ------------------ | | 81| 1|#define DEFAULT_STACK_SIZE 16384 ------------------ 246| 1| uint32_t def_max_strings_per_rule = DEFAULT_MAX_STRINGS_PER_RULE; ------------------ | | 82| 1|#define DEFAULT_MAX_STRINGS_PER_RULE 10000 ------------------ 247| 1| uint32_t def_max_match_data = DEFAULT_MAX_MATCH_DATA; ------------------ | | 83| 1|#define DEFAULT_MAX_MATCH_DATA 512 ------------------ 248| 1| uint64_t def_max_process_memory_chunk = DEFAULT_MAX_PROCESS_MEMORY_CHUNK; ------------------ | | 84| 1|#define DEFAULT_MAX_PROCESS_MEMORY_CHUNK 1073741824 ------------------ 249| | 250| 1| init_count++; 251| | 252| 1| if (init_count > 1) ------------------ | Branch (252:7): [True: 0, False: 1] ------------------ 253| 0| return ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 254| | 255| | // Initialize random number generator, as it is used for generating object 256| | // canaries. 257| 1| srand((unsigned) time(NULL)); 258| | 259| 257| for (int i = 0; i < 256; i++) ------------------ | Branch (259:19): [True: 256, False: 1] ------------------ 260| 256| { 261| 256| if (i >= 'a' && i <= 'z') ------------------ | Branch (261:9): [True: 159, False: 97] | Branch (261:21): [True: 26, False: 133] ------------------ 262| 26| yr_altercase[i] = i - 32; 263| 230| else if (i >= 'A' && i <= 'Z') ------------------ | Branch (263:14): [True: 165, False: 65] | Branch (263:26): [True: 26, False: 139] ------------------ 264| 26| yr_altercase[i] = i + 32; 265| 204| else 266| 204| yr_altercase[i] = i; 267| | 268| 256| yr_lowercase[i] = tolower(i); ------------------ | Branch (268:23): [True: 0, False: 0] | Branch (268:23): [True: 0, False: 256] | Branch (268:23): [True: 256, Folded] ------------------ 269| 256| } 270| | 271| 1| FAIL_ON_ERROR(yr_heap_alloc()); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 272| 1| FAIL_ON_ERROR(yr_thread_storage_create(&yr_yyfatal_trampoline_tls)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 273| 1| FAIL_ON_ERROR(yr_thread_storage_create(&yr_trycatch_trampoline_tls)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 274| | 275| |#if defined HAVE_LIBCRYPTO && OPENSSL_VERSION_NUMBER < 0x10100000L 276| | 277| | openssl_locks = (YR_MUTEX *) OPENSSL_malloc( 278| | CRYPTO_num_locks() * sizeof(YR_MUTEX)); 279| | 280| | for (int i = 0; i < CRYPTO_num_locks(); i++) 281| | yr_mutex_create(&openssl_locks[i]); 282| | 283| | CRYPTO_THREADID_set_callback(_thread_id); 284| | CRYPTO_set_locking_callback(_locking_function); 285| | 286| |#elif defined(HAVE_WINCRYPT_H) 287| | 288| | if (!CryptAcquireContext( 289| | &yr_cryptprov, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT)) 290| | { 291| | return ERROR_INTERNAL_FATAL_ERROR; 292| | } 293| | 294| |#elif defined(HAVE_COMMON_CRYPTO) 295| | 296| | ... 297| | 298| |#endif 299| | 300| 1| FAIL_ON_ERROR(yr_modules_initialize()); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 301| | 302| | // Initialize default configuration options 303| | 304| 1| FAIL_ON_ERROR(yr_set_configuration(YR_CONFIG_STACK_SIZE, &def_stack_size)); ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 305| | 306| 1| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 307| 1| YR_CONFIG_MAX_STRINGS_PER_RULE, &def_max_strings_per_rule)); 308| | 309| 1| FAIL_ON_ERROR(yr_set_configuration( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 310| 1| YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK, &def_max_process_memory_chunk)); 311| | 312| 1| FAIL_ON_ERROR( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 313| 1| yr_set_configuration(YR_CONFIG_MAX_MATCH_DATA, &def_max_match_data)); 314| | 315| 1| YR_DEBUG_FPRINTF(2, stderr, "} // %s()\n", __FUNCTION__); 316| | 317| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 318| 1|} yr_set_configuration: 396| 4|{ 397| 4| if (src == NULL) ------------------ | Branch (397:7): [True: 0, False: 4] ------------------ 398| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 399| | 400| 4| switch (name) 401| 4| { // lump all the cases using same types together in one cascade 402| 1| case YR_CONFIG_STACK_SIZE: ------------------ | Branch (402:3): [True: 1, False: 3] ------------------ 403| 2| case YR_CONFIG_MAX_STRINGS_PER_RULE: ------------------ | Branch (403:3): [True: 1, False: 3] ------------------ 404| 3| case YR_CONFIG_MAX_MATCH_DATA: ------------------ | Branch (404:3): [True: 1, False: 3] ------------------ 405| 3| yr_cfgs[name].ui32 = *(uint32_t *) src; 406| 3| break; 407| | 408| 1| case YR_CONFIG_MAX_PROCESS_MEMORY_CHUNK: ------------------ | Branch (408:3): [True: 1, False: 3] ------------------ 409| 1| yr_cfgs[name].ui64 = *(uint64_t *) src; 410| 1| break; 411| | 412| 0| default: ------------------ | Branch (412:3): [True: 0, False: 4] ------------------ 413| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 414| 4| } 415| | 416| 4| return ERROR_SUCCESS; ------------------ | | 40| 4|#define ERROR_SUCCESS 0 ------------------ 417| 4|} yr_heap_alloc: 120| 1|{ 121| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 122| 1|} yr_calloc: 130| 4|{ 131| 4| return calloc(count, size); 132| 4|} yr_malloc: 135| 308|{ 136| 308| return malloc(size); 137| 308|} yr_realloc: 140| 8|{ 141| 8| return realloc(ptr, size); 142| 8|} yr_strdup: 145| 153|{ 146| 153| return strdup(str); 147| 153|} yr_free: 155| 470|{ 156| 470| free(ptr); 157| 470|} yr_modules_initialize: 64| 1|{ 65| 11| for (YR_MODULE* module = yr_modules_table; module->initialize != NULL; ------------------ | Branch (65:46): [True: 10, False: 1] ------------------ 66| 10| module++) 67| 10| { 68| 10| int result = module->initialize(module); 69| | 70| 10| if (result != ERROR_SUCCESS) ------------------ | | 40| 10|#define ERROR_SUCCESS 0 ------------------ | Branch (70:9): [True: 0, False: 10] ------------------ 71| 0| return result; 72| 10| } 73| | 74| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 75| 1|} yr_modules_do_declarations: 93| 1|{ 94| 1| for (YR_MODULE* module = yr_modules_table; 95| 10| module->name != NULL && module->declarations != NULL; ------------------ | Branch (95:8): [True: 10, False: 0] | Branch (95:32): [True: 10, False: 0] ------------------ 96| 9| module++) 97| 10| { 98| 10| if (strcmp(module->name, module_name) == 0) ------------------ | Branch (98:9): [True: 1, False: 9] ------------------ 99| 1| return module->declarations(main_structure); 100| 10| } 101| | 102| 0| return ERROR_UNKNOWN_MODULE; ------------------ | | 81| 0|#define ERROR_UNKNOWN_MODULE 34 ------------------ 103| 1|} console__initialize: 260| 1|{ 261| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 262| 1|} dex__declarations: 193| 1|begin_declarations ------------------ | | 59| 1| { \ | | 60| 1| YR_OBJECT* stack[64]; \ | | 61| 1| int stack_top = 0; \ | | 62| 1| stack[stack_top] = module; ------------------ 194| 1| declare_string("DEX_FILE_MAGIC_035"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 195| 1| declare_string("DEX_FILE_MAGIC_036"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 196| 1| declare_string("DEX_FILE_MAGIC_037"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 197| 1| declare_string("DEX_FILE_MAGIC_038"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 198| 1| declare_string("DEX_FILE_MAGIC_039"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 199| | 200| 1| declare_integer("ENDIAN_CONSTANT"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 201| 1| declare_integer("REVERSE_ENDIAN_CONSTANT"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 202| 1| declare_integer("NO_INDEX"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 203| 1| declare_integer("ACC_PUBLIC"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 204| 1| declare_integer("ACC_PRIVATE"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 205| 1| declare_integer("ACC_PROTECTED"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 206| 1| declare_integer("ACC_STATIC"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 207| 1| declare_integer("ACC_FINAL"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 208| 1| declare_integer("ACC_SYNCHRONIZED"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 209| 1| declare_integer("ACC_VOLATILE"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 210| 1| declare_integer("ACC_BRIDGE"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 211| 1| declare_integer("ACC_TRANSIENT"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 212| 1| declare_integer("ACC_VARARGS"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 213| 1| declare_integer("ACC_NATIVE"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 214| 1| declare_integer("ACC_INTERFACE"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 215| 1| declare_integer("ACC_ABSTRACT"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 216| 1| declare_integer("ACC_STRICT"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 217| 1| declare_integer("ACC_SYNTHETIC"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 218| 1| declare_integer("ACC_ANNOTATION"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 219| 1| declare_integer("ACC_ENUM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 220| 1| declare_integer("ACC_CONSTRUCTOR"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 221| 1| declare_integer("ACC_DECLARED_SYNCHRONIZED"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 222| | 223| 1| declare_integer("TYPE_HEADER_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 224| 1| declare_integer("TYPE_STRING_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 225| 1| declare_integer("TYPE_TYPE_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 226| 1| declare_integer("TYPE_PROTO_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 227| 1| declare_integer("TYPE_FIELD_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 228| 1| declare_integer("TYPE_METHOD_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 229| 1| declare_integer("TYPE_CLASS_DEF_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 230| 1| declare_integer("TYPE_CALL_SITE_ID_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 231| 1| declare_integer("TYPE_METHOD_HANDLE_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 232| 1| declare_integer("TYPE_MAP_LIST"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 233| 1| declare_integer("TYPE_TYPE_LIST"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 234| 1| declare_integer("TYPE_ANNOTATION_SET_REF_LIST"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 235| 1| declare_integer("TYPE_ANNOTATION_SET_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 236| 1| declare_integer("TYPE_CLASS_DATA_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 237| 1| declare_integer("TYPE_CODE_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 238| 1| declare_integer("TYPE_STRING_DATA_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 239| 1| declare_integer("TYPE_DEBUG_INFO_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 240| 1| declare_integer("TYPE_ANNOTATION_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 241| 1| declare_integer("TYPE_ENCODED_ARRAY_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 242| 1| declare_integer("TYPE_ANNOTATIONS_DIRECTORY_ITEM"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 243| | 244| 2| begin_struct("header") ------------------ | | 69| 1| { \ | | 70| 1| YR_OBJECT* structure; \ | | 71| 1| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 72| 1| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 1| "too many nested structures"); \ | | 76| 1| stack[++stack_top] = structure; \ | | 77| 1| } ------------------ 245| 1| declare_string("magic"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 246| 1| declare_integer("checksum"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 247| 1| declare_string("signature"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 248| 1| declare_integer("file_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 249| 1| declare_integer("header_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 250| 1| declare_integer("endian_tag"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 251| 1| declare_integer("link_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 252| 1| declare_integer("link_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 253| 1| declare_integer("map_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 254| 1| declare_integer("string_ids_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 255| 1| declare_integer("string_ids_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 256| 1| declare_integer("type_ids_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 257| 1| declare_integer("type_ids_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 258| 1| declare_integer("proto_ids_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 259| 1| declare_integer("proto_ids_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 260| 1| declare_integer("field_ids_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 261| 1| declare_integer("field_ids_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 262| 1| declare_integer("method_ids_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 263| 1| declare_integer("method_ids_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 264| 1| declare_integer("class_defs_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 265| 1| declare_integer("class_defs_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 266| 1| declare_integer("data_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 267| 1| declare_integer("data_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 268| 2| end_struct("header") ------------------ | | 108| 1| { \ | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | 113| 1| stack_top--; \ | | 114| 1| } ------------------ | Branch (268:3): [True: 0, False: 1] | Branch (268:3): [True: 1, False: 0] ------------------ 269| | 270| 3| begin_struct_array("string_ids") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 271| 1| declare_integer("offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 272| 1| declare_integer("size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 273| 1| declare_string("value"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 274| 2| end_struct_array("string_ids") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (274:3): [True: 0, False: 1] | Branch (274:3): [True: 1, False: 0] ------------------ 275| | 276| 3| begin_struct_array("type_ids") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 277| 1| declare_integer("descriptor_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 278| 2| end_struct_array("type_ids") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (278:3): [True: 0, False: 1] | Branch (278:3): [True: 1, False: 0] ------------------ 279| | 280| 3| begin_struct_array("proto_ids") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 281| 1| declare_integer("shorty_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 282| 1| declare_integer("return_type_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 283| 1| declare_integer("parameters_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 284| 2| end_struct_array("proto_ids") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (284:3): [True: 0, False: 1] | Branch (284:3): [True: 1, False: 0] ------------------ 285| | 286| 3| begin_struct_array("field_ids") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 287| 1| declare_integer("class_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 288| 1| declare_integer("type_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 289| 1| declare_integer("name_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 290| 2| end_struct_array("field_ids") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (290:3): [True: 0, False: 1] | Branch (290:3): [True: 1, False: 0] ------------------ 291| | 292| 3| begin_struct_array("method_ids") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 293| 1| declare_integer("class_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 294| 1| declare_integer("proto_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 295| 1| declare_integer("name_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 296| 2| end_struct_array("method_ids") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (296:3): [True: 0, False: 1] | Branch (296:3): [True: 1, False: 0] ------------------ 297| | 298| 3| begin_struct_array("class_defs") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 299| 1| declare_integer("class_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 300| 1| declare_integer("access_flags"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 301| 1| declare_integer("super_class_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 302| 1| declare_integer("interfaces_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 303| 1| declare_integer("source_file_idx"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 304| 1| declare_integer("annotations_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 305| 1| declare_integer("class_data_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 306| 1| declare_integer("static_values_offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 307| 2| end_struct_array("class_defs") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (307:3): [True: 0, False: 1] | Branch (307:3): [True: 1, False: 0] ------------------ 308| | 309| 3| begin_struct_array("class_data_item") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 310| 1| declare_integer("static_fields_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 311| 1| declare_integer("instance_fields_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 312| 1| declare_integer("direct_methods_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 313| 1| declare_integer("virtual_methods_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 314| 2| end_struct_array("class_data_item") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (314:3): [True: 0, False: 1] | Branch (314:3): [True: 1, False: 0] ------------------ 315| | 316| 2| begin_struct("map_list") ------------------ | | 69| 1| { \ | | 70| 1| YR_OBJECT* structure; \ | | 71| 1| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 72| 1| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 1| "too many nested structures"); \ | | 76| 1| stack[++stack_top] = structure; \ | | 77| 1| } ------------------ 317| 1| declare_integer("size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 318| 3| begin_struct_array("map_item") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 319| 1| declare_integer("type"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 320| 1| declare_integer("unused"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 321| 1| declare_integer("size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 322| 1| declare_integer("offset"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 323| 2| end_struct_array("map_item"); ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (323:5): [True: 0, False: 1] | Branch (323:5): [True: 1, False: 0] ------------------ 324| 2| end_struct("map_list") ------------------ | | 108| 1| { \ | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | 113| 1| stack_top--; \ | | 114| 1| } ------------------ | Branch (324:3): [True: 0, False: 1] | Branch (324:3): [True: 1, False: 0] ------------------ 325| | 326| 1| declare_integer("number_of_fields"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 327| 3| begin_struct_array("field") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 328| 1| declare_string("class_name"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 329| 1| declare_string("name"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 330| 1| declare_string("proto"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 331| 1| declare_integer("static"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 332| 1| declare_integer("instance"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 333| 1| declare_integer("field_idx_diff"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 334| 1| declare_integer("access_flags"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 335| 2| end_struct_array("field") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (335:3): [True: 0, False: 1] | Branch (335:3): [True: 1, False: 0] ------------------ 336| | 337| 1| declare_function("has_method", "s", "i", has_method_string); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 338| 1| declare_function("has_method", "ss", "i", has_method_and_class_string); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 339| 1| declare_function("has_method", "r", "i", has_method_regexp); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 340| 1| declare_function("has_method", "rr", "i", has_method_and_class_regexp); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 341| 1| declare_function("has_class", "s", "i", has_class_string); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 342| 1| declare_function("has_class", "r", "i", has_class_regexp); ------------------ | | 191| 1| { \ | | 192| 1| YR_OBJECT* function; \ | | 193| 1| FAIL_ON_ERROR(yr_object_function_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 194| 1| name, args_fmt, ret_fmt, func, stack[stack_top], &function)); \ | | 195| 1| } ------------------ 343| | 344| 1| declare_integer("number_of_methods"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 345| 3| begin_struct_array("method") ------------------ | | 80| 1| { \ | | 81| 1| YR_OBJECT* structure; \ | | 82| 1| YR_OBJECT* array; \ | | 83| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 84| 1| yr_object_create(OBJECT_TYPE_ARRAY, name, stack[stack_top], &array)); \ | | 85| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 86| 1| yr_object_create(OBJECT_TYPE_STRUCTURE, name, array, &structure)); \ | | 87| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 88| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 89| 1| "too many nested structures"); \ | | 90| 1| stack[++stack_top] = structure; \ | | 91| 1| } ------------------ 346| 1| declare_string("class_name"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 347| 1| declare_string("name"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 348| 1| declare_string("proto"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 349| 1| declare_integer("direct"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 350| 1| declare_integer("virtual"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 351| 1| declare_integer("method_idx_diff"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 352| 1| declare_integer("access_flags"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 353| 1| declare_integer("code_off"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 354| | 355| 2| begin_struct("code_item") ------------------ | | 69| 1| { \ | | 70| 1| YR_OBJECT* structure; \ | | 71| 1| FAIL_ON_ERROR(yr_object_create( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 72| 1| OBJECT_TYPE_STRUCTURE, name, stack[stack_top], &structure)); \ | | 73| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 74| 1| stack_top < sizeof(stack) / sizeof(stack[0]) - 1, \ | | 75| 1| "too many nested structures"); \ | | 76| 1| stack[++stack_top] = structure; \ | | 77| 1| } ------------------ 356| 1| declare_integer("registers_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 357| 1| declare_integer("ins_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 358| 1| declare_integer("outs_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 359| 1| declare_integer("tries_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 360| 1| declare_integer("debug_info_off"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 361| 1| declare_integer("insns_size"); ------------------ | | 125| 1| { \ | | 126| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 127| 1| yr_object_create(OBJECT_TYPE_INTEGER, name, stack[stack_top], NULL)); \ | | 128| 1| } ------------------ 362| 1| declare_string("insns"); ------------------ | | 169| 1| { \ | | 170| 1| FAIL_ON_ERROR( \ | | ------------------ | | | | 134| 1| { \ | | | | 135| 1| int __error = (x); \ | | | | 136| 1| if (__error != ERROR_SUCCESS) \ | | | | ------------------ | | | | | | 40| 1|#define ERROR_SUCCESS 0 | | | | ------------------ | | | | | Branch (136:9): [True: 0, False: 1] | | | | ------------------ | | | | 137| 1| return __error; \ | | | | 138| 1| } | | ------------------ | | 171| 1| yr_object_create(OBJECT_TYPE_STRING, name, stack[stack_top], NULL)); \ | | 172| 1| } ------------------ 363| 2| end_struct("code_item") ------------------ | | 108| 1| { \ | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | 110| 1| assertf( \ | | ------------------ | | | | 164| 1| if (!(expr)) \ | | | | ------------------ | | | | | Branch (164:7): [True: 0, False: 1] | | | | ------------------ | | | | 165| 1| { \ | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | 167| 0| abort(); \ | | | | 168| 0| } | | ------------------ | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | 113| 1| stack_top--; \ | | 114| 1| } ------------------ | Branch (363:5): [True: 0, False: 1] | Branch (363:5): [True: 1, False: 0] ------------------ 364| 2| end_struct_array("method") ------------------ | | 117| 1| end_struct \ | | ------------------ | | | | 108| 1| { \ | | | | 109| 1| assert(stack[stack_top]->type == OBJECT_TYPE_STRUCTURE); \ | | | | 110| 1| assertf( \ | | | | ------------------ | | | | | | 164| 1| if (!(expr)) \ | | | | | | ------------------ | | | | | | | Branch (164:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 165| 1| { \ | | | | | | 166| 0| fprintf(stderr, "%s:%d: " msg "\n", __FILE__, __LINE__, ##__VA_ARGS__); \ | | | | | | 167| 0| abort(); \ | | | | | | 168| 0| } | | | | ------------------ | | | | 111| 1| strcmp(stack[stack_top]->identifier, name) == 0, \ | | | | 112| 1| "unbalanced begin_struct/end_struct"); \ | | | | 113| 1| stack_top--; \ | | | | 114| 1| } | | ------------------ | | 118| 1| (name) ------------------ | Branch (364:3): [True: 0, False: 1] | Branch (364:3): [True: 1, False: 0] ------------------ 365| 1|end_declarations ------------------ | | 65| 1| return ERROR_SUCCESS; \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | 66| 1| } ------------------ dex__initialize: 1433| 1|{ 1434| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 1435| 1|} dotnet__initialize: 3470| 1|{ 3471| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 3472| 1|} elf__initialize: 998| 1|{ 999| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 1000| 1|} macho__initialize: 1363| 1|{ 1364| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 1365| 1|} math__initialize: 816| 1|{ 817| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 818| 1|} pe__initialize: 3990| 1|{ 3991| |#if defined(HAVE_LIBCRYPTO) && !defined(BORINGSSL) 3992| | // Initialize OpenSSL global objects for the auth library before any 3993| | // multithreaded environment as it is not thread-safe. This can 3994| | // only be called once per process. 3995| | static bool s_initialized = false; 3996| | 3997| | if (!s_initialized) 3998| | { 3999| | s_initialized = true; 4000| | initialize_authenticode_parser(); 4001| | } 4002| |#endif 4003| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 4004| 1|} string__initialize: 103| 1|{ 104| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 105| 1|} tests__initialize: 158| 1|{ 159| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 160| 1|} time__initialize: 51| 1|{ 52| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 53| 1|} yr_object_create: 56| 152|{ 57| 152| YR_OBJECT* obj; 58| 152| size_t object_size = 0; 59| | 60| 152| assert(parent != NULL || object != NULL); ------------------ | Branch (60:3): [True: 152, False: 0] | Branch (60:3): [True: 0, False: 0] | Branch (60:3): [True: 151, False: 1] | Branch (60:3): [True: 1, False: 0] ------------------ 61| 152| assert(identifier != NULL); ------------------ | Branch (61:3): [True: 0, False: 152] | Branch (61:3): [True: 152, False: 0] ------------------ 62| | 63| 152| switch (type) 64| 152| { 65| 14| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 14|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (65:3): [True: 14, False: 138] ------------------ 66| 14| object_size = sizeof(YR_OBJECT_STRUCTURE); 67| 14| break; 68| 10| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 10|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (68:3): [True: 10, False: 142] ------------------ 69| 10| object_size = sizeof(YR_OBJECT_ARRAY); 70| 10| break; 71| 0| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (71:3): [True: 0, False: 152] ------------------ 72| 0| object_size = sizeof(YR_OBJECT_DICTIONARY); 73| 0| break; 74| 111| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 111|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (74:3): [True: 111, False: 41] ------------------ 75| 111| object_size = sizeof(YR_OBJECT); 76| 111| break; 77| 0| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (77:3): [True: 0, False: 152] ------------------ 78| 0| object_size = sizeof(YR_OBJECT); 79| 0| break; 80| 15| case OBJECT_TYPE_STRING: ------------------ | | 59| 15|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (80:3): [True: 15, False: 137] ------------------ 81| 15| object_size = sizeof(YR_OBJECT); 82| 15| break; 83| 2| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (83:3): [True: 2, False: 150] ------------------ 84| 2| object_size = sizeof(YR_OBJECT_FUNCTION); 85| 2| break; 86| 0| default: ------------------ | Branch (86:3): [True: 0, False: 152] ------------------ 87| 0| assert(false); ------------------ | Branch (87:5): [Folded, False: 0] | Branch (87:5): [Folded, False: 0] ------------------ 88| 152| } 89| | 90| 152| obj = (YR_OBJECT*) yr_malloc(object_size); 91| | 92| 152| if (obj == NULL) ------------------ | Branch (92:7): [True: 0, False: 152] ------------------ 93| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 94| | 95| 152| obj->type = type; 96| 152| obj->identifier = yr_strdup(identifier); 97| 152| obj->parent = parent; 98| 152| obj->data = NULL; 99| | 100| 152| switch (type) ------------------ | Branch (100:11): [True: 152, False: 0] ------------------ 101| 152| { 102| 111| case OBJECT_TYPE_INTEGER: ------------------ | | 58| 111|#define OBJECT_TYPE_INTEGER 1 ------------------ | Branch (102:3): [True: 111, False: 41] ------------------ 103| 111| obj->value.i = YR_UNDEFINED; ------------------ | | 38| 111|#define YR_UNDEFINED 0xFFFABADAFABADAFFLL ------------------ 104| 111| break; 105| 0| case OBJECT_TYPE_FLOAT: ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ | Branch (105:3): [True: 0, False: 152] ------------------ 106| 0| obj->value.d = NAN; 107| 0| break; 108| 15| case OBJECT_TYPE_STRING: ------------------ | | 59| 15|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (108:3): [True: 15, False: 137] ------------------ 109| 15| obj->value.ss = NULL; 110| 15| break; 111| 14| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 14|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (111:3): [True: 14, False: 138] ------------------ 112| 14| object_as_structure(obj)->members = NULL; ------------------ | | 909| 14|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 113| 14| break; 114| 10| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 10|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (114:3): [True: 10, False: 142] ------------------ 115| 10| object_as_array(obj)->items = NULL; ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 116| 10| object_as_array(obj)->prototype_item = NULL; ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 117| 10| break; 118| 0| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (118:3): [True: 0, False: 152] ------------------ 119| 0| object_as_dictionary(obj)->items = NULL; ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 120| 0| object_as_dictionary(obj)->prototype_item = NULL; ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 121| 0| break; 122| 2| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (122:3): [True: 2, False: 150] ------------------ 123| 2| object_as_function(obj)->return_obj = NULL; ------------------ | | 912| 2|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 124| 22| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 135| 22|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (124:21): [True: 20, False: 2] ------------------ 125| 20| { 126| 20| object_as_function(obj)->prototypes[i].arguments_fmt = NULL; ------------------ | | 912| 20|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 127| 20| object_as_function(obj)->prototypes[i].code = NULL; ------------------ | | 912| 20|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 128| 20| } 129| 2| break; 130| 152| } 131| | 132| 152| if (obj->identifier == NULL) ------------------ | Branch (132:7): [True: 0, False: 152] ------------------ 133| 0| { 134| 0| yr_free(obj); 135| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 136| 0| } 137| | 138| 152| if (parent != NULL) ------------------ | Branch (138:7): [True: 151, False: 1] ------------------ 139| 151| { 140| 151| assert( ------------------ | Branch (140:5): [True: 151, False: 0] | Branch (140:5): [True: 0, False: 0] | Branch (140:5): [True: 0, False: 0] | Branch (140:5): [True: 0, False: 0] | Branch (140:5): [True: 139, False: 12] | Branch (140:5): [True: 10, False: 2] | Branch (140:5): [True: 0, False: 2] | Branch (140:5): [True: 2, False: 0] ------------------ 141| 151| parent->type == OBJECT_TYPE_STRUCTURE || 142| 151| parent->type == OBJECT_TYPE_ARRAY || 143| 151| parent->type == OBJECT_TYPE_DICTIONARY || 144| 151| parent->type == OBJECT_TYPE_FUNCTION); 145| | 146| | // Objects with a parent take the canary from it. 147| 151| obj->canary = parent->canary; 148| | 149| 151| switch (parent->type) ------------------ | Branch (149:13): [True: 151, False: 0] ------------------ 150| 151| { 151| 139| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 139|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (151:5): [True: 139, False: 12] ------------------ 152| 139| FAIL_ON_ERROR_WITH_CLEANUP(yr_object_structure_set_member(parent, obj), { ------------------ | | 142| 139| { \ | | 143| 139| int __error = (x); \ | | 144| 139| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 139|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (144:9): [True: 0, False: 139] | | ------------------ | | 145| 139| { \ | | 146| 0| cleanup; \ | | 147| 0| return __error; \ | | 148| 0| } \ | | 149| 139| } ------------------ 153| 139| yr_free((void*) obj->identifier); 154| 139| yr_free(obj); 155| 139| }); 156| 139| break; 157| | 158| 10| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 10|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (158:5): [True: 10, False: 141] ------------------ 159| 10| object_as_array(parent)->prototype_item = obj; ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 160| 10| break; 161| | 162| 0| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (162:5): [True: 0, False: 151] ------------------ 163| 0| object_as_dictionary(parent)->prototype_item = obj; ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 164| 0| break; 165| | 166| 2| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (166:5): [True: 2, False: 149] ------------------ 167| 2| object_as_function(parent)->return_obj = obj; ------------------ | | 912| 2|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 168| 2| break; 169| 151| } 170| 151| } 171| | 172| 152| if (object != NULL) ------------------ | Branch (172:7): [True: 28, False: 124] ------------------ 173| 28| *object = obj; 174| | 175| 152| return ERROR_SUCCESS; ------------------ | | 40| 152|#define ERROR_SUCCESS 0 ------------------ 176| 152|} yr_object_function_create: 190| 6|{ 191| 6| YR_OBJECT* return_obj; 192| 6| YR_OBJECT* o = NULL; 193| 6| YR_OBJECT_FUNCTION* f = NULL; 194| | 195| 6| int8_t return_type; 196| | 197| | // The parent of a function must be a structure. 198| 6| assert(parent != NULL && parent->type == OBJECT_TYPE_STRUCTURE); ------------------ | Branch (198:3): [True: 0, False: 6] | Branch (198:3): [True: 0, False: 0] | Branch (198:3): [True: 6, False: 0] | Branch (198:3): [True: 6, False: 0] ------------------ 199| | 200| 6| switch (*return_fmt) 201| 6| { 202| 6| case 'i': ------------------ | Branch (202:3): [True: 6, False: 0] ------------------ 203| 6| return_type = OBJECT_TYPE_INTEGER; ------------------ | | 58| 6|#define OBJECT_TYPE_INTEGER 1 ------------------ 204| 6| break; 205| 0| case 's': ------------------ | Branch (205:3): [True: 0, False: 6] ------------------ 206| 0| return_type = OBJECT_TYPE_STRING; ------------------ | | 59| 0|#define OBJECT_TYPE_STRING 2 ------------------ 207| 0| break; 208| 0| case 'f': ------------------ | Branch (208:3): [True: 0, False: 6] ------------------ 209| 0| return_type = OBJECT_TYPE_FLOAT; ------------------ | | 64| 0|#define OBJECT_TYPE_FLOAT 7 ------------------ 210| 0| break; 211| 0| default: ------------------ | Branch (211:3): [True: 0, False: 6] ------------------ 212| 0| return ERROR_INVALID_FORMAT; ------------------ | | 85| 0|#define ERROR_INVALID_FORMAT 38 ------------------ 213| 6| } 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| 6| f = object_as_function(yr_object_lookup_field(parent, identifier)); ------------------ | | 912| 6|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 218| | 219| | // Overloaded functions must have the same return type. 220| 6| if (f != NULL && return_type != f->return_obj->type) ------------------ | Branch (220:7): [True: 4, False: 2] | Branch (220:20): [True: 0, False: 4] ------------------ 221| 0| return ERROR_WRONG_RETURN_TYPE; ------------------ | | 88| 0|#define ERROR_WRONG_RETURN_TYPE 41 ------------------ 222| | 223| 6| if (f == NULL) // Function doesn't exist yet ------------------ | Branch (223:7): [True: 2, False: 4] ------------------ 224| 2| { 225| 2| FAIL_ON_ERROR( ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 226| 2| yr_object_create(OBJECT_TYPE_FUNCTION, identifier, parent, &o)); 227| | 228| | // In case of failure while creating return_obj we don't need to free the 229| | // previously created "o" object, as it is already associated with its 230| | // parent and will be destroyed when the parent is destroyed. 231| 2| FAIL_ON_ERROR(yr_object_create(return_type, "result", o, &return_obj)); ------------------ | | 134| 2| { \ | | 135| 2| int __error = (x); \ | | 136| 2| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 2|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 2] | | ------------------ | | 137| 2| return __error; \ | | 138| 2| } ------------------ 232| | 233| 2| f = object_as_function(o); ------------------ | | 912| 2|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 234| 2| } 235| | 236| 13| for (int i = 0; i < YR_MAX_OVERLOADED_FUNCTIONS; i++) ------------------ | | 135| 13|#define YR_MAX_OVERLOADED_FUNCTIONS 10 ------------------ | Branch (236:19): [True: 13, False: 0] ------------------ 237| 13| { 238| 13| if (f->prototypes[i].arguments_fmt == NULL) ------------------ | Branch (238:9): [True: 6, False: 7] ------------------ 239| 6| { 240| 6| f->prototypes[i].arguments_fmt = arguments_fmt; 241| 6| f->prototypes[i].code = code; 242| | 243| 6| break; 244| 6| } 245| 13| } 246| | 247| 6| if (function != NULL) ------------------ | Branch (247:7): [True: 6, False: 0] ------------------ 248| 6| *function = (YR_OBJECT*) f; 249| | 250| 6| return ERROR_SUCCESS; ------------------ | | 40| 6|#define ERROR_SUCCESS 0 ------------------ 251| 6|} yr_object_destroy: 321| 152|{ 322| 152| YR_STRUCTURE_MEMBER* member; 323| 152| YR_STRUCTURE_MEMBER* next_member; 324| 152| YR_ARRAY_ITEMS* array_items; 325| 152| YR_DICTIONARY_ITEMS* dict_items; 326| | 327| 152| if (object == NULL) ------------------ | Branch (327:7): [True: 0, False: 152] ------------------ 328| 0| return; 329| | 330| 152| switch (object->type) ------------------ | Branch (330:11): [True: 41, False: 111] ------------------ 331| 152| { 332| 14| case OBJECT_TYPE_STRUCTURE: ------------------ | | 60| 14|#define OBJECT_TYPE_STRUCTURE 3 ------------------ | Branch (332:3): [True: 14, False: 138] ------------------ 333| 14| member = object_as_structure(object)->members; ------------------ | | 909| 14|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 334| | 335| 153| while (member != NULL) ------------------ | Branch (335:12): [True: 139, False: 14] ------------------ 336| 139| { 337| 139| next_member = member->next; 338| 139| yr_object_destroy(member->object); 339| 139| yr_free(member); 340| 139| member = next_member; 341| 139| } 342| 14| break; 343| | 344| 15| case OBJECT_TYPE_STRING: ------------------ | | 59| 15|#define OBJECT_TYPE_STRING 2 ------------------ | Branch (344:3): [True: 15, False: 137] ------------------ 345| 15| if (object->value.ss != NULL) ------------------ | Branch (345:9): [True: 0, False: 15] ------------------ 346| 0| yr_free(object->value.ss); 347| 15| break; 348| | 349| 10| case OBJECT_TYPE_ARRAY: ------------------ | | 61| 10|#define OBJECT_TYPE_ARRAY 4 ------------------ | Branch (349:3): [True: 10, False: 142] ------------------ 350| 10| if (object_as_array(object)->prototype_item != NULL) ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ | Branch (350:9): [True: 10, False: 0] ------------------ 351| 10| yr_object_destroy(object_as_array(object)->prototype_item); ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 352| | 353| 10| array_items = object_as_array(object)->items; ------------------ | | 910| 10|#define object_as_array(obj) ((YR_OBJECT_ARRAY*) (obj)) ------------------ 354| | 355| 10| if (array_items != NULL) ------------------ | Branch (355:9): [True: 0, False: 10] ------------------ 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| 10| yr_free(array_items); 363| 10| break; 364| | 365| 0| case OBJECT_TYPE_DICTIONARY: ------------------ | | 63| 0|#define OBJECT_TYPE_DICTIONARY 6 ------------------ | Branch (365:3): [True: 0, False: 152] ------------------ 366| 0| if (object_as_dictionary(object)->prototype_item != NULL) ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ | Branch (366:9): [True: 0, False: 0] ------------------ 367| 0| yr_object_destroy(object_as_dictionary(object)->prototype_item); ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 368| | 369| 0| dict_items = object_as_dictionary(object)->items; ------------------ | | 911| 0|#define object_as_dictionary(obj) ((YR_OBJECT_DICTIONARY*) (obj)) ------------------ 370| | 371| 0| if (dict_items != NULL) ------------------ | Branch (371:9): [True: 0, False: 0] ------------------ 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| 0| yr_free(dict_items); 384| 0| break; 385| | 386| 2| case OBJECT_TYPE_FUNCTION: ------------------ | | 62| 2|#define OBJECT_TYPE_FUNCTION 5 ------------------ | Branch (386:3): [True: 2, False: 150] ------------------ 387| 2| yr_object_destroy(object_as_function(object)->return_obj); ------------------ | | 912| 2|#define object_as_function(obj) ((YR_OBJECT_FUNCTION*) (obj)) ------------------ 388| 2| break; 389| 152| } 390| | 391| 152| yr_free((void*) object->identifier); 392| 152| yr_free(object); 393| 152|} yr_object_lookup_field: 396| 145|{ 397| 145| YR_STRUCTURE_MEMBER* member; 398| | 399| 145| assert(object != NULL); ------------------ | Branch (399:3): [True: 0, False: 145] | Branch (399:3): [True: 145, False: 0] ------------------ 400| 145| assert(object->type == OBJECT_TYPE_STRUCTURE); ------------------ | Branch (400:3): [True: 0, False: 145] | Branch (400:3): [True: 145, False: 0] ------------------ 401| | 402| 145| member = object_as_structure(object)->members; ------------------ | | 909| 145|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 403| | 404| 2.53k| while (member != NULL) ------------------ | Branch (404:10): [True: 2.39k, False: 141] ------------------ 405| 2.39k| { 406| 2.39k| if (strcmp(member->object->identifier, field_name) == 0) ------------------ | Branch (406:9): [True: 4, False: 2.39k] ------------------ 407| 4| return member->object; 408| | 409| 2.39k| member = member->next; 410| 2.39k| } 411| | 412| 141| return NULL; 413| 145|} yr_object_structure_set_member: 634| 139|{ 635| 139| YR_STRUCTURE_MEMBER* sm; 636| | 637| 139| assert(object->type == OBJECT_TYPE_STRUCTURE); ------------------ | Branch (637:3): [True: 0, False: 139] | Branch (637:3): [True: 139, False: 0] ------------------ 638| | 639| | // Check if the object already have a member with the same identifier 640| | 641| 139| if (yr_object_lookup_field(object, member->identifier) != NULL) ------------------ | Branch (641:7): [True: 0, False: 139] ------------------ 642| 0| return ERROR_DUPLICATED_STRUCTURE_MEMBER; ------------------ | | 89| 0|#define ERROR_DUPLICATED_STRUCTURE_MEMBER 42 ------------------ 643| | 644| 139| sm = (YR_STRUCTURE_MEMBER*) yr_malloc(sizeof(YR_STRUCTURE_MEMBER)); 645| | 646| 139| if (sm == NULL) ------------------ | Branch (646:7): [True: 0, False: 139] ------------------ 647| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 648| | 649| 139| member->parent = object; 650| 139| sm->object = member; 651| 139| sm->next = object_as_structure(object)->members; ------------------ | | 909| 139|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 652| | 653| 139| object_as_structure(object)->members = sm; ------------------ | | 909| 139|#define object_as_structure(obj) ((YR_OBJECT_STRUCTURE*) (obj)) ------------------ 654| | 655| 139| return ERROR_SUCCESS; ------------------ | | 40| 139|#define ERROR_SUCCESS 0 ------------------ 656| 139|} yr_parser_emit_with_arg_reloc: 147| 1|{ 148| 1| YR_ARENA_REF ref = YR_ARENA_NULL_REF; ------------------ | | 43| 1| (YR_ARENA_REF) \ | | 44| 1| { \ | | 45| 1| UINT32_MAX, UINT32_MAX \ | | 46| 1| } ------------------ 149| | 150| 1| DECLARE_REFERENCE(void*, ptr) arg; ------------------ | | 45| 1| union \ | | 46| 1| { \ | | 47| 1| type name; \ | | 48| 1| YR_ARENA_REF name##_; \ | | 49| 1| } YR_ALIGN(8) ------------------ 151| | 152| 1| memset(&arg, 0, sizeof(arg)); 153| 1| arg.ptr = argument; 154| | 155| 1| int result = yr_arena_write_data( 156| 1| yyget_extra(yyscanner)->arena, ------------------ | | 54| 1|#define yyget_extra yara_yyget_extra ------------------ 157| 1| YR_CODE_SECTION, ------------------ | | 63| 1|#define YR_CODE_SECTION 6 ------------------ 158| 1| &instruction, 159| 1| sizeof(uint8_t), 160| 1| instruction_ref); 161| | 162| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (162:7): [True: 1, False: 0] ------------------ 163| 1| result = yr_arena_write_data( 164| 1| yyget_extra(yyscanner)->arena, ------------------ | | 54| 1|#define yyget_extra yara_yyget_extra ------------------ 165| 1| YR_CODE_SECTION, ------------------ | | 63| 1|#define YR_CODE_SECTION 6 ------------------ 166| 1| &arg, 167| 1| sizeof(arg), 168| 1| &ref); 169| | 170| 1| if (result == ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (170:7): [True: 1, False: 0] ------------------ 171| 1| result = yr_arena_make_ptr_relocatable( 172| 1| yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 54| 1|#define yyget_extra yara_yyget_extra ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 63| 1|#define YR_CODE_SECTION 6 ------------------ yyget_extra(yyscanner)->arena, YR_CODE_SECTION, ref.offset, EOL); ------------------ | | 38| 1|#define EOL ((size_t) -1) ------------------ 173| | 174| 1| if (argument_ref != NULL) ------------------ | Branch (174:7): [True: 0, False: 1] ------------------ 175| 0| *argument_ref = ref; 176| | 177| 1| return result; 178| 1|} yr_parser_reduce_import: 1322| 1|{ 1323| 1| int result; 1324| | 1325| 1| YR_ARENA_REF ref; 1326| 1| YR_COMPILER* compiler = yyget_extra(yyscanner); ------------------ | | 54| 1|#define yyget_extra yara_yyget_extra ------------------ 1327| 1| YR_OBJECT* module_structure; 1328| | 1329| 1| if (!_yr_parser_valid_module_name(module_name)) ------------------ | Branch (1329:7): [True: 0, False: 1] ------------------ 1330| 0| { 1331| 0| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1332| | 1333| 0| return ERROR_INVALID_MODULE_NAME; ------------------ | | 97| 0|#define ERROR_INVALID_MODULE_NAME 50 ------------------ 1334| 0| } 1335| | 1336| 1| YR_NAMESPACE* ns = (YR_NAMESPACE*) yr_arena_get_ptr( 1337| 1| compiler->arena, 1338| 1| YR_NAMESPACES_TABLE, ------------------ | | 57| 1|#define YR_NAMESPACES_TABLE 0 ------------------ 1339| 1| compiler->current_namespace_idx * sizeof(struct YR_NAMESPACE)); 1340| | 1341| 1| module_structure = (YR_OBJECT*) yr_hash_table_lookup( 1342| 1| compiler->objects_table, module_name->c_string, ns->name); 1343| | 1344| | // if module already imported, do nothing 1345| | 1346| 1| if (module_structure != NULL) ------------------ | Branch (1346:7): [True: 0, False: 1] ------------------ 1347| 0| return ERROR_SUCCESS; ------------------ | | 40| 0|#define ERROR_SUCCESS 0 ------------------ 1348| | 1349| 1| FAIL_ON_ERROR(yr_object_create( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 1350| 1| OBJECT_TYPE_STRUCTURE, module_name->c_string, NULL, &module_structure)); 1351| | 1352| 1| FAIL_ON_ERROR(yr_hash_table_add( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 1353| 1| compiler->objects_table, 1354| 1| module_name->c_string, 1355| 1| ns->name, 1356| 1| module_structure)); 1357| | 1358| 1| result = yr_modules_do_declarations(module_name->c_string, module_structure); 1359| | 1360| 1| if (result == ERROR_UNKNOWN_MODULE) ------------------ | | 81| 1|#define ERROR_UNKNOWN_MODULE 34 ------------------ | Branch (1360:7): [True: 0, False: 1] ------------------ 1361| 0| yr_compiler_set_error_extra_info(compiler, module_name->c_string); ------------------ | | 320| 0| strlcpy( \ | | 321| 0| compiler->last_error_extra_info, \ | | 322| 0| info, \ | | 323| 0| sizeof(compiler->last_error_extra_info)); ------------------ 1362| | 1363| 1| if (result != ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (1363:7): [True: 0, False: 1] ------------------ 1364| 0| return result; 1365| | 1366| 1| FAIL_ON_ERROR( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 1367| 1| _yr_compiler_store_string(compiler, module_name->c_string, &ref)); 1368| | 1369| 1| FAIL_ON_ERROR(yr_parser_emit_with_arg_reloc( ------------------ | | 134| 1| { \ | | 135| 1| int __error = (x); \ | | 136| 1| if (__error != ERROR_SUCCESS) \ | | ------------------ | | | | 40| 1|#define ERROR_SUCCESS 0 | | ------------------ | | | Branch (136:9): [True: 0, False: 1] | | ------------------ | | 137| 1| return __error; \ | | 138| 1| } ------------------ 1370| 1| yyscanner, 1371| 1| OP_IMPORT, 1372| 1| yr_arena_ref_to_ptr(compiler->arena, &ref), 1373| 1| NULL, 1374| 1| NULL)); 1375| | 1376| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 1377| 1|} parser.c:_yr_parser_valid_module_name: 1311| 1|{ 1312| 1| if (module_name->length == 0) ------------------ | Branch (1312:7): [True: 0, False: 1] ------------------ 1313| 0| return false; 1314| | 1315| 1| if (strlen(module_name->c_string) != module_name->length) ------------------ | Branch (1315:7): [True: 0, False: 1] ------------------ 1316| 0| return false; 1317| | 1318| 1| return true; 1319| 1|} yr_rules_from_arena: 327| 1|{ 328| 1| YR_SUMMARY* summary = (YR_SUMMARY*) yr_arena_get_ptr( 329| 1| arena, YR_SUMMARY_SECTION, 0); ------------------ | | 68| 1|#define YR_SUMMARY_SECTION 11 ------------------ 330| | 331| 1| if (summary == NULL) ------------------ | Branch (331:7): [True: 0, False: 1] ------------------ 332| 0| return ERROR_CORRUPT_FILE; ------------------ | | 52| 0|#define ERROR_CORRUPT_FILE 7 ------------------ 333| | 334| 1| YR_RULES* new_rules = (YR_RULES*) yr_malloc(sizeof(YR_RULES)); 335| | 336| 1| if (new_rules == NULL) ------------------ | Branch (336:7): [True: 0, False: 1] ------------------ 337| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 338| | 339| 1| new_rules->no_required_strings = (YR_BITMASK*) yr_calloc( 340| 1| sizeof(YR_BITMASK), YR_BITMASK_SIZE(summary->num_rules)); ------------------ | | 57| 1|#define YR_BITMASK_SIZE(n) (((n) / (YR_BITMASK_SLOT_BITS)) + 1) | | ------------------ | | | | 56| 1|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ ------------------ 341| | 342| 1| if (new_rules->no_required_strings == NULL) ------------------ | Branch (342:7): [True: 0, False: 1] ------------------ 343| 0| { 344| 0| yr_free(new_rules); 345| 0| return ERROR_INSUFFICIENT_MEMORY; ------------------ | | 47| 0|#define ERROR_INSUFFICIENT_MEMORY 1 ------------------ 346| 0| } 347| | 348| | // Now YR_RULES relies on this arena, let's increment the arena's 349| | // reference count so that if the original owner of the arena calls 350| | // yr_arena_destroy the arena is not destroyed. 351| 1| yr_arena_acquire(arena); 352| | 353| 1| new_rules->arena = arena; 354| 1| new_rules->num_rules = summary->num_rules; 355| 1| new_rules->num_strings = summary->num_strings; 356| 1| new_rules->num_namespaces = summary->num_namespaces; 357| | 358| 1| new_rules->rules_table = yr_arena_get_ptr(arena, YR_RULES_TABLE, 0); ------------------ | | 58| 1|#define YR_RULES_TABLE 1 ------------------ 359| | 360| 1| new_rules->strings_table = yr_arena_get_ptr(arena, YR_STRINGS_TABLE, 0); ------------------ | | 60| 1|#define YR_STRINGS_TABLE 3 ------------------ 361| | 362| 1| new_rules->ext_vars_table = yr_arena_get_ptr( 363| 1| arena, YR_EXTERNAL_VARIABLES_TABLE, 0); ------------------ | | 61| 1|#define YR_EXTERNAL_VARIABLES_TABLE 4 ------------------ 364| | 365| 1| new_rules->ac_transition_table = yr_arena_get_ptr( 366| 1| arena, YR_AC_TRANSITION_TABLE, 0); ------------------ | | 65| 1|#define YR_AC_TRANSITION_TABLE 8 ------------------ 367| | 368| 1| new_rules->ac_match_table = yr_arena_get_ptr( 369| 1| arena, YR_AC_STATE_MATCHES_TABLE, 0); ------------------ | | 66| 1|#define YR_AC_STATE_MATCHES_TABLE 9 ------------------ 370| | 371| 1| new_rules->ac_match_pool = yr_arena_get_ptr( 372| 1| arena, YR_AC_STATE_MATCHES_POOL, 0); ------------------ | | 67| 1|#define YR_AC_STATE_MATCHES_POOL 10 ------------------ 373| | 374| 1| new_rules->code_start = yr_arena_get_ptr(arena, YR_CODE_SECTION, 0); ------------------ | | 63| 1|#define YR_CODE_SECTION 6 ------------------ 375| | 376| | // If a rule has no required_strings, this means that the condition might 377| | // evaluate to true without any matching strings, and we therefore have to 378| | // mark it as "to be evaluated" from the beginning. 379| 1| for (int i = 0; i < new_rules->num_rules; i++) ------------------ | Branch (379:19): [True: 0, False: 1] ------------------ 380| 0| { 381| 0| if (new_rules->rules_table[i].required_strings == 0) ------------------ | Branch (381:9): [True: 0, False: 0] ------------------ 382| 0| yr_bitmask_set(new_rules->no_required_strings, i); ------------------ | | 60| 0| do \ | | 61| 0| { \ | | 62| 0| (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | (bm)[(i) / YR_BITMASK_SLOT_BITS] |= 1UL << ((i) % YR_BITMASK_SLOT_BITS); \ | | ------------------ | | | | 56| 0|#define YR_BITMASK_SLOT_BITS (sizeof(YR_BITMASK) * 8) | | ------------------ | | 63| 0| } while (0) | | ------------------ | | | Branch (63:12): [Folded, False: 0] | | ------------------ ------------------ 383| 0| } 384| | 385| 1| *rules = new_rules; 386| | 387| 1| return ERROR_SUCCESS; ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ 388| 1|} yr_thread_storage_create: 160| 2|{ 161| 2| if (pthread_key_create(storage, NULL) != 0) ------------------ | Branch (161:7): [True: 0, False: 2] ------------------ 162| 0| return ERROR_INTERNAL_FATAL_ERROR; ------------------ | | 78| 0|#define ERROR_INTERNAL_FATAL_ERROR 31 ------------------ 163| | 164| 2| return ERROR_SUCCESS; ------------------ | | 40| 2|#define ERROR_SUCCESS 0 ------------------ 165| 2|} LLVMFuzzerInitialize: 10| 1|{ 11| 1| YR_COMPILER* compiler; 12| | 13| 1| if (yr_initialize() != ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (13:7): [True: 0, False: 1] ------------------ 14| 0| return 0; 15| | 16| 1| if (yr_compiler_create(&compiler) != ERROR_SUCCESS) ------------------ | | 40| 1|#define ERROR_SUCCESS 0 ------------------ | Branch (16:7): [True: 0, False: 1] ------------------ 17| 0| return 0; 18| | 19| 1| if (yr_compiler_add_string(compiler, "import \"dex\"", NULL) == 0) ------------------ | Branch (19:7): [True: 1, False: 0] ------------------ 20| 1| yr_compiler_get_rules(compiler, &rules); 21| | 22| 1| yr_compiler_destroy(compiler); 23| | 24| 1| return 0; 25| 1|}