Branch data     Line data    Source code

       1                 :            : #include "range_set.hpp"
       2                 :            : 
       3                 :      27606 : AstNode *rangeset_add_range(RangeSet *rs, BigInt *first, BigInt *last, AstNode *source_node) {
       4         [ +  + ]:      55070 :     for (size_t i = 0; i < rs->src_range_list.length; i += 1) {
       5                 :      27464 :         RangeWithSrc *range_with_src = &rs->src_range_list.at(i);
       6                 :      27464 :         Range *range = &range_with_src->range;
       7   [ +  -  +  + ]:      79398 :         if ((bigint_cmp(first, &range->first) != CmpLT && bigint_cmp(first, &range->last) != CmpGT) ||
         [ -  + ][ +  + ]
       8         [ -  + ]:      51934 :             (bigint_cmp(last, &range->first) != CmpLT && bigint_cmp(last, &range->last) != CmpGT))
       9                 :            :         {
      10                 :          0 :             return range_with_src->source_node;
      11                 :            :         }
      12                 :            :     }
      13                 :      27606 :     rs->src_range_list.append({{*first, *last}, source_node});
      14                 :            : 
      15                 :      27606 :     return nullptr;
      16                 :            : 
      17                 :            : }
      18                 :            : 
      19                 :        729 : static bool add_range(ZigList<Range> *list, Range *new_range, BigInt *one) {
      20         [ +  + ]:        777 :     for (size_t i = 0; i < list->length; i += 1) {
      21                 :        567 :         Range *range = &list->at(i);
      22                 :            : 
      23                 :            :         BigInt first_minus_one;
      24                 :        567 :         bigint_sub(&first_minus_one, &range->first, one);
      25                 :            : 
      26         [ +  + ]:        567 :         if (bigint_cmp(&new_range->last, &first_minus_one) == CmpEQ) {
      27                 :         24 :             range->first = new_range->first;
      28                 :        519 :             return true;
      29                 :            :         }
      30                 :            : 
      31                 :            :         BigInt last_plus_one;
      32                 :        543 :         bigint_add(&last_plus_one, &range->last, one);
      33                 :            : 
      34         [ +  + ]:        543 :         if (bigint_cmp(&new_range->first, &last_plus_one) == CmpEQ) {
      35                 :        495 :             range->last = new_range->last;
      36                 :        495 :             return true;
      37                 :            :         }
      38                 :            :     }
      39                 :        210 :     list->append({new_range->first, new_range->last});
      40                 :        210 :     return false;
      41                 :            : }
      42                 :            : 
      43                 :         89 : bool rangeset_spans(RangeSet *rs, BigInt *first, BigInt *last) {
      44                 :         89 :     ZigList<Range> cur_list_value = {0};
      45                 :         89 :     ZigList<Range> other_list_value = {0};
      46                 :         89 :     ZigList<Range> *cur_list = &cur_list_value;
      47                 :         89 :     ZigList<Range> *other_list = &other_list_value;
      48                 :            : 
      49         [ +  + ]:        697 :     for (size_t i = 0; i < rs->src_range_list.length; i += 1) {
      50                 :        608 :         RangeWithSrc *range_with_src = &rs->src_range_list.at(i);
      51                 :        608 :         Range *range = &range_with_src->range;
      52                 :        608 :         cur_list->append({range->first, range->last});
      53                 :            :     }
      54                 :            : 
      55                 :            :     BigInt one;
      56                 :         89 :     bigint_init_unsigned(&one, 1);
      57                 :            : 
      58                 :         89 :     bool changes_made = true;
      59         [ +  + ]:        275 :     while (changes_made) {
      60                 :        186 :         changes_made = false;
      61         [ +  + ]:        915 :         for (size_t cur_i = 0; cur_i < cur_list->length; cur_i += 1) {
      62                 :        729 :             Range *range = &cur_list->at(cur_i);
      63 [ +  + ][ +  + ]:        729 :             changes_made = add_range(other_list, range, &one) || changes_made;
      64                 :            :         }
      65                 :        186 :         ZigList<Range> *tmp = cur_list;
      66                 :        186 :         cur_list = other_list;
      67                 :        186 :         other_list = tmp;
      68                 :        186 :         other_list->resize(0);
      69                 :            :     }
      70                 :            : 
      71         [ -  + ]:         89 :     if (cur_list->length != 1)
      72                 :          0 :         return false;
      73                 :         89 :     Range *range = &cur_list->at(0);
      74         [ -  + ]:         89 :     if (bigint_cmp(&range->first, first) != CmpEQ)
      75                 :          0 :         return false;
      76         [ -  + ]:         89 :     if (bigint_cmp(&range->last, last) != CmpEQ)
      77                 :          0 :         return false;
      78                 :         89 :     return true;
      79                 :            : }