feat: accept extended ascii

Author: hmigl

include/comand.h

@@ -21,7 +21,7 @@ struct data {
 
   bool can_display_statistics;
   int serialized_tree[MAX_NODES];
-  char data[MAX_NODES];
+  unsigned char data[MAX_NODES];
 };
 
 #endif

lib/huffman/huffman_ds.c

@@ -38,10 +38,10 @@ static list_t *trim_freq_table(unsigned int *freq_table) {
   return list;
 }
 
-list_t *new_freq_table(const char *str) {
+list_t *new_freq_table(const unsigned char *str) {
   unsigned int freq[FREQ_TABLE_SIZE] = {0};
 
-  for (size_t i = 0; i < strlen(str); i++) {
+  for (size_t i = 0; i < strlen((char *)str); i++) {
     freq[(unsigned char)str[i]]++;
   }
   return trim_freq_table(freq);

lib/huffman/huffman_ds.h

@@ -27,7 +27,7 @@ struct list {
  * @param str string - should not be empty
  * @return linked list storing all 'frequency nodes' created from 'str'
  */
-list_t *new_freq_table(const char *str);
+list_t *new_freq_table(const unsigned char *str);
 
 /**
  * @brief Create a binary-tree based on 'Huffman coding'

src/decoder/decompress.c

@@ -9,19 +9,23 @@ static node_t *traverse_tree(node_t *current, char byte, int bit_index) {
   return (byte & (1 << bit_index)) ? current->right : current->left;
 }
 
-static char *huffman_coding_decompress(node_t *huff_tree, data_t *block) {
-  int i = 0, j, k = 0;
+static unsigned char *huffman_coding_decompress(node_t *huff_tree,
+                                                data_t *block) {
+  int i, j, k = 0;
   node_t *current = huff_tree;
-  char *decompressed = calloc(block->data_length + 1, sizeof(char));
+  size_t data_length = block->data_length;
+  unsigned char *decompressed =
+      calloc(block->data_length + 1, sizeof(unsigned char));
 
   for (i = 0; i < (int)block->compressed_data_length; i++) {
-    for (j = 7; j >= 0; j--) {
+    for (j = 7; j >= 0 && data_length; j--) {
       if (current) {
         current = traverse_tree(current, block->data[i], j);
       }
       if (is_leaf(current)) {
         decompressed[k++] = current->c;
         current = huff_tree;
+        data_length--;
       }
     }
   }
@@ -31,11 +35,11 @@ static char *huffman_coding_decompress(node_t *huff_tree, data_t *block) {
 
 void decompress(node_t *huff_tree, data_t *block) {
   clock_t invocation_start = clock(), invocation_end;
-  char *decompressed = huffman_coding_decompress(huff_tree, block);
+  unsigned char *decompressed = huffman_coding_decompress(huff_tree, block);
 
   invocation_end = clock();
   block->time_to_decompress =
       (double)(invocation_end - invocation_start) / CLOCKS_PER_SEC * 1000;
-  strcpy(block->data, decompressed);
+  strcpy((char *)block->data, (char *)decompressed);
   free(decompressed);
 }

src/encoder/compress.c

@@ -18,7 +18,7 @@ static void free_up_dictionary(char **dictionary) {
   dictionary = NULL;
 }
 
-static int data_length(char **dic, const char *data) {
+static int data_length(char **dic, const unsigned char *data) {
   int i = -1, len = 0;
 
   while (data[++i]) {
@@ -28,16 +28,18 @@ static int data_length(char **dic, const char *data) {
   return len;
 }
 
-static char *encode(char **dic, const char *data) {
-  char *encoded_data = calloc(data_length(dic, data), sizeof(char));
+static unsigned char *encode(char **dic, const unsigned char *data) {
+  unsigned char *encoded_data =
+      calloc(data_length(dic, data), sizeof(unsigned char));
 
   for (int i = 0; data[i] != '\0'; i++) {
     strcat((char *)encoded_data, dic[(int)data[i]]);
   }
   return encoded_data;
 }
 
-static void compress_byte(unsigned char *byte, char *encoded, int *j, int i) {
+static void compress_byte(unsigned char *byte, unsigned char *encoded, int *j,
+                          int i) {
   unsigned char mask = 1;
 
   if (encoded[i] == '1') {
@@ -52,7 +54,7 @@ static void add_compressed_byte(char *compressed, int *k, unsigned char byte) {
   (*k)++;
 }
 
-static unsigned int compress(char *encoded, char *compressed) {
+static unsigned int compress(unsigned char *encoded, char *compressed) {
   int i, j = 7, k = 0;
   unsigned char byte = 0;
 
@@ -71,14 +73,15 @@ static unsigned int compress(char *encoded, char *compressed) {
 }
 
 void compress_data(aux_t *aux) {
-  char *data_to_be_compressed;
+  unsigned char *data_to_be_compressed;
+
   if (!strcmp("--file", aux->argv[1]) && aux->argv[2]) {
     data_to_be_compressed = file_to_str(aux->argv[2]);
   } else {
-    data_to_be_compressed = merge_input(aux->argc, aux->argv);
+    data_to_be_compressed = (unsigned char *)merge_input(aux->argc, aux->argv);
   }
   list_t *freq_table = new_freq_table(data_to_be_compressed);
-  aux->data_length = strlen(data_to_be_compressed);
+  aux->data_length = strlen((char *)data_to_be_compressed);
 
   aux->huff_tree = new_huff_tree(freq_table);
   int tree_height = huff_tree_height(aux->huff_tree);

src/encoder/encoder.h

@@ -13,7 +13,7 @@ struct aux {
   unsigned int compressed_data_length;
 
   char **dictionary;
-  char *encoded_data;
+  unsigned char *encoded_data;
   unsigned char compressed_data[MAX_NODES];
   node_t *huff_tree;
 };
@@ -45,7 +45,7 @@ char *merge_input(int argc, char **argv);
  * @param file_name existing file path
  * @return string containg the contents of 'file_name'
  */
-char *file_to_str(const char *file_name);
+unsigned char *file_to_str(const char *file_name);
 
 /**
  * @brief Uses bitshifting operations to compress data, writing relevant

src/encoder/input.c

@@ -36,7 +36,7 @@ static bool has_valid_argc(int argc) { return argc >= 2; }
 
 bool has_valid_input(int argc, char **argv) { return has_valid_argc(argc); }
 
-static void read_into_buffer(FILE *file, char *contents, long size) {
+static void read_into_buffer(FILE *file, unsigned char *contents, long size) {
   int bytes_read = fread(contents, sizeof(char), size, file);
 
   if (bytes_read != size) {
@@ -63,10 +63,10 @@ static FILE *open_file(const char *file_name) {
   return file;
 }
 
-char *file_to_str(const char *file_name) {
+unsigned char *file_to_str(const char *file_name) {
   FILE *file = open_file(file_name);
   long size = get_file_size(file);
-  char *contents = (char *)malloc(size + 1);
+  unsigned char *contents = malloc(size + 1);
 
   if (contents == NULL) {
     perror("malloc");