1  #ifndef FLASHLIGHT_BYTES
  2  #define FLASHLIGHT_BYTES
  3  #include "bytes.h"
  4  
  5  int f_bytes_new(f_bytes** out, bool atomic, size_t offset)
  6  {
  7    f_bytes* init = malloc(sizeof(f_bytes));
  8    if (init == NULL)
  9    {
 10      return -1;
 11    }
 12  
 13    init->atomic = atomic;
 14    init->offset = offset;
 15    *out = init;
 16    return 0;
 17  }
 18  
 19  void f_bytes_free(f_bytes** bytes)
 20  {
 21    free(*bytes);
 22    *bytes = NULL;
 23  }
 24  
 25  int f_bytes_node_new(f_bytes_node** out, f_bytes* bytes)
 26  {
 27    f_bytes_node* init = malloc(sizeof(*init));
 28    if (init == NULL)
 29    {
 30      return -1;
 31    }
 32  
 33    init->bytes = bytes;
 34    init->next = NULL;
 35  
 36    *out = init;
 37    return 0;
 38  }
 39  
 40  int f_bytes_node_clone(f_bytes_node**out, f_bytes_node* node)
 41  {
 42    return f_bytes_node_new(out, node->bytes);
 43  }
 44  
 45  void f_bytes_node_free(f_bytes_node** node)
 46  {
 47    f_bytes_node* tmp;
 48    f_bytes_node* head = *node;
 49    while (head != NULL)
 50    {
 51      tmp = head;
 52      head = head->next;
 53      f_bytes_free(&tmp->bytes);
 54      free(tmp);
 55    }
 56    *node = NULL;
 57  }
 58  
 59  /*
 60    { 8, false } -> { 6, true } -> { 2, false } -> { 1, true}
 61  
 62    {3, 14}
 63  */
 64  int f_node_from_reversed_bytes_node(f_node** out, f_bytes_node** bytes_head)
 65  {
 66    f_bytes_node* prev = NULL;
 67    f_bytes_node* current = *bytes_head;
 68  
 69    int last = 0;
 70    size_t offset = 0ul;
 71  
 72    while (current != NULL)
 73    {
 74      if (current->bytes->atomic == false) 
 75      {
 76        prev = current;
 77        current = current->next;
 78        continue;
 79      } 
 80      else if (prev != NULL) 
 81      {
 82        offset = prev->bytes->offset + current->bytes->offset;
 83        prev = NULL;
 84      }
 85      else
 86      {
 87        offset = current->bytes->offset;
 88      }
 89  
 90      if (last == 0)
 91      {
 92        if (f_node_new(out, offset) == -1)
 93        {
 94          return -1;
 95        };
 96        last = 1;
 97      } 
 98      else
 99      {
100        // create and prepend node
101        f_node* new_node;
102        if (f_node_new(&new_node, offset) == -1)
103        {
104          return -1;
105        }
106  
107        f_node* tmp = *out;
108        new_node->next = tmp;
109        *out = new_node;
110      }
111  
112      current = current->next;
113    }
114    // prepend 0 to the node.
115    f_node* first_node;
116    if (f_node_new(&first_node, 0ul) == -1)
117    {
118      return -1;
119    }
120    
121    f_node* atmp = *out;
122    first_node->next = atmp;
123    *out = first_node;  
124    return 0;
125  }
126  
127  int f_bytes_node_prepend(f_bytes_node** head, f_bytes_node** parent)
128  {
129    if (*head == NULL)
130    {
131      *head = *parent;
132    }
133    else
134    {
135      f_bytes_node* tmp = *head;
136  
137      (*parent)->next = tmp;
138      *head = *parent;
139    }
140    return 0;
141  }
142  
143  #endif