Stats *Stats_recreate(double sum,
                      double sumsq,
                      unsigned long n,
                      double min,
                      double max
                     )
{
  Stats *st = malloc(sizeof(Stats));
  check_mem(st);

  st->sum = sum;
  st->sumsq = sumsq;
  st->n = n;
  st->min = min;
  st->max = max;

  return st;

error:
  return NULL;
}

int test_check(char *file_name)
{
  FILE *input = NULL;
  char *block = NULL;

  block = malloc(100);
  check_mem(block);

  input = fopen(file_name, "r");
  check(input, "Failed to open %s", file_name);

  free(block);
  fclose(input);

  return 0;

error:
  if(block) free(block);
  if(input) fclose(input);
  return -1;
}

int test_sentinel(int code)
{
  char *temp = malloc(100);
  check_mem(temp);

  switch(code)
  {
    case 1:
      log_info("it worked");
      break;
    default:
      sentinel("I shouldn't run");
  }

  free(temp);
  return 0;

error:
  if(temp) free(temp);
  return -1;
}

int  Renderer_createTexture( const char *pTFile, bool pMipmaps ) {
    Texture *t = NULL;

    if( renderer && TextureArray_checkSize( &renderer->mTextures ) ) {
        t = Texture_new();
        check_mem( t );

        // texture creation from file
        check( Texture_loadFromFile( t, pTFile, pMipmaps ), "Error in texture creation.\n" );

        // storage
        int index = renderer->mTextures.cpt++;
        renderer->mTextures.data[index] = t;

        return index;
    }

error:
    Texture_destroy( t );
    return -1;
}

int Filter_add(StateEvent state, filter_cb cb, bstring load_path, tns_value_t *config)
{
    darray_t *filters = Filter_lookup_create(state);
    check(filters != NULL, "Invalid filter state: %d given for filter %s",
            state, bdata(load_path));

    Filter *filter = darray_new(filters);
    check_mem(filter);

    filter->state = state;
    filter->cb = cb;
    filter->load_path = bstrcpy(load_path);
    filter->config = config;

    darray_attach(filters, filter);
    darray_push(filters, filter);

    return 0;
error:
    return -1;
}

void List_unshift(List *list, void *value)
{
    ListNode *node = calloc(1, sizeof(ListNode));
    check_mem(node);

    node->value = value;

    if(list->first == NULL) {
        list->first = node;
        list->last = node;
    } else {
        node->next = list->first;
        list->first->prev = node;
        list->first = node;
    }

    list->count++;

error:
    return;
}

int  Renderer_createShader( const char *pVFile, const char *pFFile ) {
    Shader *s = NULL;

    if( renderer && ShaderArray_checkSize( &renderer->mShaders ) ) {
        s = Shader_new();
        check_mem( s );

        // shader creation and linking
        check( Shader_buildFromFile( s, pVFile, pFFile ), "Error in shader creation.\n" );

        // storage
        int index = renderer->mShaders.cpt++;
        renderer->mShaders.data[index] = s;

        return index;
    }

error:
    Shader_destroy( s );
    return -1;
}

CpuTimes *cpu_times_percent(bool percpu, CpuTimes *prev_times) {
  CpuTimes *current = NULL;
  CpuTimes *t;
  int i, ncpus = percpu ? cpu_count(1) : 1;
  CpuTimes *ret;
  check(prev_times, "Need a reference point. prev_times can't be NULL");
  current = cpu_times(percpu);
  check(current, "Couldn't obtain CPU times");
  ret = (CpuTimes *)calloc(ncpus, sizeof(CpuTimes));
  check_mem(ret);
  for (i = 0; i < ncpus; i++) {
    t = calculate_cpu_times_percentage(prev_times + i, current + i);
    *(ret + i) = *t;
    free(t);
  }
  free(current);
  return ret;
error:
  free(current);
  return NULL;
}

int http_receive_payload(int sockfd, char **payload, int content_length) {
    *payload = NULL;
    ssize_t recv_size = 0;
    *payload = (char *)calloc(sizeof(char), content_length + 1);
    check_mem(payload);

    recv_size = read_all(sockfd, *payload, content_length);
    debug("%s", *payload);

    if (recv_size == content_length) {
        debug("Read complete Http payload.");
    } else if (recv_size == 0) {
        log_err("End of TCP stream.");
            return ERR_EOF;
    } else {
        log_err("Error while reading TCP stream.");
         // TODO handle
        exit(-1);
    }
    return HTTP_SUCCESS;
}

