$export_common #library "ZMEMORY"
$export_common #include "zcommon.acs"

#define muffins 42

$export_common #include "ZMEMORY_g.acs"
$export_common #include "ZMEMORY_w.acs"

//Simple linked list implementation of malloc

//$export_common global int 63:gmemory[];
//$export_common world  int 255:wmemory[];

$export_option 
global int 63:gmemory[];
$
world int 255:wmemory[];
$

$export_common #libdefine nullptr 0

$export_common //#define nullptr 0

$export_common #define malloc_allocated 0
$export_common #define malloc_size 1
$export_common #define malloc_next_header 2
$export_common #define malloc_prev_header 3
$export_common #define malloc_num_header_properties 4

$export_common #define p_malloc_init_flag_location 0
$export_common #define p_malloc_first_header_location 1

$$export_split
//[Z] The reason I do it like this is because whoever made the acc is insane.
#define @nullptr 0

#define @malloc_allocated 0
#define @malloc_size 1
#define @malloc_next_header 2
#define @malloc_prev_header 3
#define @malloc_num_header_properties 4

#define @p_malloc_init_flag_location 0
#define @p_malloc_first_header_location 1
$$

$$export_split function int @malloc (int size) {
  //Do the setup on the first run of this function.
  if(@memory[@p_malloc_init_flag_location] == FALSE) { //Default values for global values is 0, so this is true.
    @memory[@p_malloc_init_flag_location] = TRUE;
    @memory[@p_malloc_first_header_location+@malloc_allocated] = FALSE;
    @memory[@p_malloc_first_header_location+@malloc_size] = -1; //"infinite"
    @memory[@p_malloc_first_header_location+@malloc_next_header] = @nullptr; //nullptr
    @memory[@p_malloc_first_header_location+@malloc_prev_header] = @nullptr; //nullptr
  }
  
  int p_previous_header = @nullptr;
  int p_current_header = @p_malloc_first_header_location;
  int p_retval = @nullptr;
  
  while(p_retval == @nullptr) {
    int memalloced = @memory[p_current_header+@malloc_allocated];
    int memsize = @memory[p_current_header+@malloc_size];
    if(memsize == -1) { //The end of the list.
      @memory[p_current_header+@malloc_allocated] = TRUE;
      @memory[p_current_header+@malloc_size] = size;
      @memory[p_current_header+@malloc_next_header] = p_current_header+@malloc_num_header_properties+size; //New EOL
      @memory[p_current_header+@malloc_prev_header] = p_previous_header;
      
      //Retrieve the return value while we are at the allocated space.
      p_retval = p_current_header+@malloc_num_header_properties;
      
      //Remember to initialize the new end list node.
      p_previous_header = p_current_header; //This is the header previous to the EOL.
      p_current_header = @memory[p_current_header+@malloc_next_header];
      //Set the tail node constants.
      @memory[p_current_header+@malloc_allocated] = FALSE;
      @memory[p_current_header+@malloc_size] = -1;
      @memory[p_current_header+@malloc_next_header] = @nullptr;
      @memory[p_current_header+@malloc_prev_header] = p_previous_header;
    } else if(memsize >= size && memalloced == FALSE) { //There is room here AND it isn't in use,
      @memory[p_current_header+@malloc_allocated] = TRUE;
      //The size isn't modified because we are re-using an existing space.
      // It would be a good idea to check just how large this space is and act accordingly rather
      //  than using a 500 indexes large space for a 4 indexes large object.
      // Objects allocated in a doom mod probably won't be outside the 1-16 indexes range so it
      //  should still be fine for most applications.
      //The next header isn't changed either for the same reason.
      if(memsize >= (size+@malloc_num_header_properties+5)) { //Assume that 5 is the smallest useful allocation size.
        int p_split_newheader = p_current_header+@malloc_num_header_properties+size; //Just to the end of the allocation.
        @memory[p_split_newheader+@malloc_allocated] = FALSE;
        @memory[p_split_newheader+@malloc_size] = @memory[p_current_header+@malloc_size]-@malloc_num_header_properties-size;
        @memory[p_split_newheader+@malloc_next_header] = @memory[p_current_header+@malloc_next_header];
        @memory[p_split_newheader+@malloc_prev_header] = p_current_header;
        @memory[p_current_header+@malloc_next_header] = p_split_newheader; //The header whose block was split should have its next pointer set to its other half.
        @memory[p_current_header+@malloc_size] = size; //Set the size of the allocation to reflect the split.
      }
      
      //Retrieve the return value while we are at the allocated space.
      p_retval = p_current_header+@malloc_num_header_properties;
    } else {
      //The observed node isn't useful for allocating the request. Go to the next node.
      p_previous_header = p_current_header;
      p_current_header = @memory[p_current_header+@malloc_next_header];
    }
  }
  
  //log(s:"Malloc allocated ", d:size, s:" indexes at location ", d:p_retval, s:" with header location ", d:p_current_header);
  
  return p_retval;
}
$$

