Reading string from array of pointers

Question

How can I read each individual character from a string that is accessed through an array of pointers? In the below code I currently have generated an array of pointers to strings called, symCodes, in my makeCodes function. I want to read the strings 8 characters at a time, I thought about concatenating each string together, then looping through that char by char but the strings in symCodes could be up to 255 characters each, so I feel like that could possibly be too much all to handle at once. Instead, I thought I could read each character from the strings, character by character.

I've tried scanf or just looping through and always end up with seg faults. At the end of headerEncode(), it's near the bottom. I malloc enough memory for each individual string, I try to loop through the array of pointers and print out each individual character but am ending up with a seg fault.

Any suggestions of a different way to read an array of pointers to strings, character by character, up to n amount of characters is appreciated.

EDIT 1: I've updated the program to no longer output warnings when using the -Wall and -W flags. I'm no longer getting a seg fault(yay!) but I'm still unsure of how to go about my question, how can I read an array of pointers to strings, character by character, up to n amount of characters?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "huffman.h"

#define FAIL 0
#define SUCCESS 1

/* global 1 day arrays that hold chars and their freqs from file */

unsigned long globalFreqs[256] = {0};
unsigned char globalUsedCh[256] = {0};
char globalCodes[256] = {0};
unsigned char globalUniqueSymbols;
unsigned long totalCount = 0;

typedef struct HuffmanTreeNode* HTNode;



struct HuffmanTreeNode* globalSortedLL;
/*
  struct has the input letter, the letters frequency, and the left and irght childs
*/
struct HuffmanTreeNode
{
  char symbol;
  unsigned long freq;
  char *code;
  struct HuffmanTreeNode *left, *right;
  struct HuffmanTreeNode* next;
};

/* does it make sense to have a struct for the entire huffman tree to see its size? */
struct HuffmanTree
{
  unsigned size;
};

/*generate new node with given symbol and freq */
struct HuffmanTreeNode* newNode(char symbol, int freq)
{
  struct HuffmanTreeNode* newNode = malloc(sizeof(struct HuffmanTreeNode));
  newNode->symbol = symbol;
  newNode->freq = freq;
  newNode->left = newNode->right = NULL;
  return newNode;
}

/*current work in progress, i believe this is the way to insert it for a BST
/* will change for HuffmanTreenode once working
/*
*/

struct HuffmanTreeNode* insert(struct HuffmanTreeNode* node, struct HuffmanTreeNode* htnNew)
{

  struct HuffmanTreeNode* currentNode = node;

  if(currentNode == NULL || compareTwoNodes(htnNew, currentNode))
  {
    htnNew->next = currentNode;
    return htnNew;
  }
  else
  {
    while(currentNode->next != NULL && compareTwoNodes(currentNode->next, htnNew))
    {
      currentNode = currentNode->next;
    }
    htnNew->next = currentNode->next;
    currentNode->next = htnNew;
    return node;
  }
}

int compareTwoNodes(struct HuffmanTreeNode* a, struct HuffmanTreeNode* b)
{
  if(b->freq < a->freq)
  {
    return 0;
  }
  if(a->freq == b->freq)
  {
    if(a->symbol > b->symbol)
      return 1;
    return 0;
  }
  if(b->freq > a->freq)
    return 1;
}

struct HuffmanTreeNode* popNode(struct HuffmanTreeNode** head)
{
  struct HuffmanTreeNode* node = *head;
  *head = (*head)->next;
  return node;
}

/*convert output to bytes from bits*/
/*use binary fileio to output */
/*put c for individual character byte*/
/*fwrite each individual byte for frequency of symbol(look at fileio slides) */

/*
  @function:
  @param:
  @return:
*/
int listLength(struct HuffmanTreeNode* node)
{
  struct HuffmanTreeNode* current = node;
  int length = 0;
  while(current != NULL)
  {
    length++;
    current = current->next;
  }
  return length;
}

/*
  @function:
  @param:
  @return:
*/
void printList(struct HuffmanTreeNode* node)
{
  struct HuffmanTreeNode* currentNode = node;

  while(currentNode != NULL)
  {
    if(currentNode->symbol <= ' ' || currentNode->symbol > '~')
      printf("=%d", currentNode->symbol);
    else
      printf("%c", currentNode->symbol);
    printf("%lu ", currentNode->freq);
    currentNode = currentNode->next;
  }
  printf("\n");
}

