ex1a3.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <assert.h>

#define MAX_NUMS  ((INT32_MAX >> 5) + 1) 
#define BUF_NUMS  4096                   


static inline bool is_little_endian(void)
{
   union { uint32_t u; char c[sizeof(uint32_t)]; } bint = { 0x01020304 };

   return bint.c[0] == 4; 
}

static inline int32_t reverse_int32(int32_t val)
{
    val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF);
    
    return (val << 16) | ((val >> 16) & 0xFFFF);
}

static int store_numbers(
   const char*        filename,  
   uint32_t*          have_num,  
   const unsigned int max_nums)  
{
   int32_t buf[BUF_NUMS];
   int     fd;
   int     n;
   int     total_nums = 0;

   assert(NULL != filename);
   assert(0    <  strlen(filename));
   assert(NULL != have_num);
   assert(0    <  max_nums);
   
   /* Open file
    */
   if (0 > (fd = open(filename, O_RDONLY)))
   {
      perror(filename);
      return -1;
   }

   /* Read from file until data exhausted
    */
   while(0 < (n = read(fd, buf, sizeof(buf))))
   {
      int nums_read = n / sizeof(buf[0]); 

      assert(nums_read <= BUF_NUMS);
      
      total_nums += nums_read;

      /* Run through buffer of read numbers and set mark bits
       */
      for(int i = 0; i < nums_read; i++)
      {
         int32_t num = buf[i];

         if (!is_little_endian())
            num = reverse_int32(num);
         
         // fprintf(stderr, "%d\n", num);

         /* Check input: really >= 0 ? Otherwise ignore
          */
         if (num >= 0)
         {
            int      idx = num >> 5;         // n / 32
            uint32_t msk = 1 << (num & 31);  // bit number n mod 32 

            assert(idx >= 0 && idx < max_nums);
            
            have_num[idx] |= msk;
         }
      }
   }
   /* man close(2):
    * Not  checking  the  return value of close() is a common but nevertheless serious programming error.
    * It is quite possible that errors on a previous write(2) operation are first reported at the
    * final close().  Not checking the return value when closing the file may lead to silent loss of data.
    * This can especially be observed with NFS and with disk quota.
    */
   if (close(fd))
   {
      perror("close: ");
      return -2;
   }
   return total_nums;
}

static void output_numbers(
   FILE*              fp,       
   uint32_t*          have_num,  
   const unsigned int max_nums)  
{
   assert(NULL != fp);
   assert(NULL != have_num);

   for(int i = 0; i < max_nums; i++)
      if (have_num[i])  // just for speed up
         for(int k = 0; k < 31; k++)
            if (have_num[i] & (1 << k))
               fprintf(fp, "%d\n", (i << 5) + k);
}

int main(int argc, char** argv)
{
   const char* usage = "usage: %s filename\n";

   /* made static, because otherwise, the stack size might be too small.
    */
   uint32_t* have_num;
   int       total_nums;
   
   /* Check arguments, we need a filename.
    */
   if (argc < 2)
   {
      fprintf(stderr, usage, argv[0]);
      exit(EXIT_FAILURE);
   }
   if (NULL == (have_num = calloc(MAX_NUMS, sizeof(*have_num))))
   {
      fprintf(stderr, "calloc of size %lu failed\n", MAX_NUMS * sizeof(*have_num));
      exit(EXIT_FAILURE);
   }

   if (0 > (total_nums = store_numbers(argv[1], have_num, MAX_NUMS)))
      exit(EXIT_FAILURE);
      
   fprintf(stderr, "Total numbers read = %d\n", total_nums);
   
   output_numbers(stdout, have_num, MAX_NUMS);

   free(have_num);
   
   return EXIT_SUCCESS;
}