$$export_split function int @free (int p_ptr) {
  log(s:"Invoked free");
  
  int p_header = p_ptr - @malloc_num_header_properties;
  
  @memory[p_header+@malloc_allocated] = FALSE;
  
  int p_next = @memory[p_header+@malloc_next_header];
  int p_prev = @memory[p_header+@malloc_prev_header];
  
  //Below is the merging of free blocks.
  //It merges to the left (lower indexes) first becaue the right (larger 
  // indexes) has a special case. (the end of the list)
  
  //the previous block is unused. Merge.
  if(p_prev != @nullptr //This doesn't make sense if the previous block doesn't exist.
  && @memory[p_prev+@malloc_allocated] == FALSE) {
    log(s:"Free attempting merge of header ", d:p_header, s: " to the left with header ", d:p_prev);
    @memory[p_prev+@malloc_size] += @memory[p_header+@malloc_size] + @malloc_num_header_properties;
    @memory[p_prev+@malloc_next_header] = p_next; //The prev header needs to know the new next.
    @memory[p_next+@malloc_prev_header] = p_prev; //The next header needs to know the new prev.
    
    //Now the two blocks are the same block. requires new initializations of the
    // variables for the other check to function correctly.
    //The header is the result of the merge, and the prev is the one before it.
    p_header = p_prev;
    p_prev = @memory[p_header+@malloc_prev_header];
  }
  
  //The next block is unused. Merge.
  //Note that p_next will never be a nullptr with correct usage.
  if(@memory[p_next+@malloc_allocated] == FALSE) {
    if(@memory[p_next+@malloc_size] == -1) { //EOL
      @memory[p_header+@malloc_size] = -1;
      @memory[p_header+@malloc_next_header] = @nullptr;
    } else {
      int p_next_next = @memory[p_next+@malloc_next_header];
      @memory[p_header+@malloc_size] += @memory[p_next+@malloc_size] + @malloc_num_header_properties;
      @memory[p_header+@malloc_next_header] = p_next_next; //The header on the other side of the next header needs to know its new prev.
      @memory[p_next_next+@malloc_prev_header] = p_header; //This header needs to know its new next.
    }
  }
  
  
  return -1;
}
$$


//These are for debugging
/*
script "memory_write" (int index, int value) {
  memory[index] = value;
}

script "memory_read" (int index) {
  log(d:memory[index]);
}

script "memory_print_allocation_list" (void) {
  int p_current_header = p_malloc_first_header_location;
  
  while(p_current_header != nullptr) {
    log(s:  "Header location: ", d:p_current_header,
        s:"\n Allocated flag: ", d:memory[p_current_header+malloc_allocated],
        s:"\n Allocation size: ", d:memory[p_current_header+malloc_size],
        s:"\n Prev header pointer: ", d:memory[p_current_header+malloc_prev_header],
        s:"\n Next header pointer: ", d:memory[p_current_header+malloc_next_header],
        s:"\n"
        );
    
    p_current_header = memory[p_current_header+malloc_next_header];
  }
}
*/