/*
  @function:
  @param:
  @return:
*/
void buildSortedList()
{
  int i;
  for(i = 0; i < 256; i++)
  {
    if(!globalFreqs[i] == 0)
    {
      globalSortedLL = insert(globalSortedLL, newNode(i, globalFreqs[i]));
    }
  }

  printf("Sorted freqs: ");
  printList(globalSortedLL);
  printf("listL: %d\n", listLength(globalSortedLL));
}
/*
  @function: isLeaf()
  will test to see if the current node is a leaf or not
  @param:
  @return
*/

int isLeaf(struct HuffmanTreeNode* node)
{
  if((node->left == NULL) && (node->right == NULL))
    return SUCCESS;
  else
    return FAIL;
}

/*where I plan to build the actual huffmantree */
/*
  @function:
  @param:
  @return:
*/
struct HuffmanTreeNode* buildHuffmanTree(struct HuffmanTreeNode* node)
{
  int top = 0;
  struct HuffmanTreeNode *left, *right, *topNode, *huffmanTree;
  struct HuffmanTreeNode* head = node;
  struct HuffmanTreeNode *newChildNode, *firstNode, *secondNode;

  while(head->next != NULL)
  {
    /*grab first two items from linkedL, and remove two items*/
    firstNode = popNode(&head);
    secondNode = popNode(&head);
    /*combine sums, use higher symbol, create new node*/
    newChildNode = newNode(secondNode->symbol, (firstNode->freq +   secondNode->freq));
    newChildNode->left = firstNode;
    newChildNode->right = secondNode;
    /*insert new node, decrement total symbols in use */
    head = insert(head, newChildNode);
  }

  return head;
}

void printTable(char *codesArray[])
{
  int i;
  printf("Symbol\tFreq\tCode\n");
  for(i = 0; i < 256; i++)
  {
    if(globalFreqs[i] != 0)
    {
      if(i <= ' ' || i > '~')
      {
        printf("=%d\t%lu\t%s\n", i, globalFreqs[i], codesArray[i]);
      }
      else
      {
        printf("%c\t%lu\t%s\n", i, globalFreqs[i], codesArray[i]);
      }
    }
  }
  printf("Total chars = %lu\n", totalCount);
}

void makeCodes(
   struct HuffmanTreeNode *node,        /* Pointer to some tree node */
   char *code,          /* The *current* code in progress */
   char *symCodes[256], /* The array to hold the codes for all the symbols */
   int depth)           /* How deep in the tree we are (code length) */
{
    char *copiedCode;
    int i = 0;

    if(isLeaf(node))
    {
        code[depth] = '\0';
        symCodes[node->symbol] = code;
        return;
    }

    copiedCode = malloc(255*sizeof(char));
    memcpy(copiedCode, code, 255*sizeof(char));

    code[depth] = '0';
    copiedCode[depth] = '1';
    makeCodes(node->left, code, symCodes, depth+1);
    makeCodes(node->right, copiedCode, symCodes, depth+1);
}

/*
  @function: getFileFreq()
  gets the frequencies of each character in the given
  file from the command line, this function will also
  create two global 1d arrays, one for the currently
  used characters in the file, and then one with those
  characters frequencies, the two arrays will line up
  parallel
  @param: FILE* in, FILE* out,
  the current file being processed
  @return: void
*/
void getFileFreq(FILE* in, FILE* out)
{  
    unsigned long freqs[256] = {0};
    int i, t, fileCh;

    while((fileCh = fgetc(in)) != EOF)
    {
        freqs[fileCh]++;
        totalCount++;
    }
    for(i = 0; i < 256; i++)
    {
        if(freqs[i] != 0)
        {
            globalUsedCh[i] = i;
            globalFreqs[i] = freqs[i];
            if(i <= ' ' || i > '~')
            {
                globalUniqueSymbols++;
            }
            else
            {
                globalUniqueSymbols++;
            }
        }
    }
    /* below code until total count is for debugging purposes */
    printf("Used Ch: ");
    for(t = 0; t < 256; t++)
    { 
    if(globalUsedCh[t] != 0)
            {  
         if(t <= ' ' || t > '~')
        {
            printf("%d ", globalUsedCh[t]);
        }
        else
            printf("%c ", globalUsedCh[t]);
        }
    }
    printf("\n");
    printf("Freq Ch: ");
    for(t = 0; t < 256; t++)
    {
        if(globalFreqs[t] != 0)
        {  
            printf("%lu ", globalFreqs[t]);
        }
    }
    printf("\n");
    /* end of code for debugging/vizualazation of arrays*/
    printf("Total Count %lu\n", totalCount);
    printf("globalArrayLength: %d\n", globalUniqueSymbols);
}


