Illegal instruction 4 when placing a function outside int main

Question

I've just begun learning the C language and I ran into an issue with one of my programs.

I am getting an error: "Illegal instruction 4" when executing: ./dictionary large.txt

Large.txt is a file with 143091 alphabetically sorted words, with each word starting on a new line. I am trying to load all of them into a hash table and return true if all the words are loaded successfully.

This code works for me if the code in bool load() is within int main and load() is non-existent. However, once I place it inside the load() function and call it from main, I get an error.

I would appreciate help on this, as there are not many threads on Illegal instruction.

This is my code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

// Maximum length for a word
// (e.g., pneumonoultramicroscopicsilicovolcanoconiosis)
#define LENGTH 45

// Number of letters in the english alphabet
#define ALPHABET_LENGTH 26

// Default dictionary
#define DICTIONARY "large.txt"

// Represents a node in a hash table
typedef struct node
{
    char word[LENGTH + 1];
    struct node *next;
} node;

// Number of buckets in hash table
const unsigned int N = ALPHABET_LENGTH;

// Hash table
node *table[N];

// Load function
bool load(char *dictionary);

// Hash function
int hash(char *word);

int main(int argc, char *argv[])
{
    // Check for correct number of args
    if (argc != 2 && argc != 3)
    {
        printf("Usage: ./speller [DICTIONARY] text\n");
        exit(1);
    }

    // Determine which dictionary to use
    char *dictionary = (argc == 3) ? argv[1] : DICTIONARY;

    bool loaded = load(dictionary);

    // TODO: free hashtable from memory

    return 0;
}

bool load(char *dictionary)
{
    // Open dictionary for reading
    FILE *file = fopen(dictionary, "r");
    if (file == NULL)
    {
        printf("Error 2: could not open %s. Please call customer service.\n", dictionary);
        exit(2);
    }

    // Initialize array to NULL
    for (int i = 0; i < N; i++)
        table[i] = NULL;

    // Declare and initialize variables
    unsigned int char_count = 0;
    unsigned int word_count = 0;
    char char_buffer;
    char word_buffer[LENGTH + 1];
    int hash_code = 0;
    int previous_hash_code = 0;

    // Declare pointers
    struct node *first_item;
    struct node *current_item;
    struct node *new_item;

    // Is true the first time the while loop is ran to be able to distinguish between hash_code and previous_hash_code after one loop
    bool first_loop = true;

    // Count the number of words in dictionary
    while (fread(&char_buffer, sizeof(char), 1, file))
    {

        // Builds the word_buffer by scanning characters
        if (char_buffer != '\n')
        {
            word_buffer[char_count] = char_buffer;

            char_count++;
        }
        else
        {
            // Increases word count each time char_buffer == '\n'
            word_count += 1;

            // Calls the hash function and stores its value in hash_code
            hash_code = hash(&word_buffer[0]);

            // Creates and initializes first node in a given table index
            if (hash_code != previous_hash_code || first_loop == true)
            {
                first_item = table[hash_code] = (struct node *)malloc(sizeof(node));
                if (first_item == NULL)
                {
                    printf("Error 3: memory not allocated. Please call customer service.\n");
                    return false;
                }

                current_item = first_item;
                strcpy(current_item->word, word_buffer);
                current_item->next = NULL;
            }
            else
            {
                new_item = current_item->next = (struct node *)malloc(sizeof(node));
                if (new_item == NULL)
                {
                    printf("Error 4: memory not allocated. Please call customer service.\n");
                    return false;
                }

                current_item = new_item;
                strcpy(current_item->word, word_buffer);
                current_item->next = NULL;
            }

            // Fills word buffer elements with '\0'
            for (int i = 0; i < char_count; i++)
            {
                word_buffer[i] = '\0';
            }

            // Signals the first loop has finished.
            first_loop = false;

            // Clears character buffer to keep track of next word
            char_count = 0;

            // Keeps track if a new table index should be initialized
            previous_hash_code = hash_code;
        }
    }

    return true;
}

// Hash in order of: 'a' is 0 and 'z' is 25
int hash(char *word_buffer)
{
    int hash = word_buffer[0] - 97;

    return hash;
}

Thank you in advance!

Chris

Answer 1

You should use node *table[ALPHABET_LENGTH]; for the table declaration instead of node *table[N];

There is a difference between constant macros and const variables, a macro can be used in a constant expression, such as a global array bound as per your use case, whereas a const variable cannot.

As you can see here, the compiler you say you are using, gcc, with no compiler flags, issues an error message:

error: variably modified 'table' at file scope

You can read more about these differences and use cases in "static const" vs "#define" vs "enum" it has more subjects, like static and enum, but is a nice read to grasp the differences between these concepts.