nums.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "nums.h"

#define NUM_INC_STORE  100000

struct num_store
{
   size_t used; 
   size_t size; 
   int*   num;  
};

static int is_valid(const NUMS* nsp)
{
   if (NULL == nsp)
      return 0;
   if (0 < nsp->size && NULL == nsp->num)
      return 0;
   if (nsp->size < nsp->used)
      return 0;
   return 1;
}


NUMS* nums_read(const char* filename)
{
   assert(NULL != filename);
   assert(0    <  strlen(filename));

   /* NUMS* np = calloc(1, sizeof(*np));
    * FILE* fp = fopen(filename, "r") do this even if calloc failed ?
    */
   NUMS* nsp = NULL;
   FILE* fp  = stdin;
   int   n;
   
   if (NULL == (nsp = calloc(1, sizeof(*nsp))))
   {
      perror("calloc");
      /* problem: out of memory.
       * do what? quit or return NULL.
       */
      return NULL;
   }
   if (strcmp(filename, "-"))
   {
      if (NULL == (fp = fopen(filename, "r")))
      {
         perror(filename);

         /* and now? Have to free nsp
          * free(nsp); return NULL;
          * exchange order with allocation above
          */
         goto terminate;
      }
   }
   
   while(fread(&n, sizeof(n), 1, fp))
   {
      /* Check input: really >= 0 ? Otherwise ignore
       */
      if (n >= 0)
      {
         /* Check if enough storage is allocated
          */
         if (nsp->used >= nsp->size)
         {
            size_t new_size = nsp->size + NUM_INC_STORE; // * 2  Scales better
            
            if (NULL == (nsp->num = realloc(nsp->num, new_size * sizeof(nsp->num[0]))))
            {               
               perror("realloc");  /* Arrgghhhhhhhh out of mem again */
               goto terminate;
            }
            nsp->size = new_size;
         }
         assert(nsp->used < nsp->size);
         
         nsp->num[nsp->used] = n;
         nsp->used++;
      }
   }
   if (!feof(fp))
   {
      perror("fread");
      goto terminate;
   }
   if (strcmp(filename, "-"))
   {
      if (fclose(fp))
      {
         perror("fclose");
         goto terminate;
      }
   }
   assert(is_valid(nsp));
   
   return nsp;
   
 terminate:
   /* But what if we come from feof, then there is no close!
    */
   if (nsp->num != NULL)
      free(nsp->num);
   if (nsp != NULL)
      free(nsp);

   return NULL;
}

void nums_free(NUMS* nsp)
{
   assert(is_valid(nsp));

   if (NULL != nsp->num)
      free(nsp->num);
   
   free(nsp);
}

static int cmp_num(const void *a, const void* b)
{
   assert(NULL != a);
   assert(NULL != b);

   const int* aa = a;
   const int* bb = b;

   return *aa - *bb;
}

void nums_print(const NUMS* nsp)
{
   assert(is_valid(nsp));

   int prev = -1;
   
   qsort(nsp->num, nsp->used, sizeof(nsp->num[0]), cmp_num);

   for(int i = 0; i < nsp->used; i++)
   {
      if (nsp->num[i] != prev)
      {
         prev = nsp->num[i];
         
         printf("%d\n", prev);
      }
   }      
}

size_t nums_used(const NUMS* nsp)
{
   assert(is_valid(nsp));

   return nsp->used;
}