void headerEncode(FILE* in, FILE* out, char *symCodes[256])
{
    char c;
    int i, ch, t, q, b, z;
    char *a;
    char *fileIn;
    unsigned char *uniqueSymbols;
    unsigned char *byteStream;
    unsigned char *tooManySym = 0;
    unsigned long totalEncodedSym;


    *uniqueSymbols = globalUniqueSymbols;


    totalEncodedSym = ftell(in);
    rewind(in);

    fileIn = malloc((totalEncodedSym+1)*sizeof(char));
    fread(fileIn, totalEncodedSym, 1, in);
    if(globalUniqueSymbols == 256)
    {
        fwrite(tooManySym, 1, sizeof(char), out);
    }
    else
    {
        fwrite(uniqueSymbols, 1, sizeof(uniqueSymbols)-7, out);
    }
    for(i = 0; i < 256; i++)
    {
        if(globalFreqs[i] != 0)
        {
            fwrite(globalUsedCh+i, 1, sizeof(char), out);
            fwrite(globalFreqs+i, 8, sizeof(char), out);
        }
    }
    for(t = 0; t < totalEncodedSym; t++)
    {
            fwrite(symCodes[fileIn[t]], 8, sizeof(char), out);
    }
    for(q = 0; q < totalEncodedSym; q++)
    {
        symCodes[q] = malloc(255*sizeof(char));
        a = symCodes[q];
        while(*a != '\0')
            printf("%c\n", *(a++));
    }

    printf("Total encoded symbols: %lu\n", totalEncodedSym);
    printf("%s\n", fileIn);
}

void encodeFile(FILE* in, FILE* out)
{
    int top = 0;
    int i;
    char *code;
    char *symCodes[256] = {0};
    int depth = 0;

    code = malloc(255*sizeof(char));

    getFileFreq(in, out);
    buildSortedList();
    makeCodes(buildHuffmanTree(globalSortedLL), code, symCodes, depth);
    printTable(symCodes);
    headerEncode(in, out, symCodes);



    free(code);
}

/*
void decodeFile(FILE* in, FILE* out)
{

}*/

Answer 1

There are many problems in your code:

• [major] function compareTwoNodes does not always return a value. The compiler can detect such problems if instructed to output more warnings.

• [major] the member symbol in the HuffmanTreeNode should have type int. Type char is problematic as an index value because it can be signed or unsigned depending on compiler configuration and platform specificities. You assume that char has values from 0 to 255, which is incorrect for most platforms where char actually has a range of -128 .. 127. Use unsigned char or int but cast the char values to unsigned char to ensure proper promotion.

• [major] comparison if (globalUniqueSymbols == 256) is always false because globalUniqueSymbols is an unsigned char. The maximum number of possible byte values is indeed 256 for 8-bit bytes, but it does not fit in an unsigned char, make globalUniqueSymbols an int.

• [major] *uniqueSymbols = globalUniqueSymbols; in function headerEncode stores globalUniqueSymbols into an uninitialized pointer, definitely undefined behavior, probable segmentation fault.

• [major] sizeof(uniqueSymbols) is the size of a pointer, not the size of the array not the size of the type. Instead of hacking it as sizeof(uniqueSymbols)-7, fputc(globalUniqueSymbols, out);

• [major] fwrite(tooManySym, 1, sizeof(char), out); is incorrect too, since tooManySym is initialized to 0, ie: it is a NULL pointer. You need a special value to tell that all bytes values are used in the source stream, use 0 for that and write it with fputc(0, out);.

• You have nested C style comments before function insert, this is not a bug but error prone and considered bad style.

• function newNode should take type unsigned long for freq for consistency.

• function buildHuffmanTree has unused local variables: right, top and topNode.

• variable i is unused in function makeCodes.

• many unused variables in headerEncode: byteStream, c, ch, b...

• totalEncodedSym is an unsigned long, use an index of the proper type in the loops where you stop at totalEncodedSym.

• unused variables un encodeFile: i, top...

Most of these can be detected by the compiler with the proper warning level: gcc -Wall -W or clang -Weverything...

There are probably also errors in the program logic, but you cannot see these until you fix the major problems above.