/+junk/codegen

#include "utils.h"

ptr_t

malloc0 (size_t sz) {

  ptr_t retval = malloc (sz);

  if (retval != NULL) {

    memset (retval, 0, sz);

  }

  return retval;

} 

str_t

string_vacuum (str_t s) {

  str_t out_buff;

  int index, i;

  index = -1;

  i = 0;

  for (auto c = s[i]; c != '\0'; c = s[i++]) {

    if (c != ' ' && c != '\n' && c != '\t' && c != '\r') {

        index = i;

    }

  }

  s[index + 1] = '\0';

  out_buff = realloc (s, strlen (s) + 1);

  return out_buff;

}

str_t

string_concat_list_nl (str_t* list) {

  ptr_t tmp;

  str_t buff = malloc0 (strlen (*list) * sizeof (list));

  if (buff == NULL) {

    err_print ("buffer is for some reason Null, this is an error.\n");

    goto error1;

  }

  for (str_t s = *list; s != NULL; s = *++list) {

    if (sizeof (buff) <= strlen (buff) + strlen (s) + 1 ) {

      size_t next_size = strlen (buff) + strlen (s) + 1;

      fprintf (stdout, "nz: %zu\n", next_size);

      tmp = realloc (buff, next_size);

      if (tmp == NULL || errno == ENOMEM) {

        goto error2;

      }

    }

    strcat (buff, "\n");

    strcat (buff, s);

  }

  buff = string_vacuum (buff);

  return buff;

error2:

  free (tmp);

error1:

  free (buff);

  return NULL;

}

void

err_print (str_t fmt, ...) {

  va_list vlst;

  va_start (vlst, fmt);

  vfprintf (stderr, fmt, vlst);

  va_end (vlst);

}

/* ************************************************************************** */

struct ByteStream {

  byte * bytes;

  size_t length;

  long int current;

};

ByteStream *

byte_stream_new (size_t length) {

  ByteStream * retval = malloc0 (sizeof (ByteStream));

  if (retval == NULL) {

    err_print ("Something went wrong with allocating the ByteStream. Have you run out of memory?\n");

    goto error1;

  }

  retval->bytes = malloc0 (length);

  if (retval->bytes == NULL) {

    err_print ("Cound not allocate ByteStream buffer. Have you run out of memory?\n");

    goto error2;

  }

  retval->length = length;

  retval->current = 0;

  return retval;

error2:

  free (retval);

error1:

  return NULL;

}

ByteStream *

byte_stream_new_from_file (UNUSED FILE * f) {

  NOT_IMPLEMENTED;

  return NULL;

}

void

byte_stream_seek (ByteStream * bstream, long int offset, SEEK_OFFSET origin) {

  switch (origin) {

    case (SEEK_OFFSET_SET):

      assert (offset > 0 && "Offset must be positive when using SEEK_OFFSET_SET.");

      bstream->current = offset;

      return;

    case (SEEK_OFFSET_CUR): 

      assert (((long) bstream->length >= (bstream->current + offset)) &&

              ((bstream->current + offset) >= 0) &&

              "Trying to seek outside range valid range.");

        bstream->current += offset;

      return;

    case (SEEK_OFFSET_END):

      assert (offset < 0 && "Offset must be negative when using SEEK_OFFSET_END.");

      bstream->current = bstream->length - offset;

      return;

    default:

      assert (false && "How did you end up here?");

  }

}

size_t

byte_stream_read (ByteStream * bstream, OUT ptr_t ptr, size_t size, size_t count) {

  /* Based on the Minix implementation: https://stackoverflow.com/a/8590471 */

  byte * cp = ptr;

  byte * bytes = bstream->bytes;

  size_t length = bstream->length;

  int c;

  size_t node = 0;

  size_t s;

  // Set the pointer correctly.

  bytes += bstream->current;

  if (size) {

    while (node < count) {

      s = 0;

      do {

        if ((s + (node * size)) <= length) {

          c = *bytes++;

          *cp++ = c;

          // update read byte.

          bstream->current++;

        }

        s++;

      } while (s <= size);

      node++;

    }

  }

  return node;

}

size_t

byte_stream_write (ByteStream * bstream, IN ptr_t ptr, size_t size, size_t count) {

  byte * cp = ptr;

  byte * bytes = bstream->bytes;

  int c;

  size_t node = 0;

  size_t s;

  size_t length = bstream->length;

  size_t read_length = size * count; 

  size_t current = bstream->current;

  if ((read_length + current) >= length) {

    ptr_t tmp = realloc (bstream->bytes, read_length + current);

    if (tmp == NULL) {

      err_print ("Could not reallocate ByteStream buffer. Have you run out of memory?\n");

      goto error;

    }

    else bstream->bytes = tmp;

  }

  if (size) {

    while (node < count) {

      s = 0;

      do {

        if ((s + (node * size)) <= read_length) {

          c = *cp++;

          *bytes++ = c;

        }

        s++;

      } while (s <= size);

      node++;

      current += s;

    }

  }

error:

  return node;

}

size_t

byte_stream_length (ByteStream * bstream) {

  return bstream->length;

}