// Copies a node and its children.
//
// node - The node to copy.
// ret  - A pointer to where the new copy should be returned to.
//
// Returns 0 if successful, otherwise returns -1.
int qip_ast_freturn_copy(qip_ast_node *node, qip_ast_node **ret)
{
    int rc;
    check(node != NULL, "Node required");
    check(ret != NULL, "Return pointer required");

    qip_ast_node *clone = qip_ast_freturn_create(NULL);
    check_mem(clone);

    rc = qip_ast_node_copy(node->freturn.value, &clone->freturn.value);
    check(rc == 0, "Unable to copy return value");
    if(clone->freturn.value) clone->freturn.value->parent = clone;
    
    *ret = clone;
    return 0;

error:
    qip_ast_node_free(clone);
    *ret = NULL;
    return -1;
}

int test_check(char *file_name)
{
    FILE *input = NULL;
    char *block = NULL;

    block = malloc(100);
    check_mem(block); // should work

    input = fopen(file_name, "r");
    check(input, "Failed to open %s", file_name);

    free(block);
    fclose(input);
    return 0;

error:
    printf("[goto error] at test_check\n");
    if(block) free(block);
    if(input) fclose(input);
    return -1;
}

static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key, int create, uint32_t *hash_out)
{//caller fn will include 1 or 0 for int create true or false
    uint32_t hash = map->hash(key);
    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;//finds bucket, will always find a bucket no matter how big
    check(bucket_n >= 0, "Invalid bucket found: %d", bucket_n);
    *hash_out = hash; //store it for the return so caller can use it. I forget how caller is supposed to use this

    DArray *bucket = DArray_get(map->buckets, bucket_n);

    if(!bucket && create) {//creates bucket if none found
        //new bucket, set it up
        bucket = DArray_create(sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
        check_mem(bucket);
        DArray_set(map->buckets, bucket_n, bucket);
    }

    return bucket;

error:
    return NULL;
}

Node_T create_node(Node_T father, SuffixTreeIndex_T start, SuffixTreeIndex_T end,
                   SuffixTreeIndex_T position)
{
   /*Allocate a node.*/
   Node_T node   = malloc(sizeof(struct Node_T));
   check_mem(node);

   node->left_son             = NULL;
   node->right_sibling        = NULL;
   node->left_sibling         = NULL;
   node->suffix_link          = NULL;
   node->father               = father;
   node->path_position        = position;
   node->edge_label_start     = start;
   node->edge_label_end       = end;
   return node;

error:
   if(node) free(node);
   return NULL;
}

// Appends an expression to the end of the block.
//
// block - The block to append the expression to.
// expr  - The expression to append.
//
// Returns 0 if successful, otherwise returns -1.
int qip_ast_block_add_expr(struct qip_ast_node *block, struct qip_ast_node *expr)
{
    // Validate.
    check(block != NULL, "Block is required");
    check(block->type == QIP_AST_TYPE_BLOCK, "Block node is invalid type: %d", block->type);
    check(expr != NULL, "Expression is required");
    
    // Append expression to block.
    block->block.expr_count++;
    block->block.exprs = realloc(block->block.exprs, sizeof(qip_ast_node*) * block->block.expr_count);
    check_mem(block->block.exprs);
    block->block.exprs[block->block.expr_count-1] = expr;
    
    // Assign parent reference to expression.
    expr->parent = block;
    
    return 0;

error:
    return -1;
}

void lapack_dsteqr(int nn, int ldz, dreal *alph, dreal *beta, dreal *zz)
{
  int   nwork, info;
  char  compz = 'I';
  dreal *work = NULL;
  
  nwork = (1 >= 2*nn-2) ? 1 : 2*nn-2;
  
  work = (dreal *) calloc(nwork, sizeof(dreal));
  check_mem(work, "work");
  
  dsteqr_(&compz, &nn, alph, beta, zz, &ldz, work, &info);
  
  freeup(work);
  
  return;
  
 error:
  if(work) freeup(work);
  abort();
}

static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key,
  int create, uint32_t *hash_out)
{
  uint32_t hash = map->hash(key);
  int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
  check(bucket_n >= 0, "Invalid bucket found: %d", bucket_n);
  *hash_out = hash;

  DArray *bucket = DArray_get(map->buckets, bucket_n);

  if (!bucket && create) {
    bucket = DArray_create(sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
    check_mem(bucket);
    DArray_set(map->buckets, bucket_n, bucket);
  }

  return bucket;

error:
  return NULL;
}

void lapack_dsyev(int nn, dreal *AA, dreal *ww)
{
  int   lda, lwork, info;
  char  jobz = 'V', uplo = 'U';
  dreal *work = NULL;
  
  lda = (1 > nn) ? 1 : nn;
  lwork = (1 > 3*nn-1) ? 1 : 3*nn-1;
  work = (dreal *) calloc(lwork, sizeof(dreal));
  check_mem(work, "work");
  
  dsyev_(&jobz, &uplo, &nn, AA, &lda, ww, work, &lwork, &info);
  
  freeup(work);
  
  return;
  
 error:
  if(work) freeup(work);
  abort();
}

// Adds an argument to a function.
//
// node - The function node.
// farg - The argument to add.
//
// Returns 0 if successful, otherwise returns -1.
int qip_ast_function_add_arg(qip_ast_node *node,
                             qip_ast_node *farg)
{
    check(node != NULL, "Node required");
    check(node->type == QIP_AST_TYPE_FUNCTION, "Node type must be 'function'");
    check(farg != NULL, "Argument is required");
    
    // Append argument to function.
    node->function.arg_count++;
    node->function.args = realloc(node->function.args, sizeof(qip_ast_node*) * node->function.arg_count);
    check_mem(node->function.args);
    node->function.args[node->function.arg_count-1] = farg;
    
    // Link property to function.
    farg->parent = node;
    
    return 0;

error:
    return -1;
}

// Starts a server. Once a server is started, it can accept messages over TCP
// on the bind address and port number specified by the server object.
//
// server - The server to start.
//
// Returns 0 if successful, otherwise returns -1.
int sky_server_start(sky_server *server)
{
    int rc;
    assert(server != NULL);
    check(server->state == SKY_SERVER_STATE_STOPPED, "Server already running");
    check(server->port > 0, "Port required");

    // Initialize socket info.
    server->sockaddr = calloc(1, sizeof(struct sockaddr_in));
    check_mem(server->sockaddr);
    server->sockaddr->sin_addr.s_addr = INADDR_ANY;
    server->sockaddr->sin_port = htons(server->port);
    server->sockaddr->sin_family = AF_INET;

    // Create socket.
    server->socket = socket(AF_INET, SOCK_STREAM, 0);
    check(server->socket != -1, "Unable to create a socket");
    
    // Set socket for reuse.
    int optval = 1;
    rc = setsockopt(server->socket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
    check(rc == 0, "Unable to set socket for reuse");
    
    // Bind socket.
    rc = bind(server->socket, (struct sockaddr*)server->sockaddr, sizeof(struct sockaddr_in));
    check(rc == 0, "Unable to bind socket");
    
    // Listen on socket.
    rc = listen(server->socket, SKY_LISTEN_BACKLOG);
    check(rc != -1, "Unable to listen on socket");
    
    // Update server state.
    server->state = SKY_SERVER_STATE_RUNNING;
    
    return 0;

error:
    sky_server_stop(server);
    return -1;
}

UsersInfo *get_users() {
  uint32_t nusers = 100;
  UsersInfo *ret = (UsersInfo *)calloc(1, sizeof(UsersInfo));
  Users *users = (Users *)calloc(nusers, sizeof(Users));
  Users *u = users;
  struct utmp *ut;
  check_mem(ret);
  check_mem(users);

  ret->nitems = 0;
  ret->users = users;

  while (NULL != (ut = getutent())) {
    if (ut->ut_type != USER_PROCESS)
      continue;
    u->username = strdup(ut->ut_user);
    check_mem(u->username);

    u->tty = strdup(ut->ut_line);
    check_mem(u->tty);

    u->hostname = strdup(ut->ut_host);
    check_mem(u->hostname);

    u->tstamp = ut->ut_tv.tv_sec;

    ret->nitems++;
    u++;

    if (ret->nitems ==
        nusers) { /* More users than we've allocated space for. */
      nusers *= 2;
      users = (Users *)realloc(users, sizeof(Users) * nusers);
      check_mem(users);
      ret->users = users;
      u = ret->users + ret->nitems; /* Move the cursor to the correct
                                       value in case the realloc moved
                                       the memory */
    }
  }
  endutent();
  return ret;

error:
  free_users_info(ret);
  return NULL;
}