my dictonary.c

/**
 * Implements a dictionary's functionality.
 */

#include <stdbool.h>
#include <stdio.h>
#include <cs50.h>
#include <string.h>
#include <strings.h>

/* from Paul Hsieh http://www.azillionmonkeys.com/qed/hash.html */
#include <stdint.h> /* Replace with <stdint.h> if appropriate */
#undef get16bits
#if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
#define get16bits(d) (*((const uint16_t *) (d)))
#endif

#if !defined (get16bits)
#define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)\
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
#endif

#include "dictionary.h"

// a node to contain a word and reference other nodes
typedef struct _node
{
   char word[LENGTH + 1];
   struct _node *next;
}
node;

/* from Paul Hsieh http://www.azillionmonkeys.com/qed/hash.html */
uint32_t SuperFastHash (const char * data, int len) {
uint32_t hash = len, tmp;
int rem;

    if (len <= 0 || data == NULL) return 0;

    rem = len & 3;
    len >>= 2;

    /* Main loop */
    for (;len > 0; len--) {
        hash  += get16bits (data);
        tmp    = (get16bits (data+2) << 11) ^ hash;
        hash   = (hash << 16) ^ tmp;
        data  += 2*sizeof (uint16_t);
        hash  += hash >> 11;
    }

    /* Handle end cases */
    switch (rem) {
        case 3: hash += get16bits (data);
                hash ^= hash << 16;
                hash ^= ((signed char)data[sizeof (uint16_t)]) << 18;
                hash += hash >> 11;
                break;
        case 2: hash += get16bits (data);
                hash ^= hash << 11;
                hash += hash >> 17;
                break;
        case 1: hash += (signed char)*data;
                hash ^= hash << 10;
                hash += hash >> 1;
    }

    /* Force "avalanching" of final 127 bits */
    hash ^= hash << 3;
    hash += hash >> 5;
    hash ^= hash << 4;
    hash += hash >> 17;
    hash ^= hash << 25;
    hash += hash >> 6;

    return hash;
}
// node *head;

// array of nodes i.e. a hashtable
node *htable[10000];

int num_words = 0;

/**
 * Returns true if word is in dictionary else false.
 */
bool check(const char *word)
{
    unsigned long hash = SuperFastHash(word, strlen(word));
    int i = hash % 10000; // 10000 is size of the hashtable

    node *trav = htable[i];

    if (trav->next != NULL)
    {
        trav = trav->next; // move trav to first word containing node
        while (trav != NULL)
        {
            if (strcasecmp(trav->word, word) == 0)
            {
                return true;
            }
            trav = trav->next; // move one node down
        }
    }
    return false;
}

/**
 * Loads dictionary into memory. Returns true if successful else false.
 */
bool load(const char *dictionary)
{

    /*
    head = malloc(sizeof(node));
    if (head == NULL)
    {
        free(head);
    }
    head->next = NULL;
    // cursor = head;
    */

    // open the dictionary
    FILE *dict = fopen(dictionary, "r");

    // to hold words from the dictionary
    char word[LENGTH + 1];

    // read a word from the dictionary into the variable 'word'
    if (ftell(dict) != EOF)
    {
        while (fscanf(dict, "%s", word) != EOF)
        {
            num_words += 1;

            node *nnode = malloc(sizeof(node));
            nnode->next = NULL;
            if (nnode == NULL)
            {
                free(nnode);
                return false;
            }
            else
            {
                strcpy(nnode->word, word);
            }

            // hashing stuff
            unsigned long hash = SuperFastHash(word, strlen(word));
            int i = hash % 10000;

            if (htable[i] == NULL)
            {
                htable[i] = malloc(sizeof(node));
                if (htable[i] == NULL)
                {
                    free(htable[i]);
                }
                htable[i]->next = nnode;
            }
            else
            {
                nnode->next = htable[i]->next;
                htable[i]->next = nnode;
            }

            /*
            if(head->next == NULL)
            {
                head->next = nnode;
            }
            else
            {
                nnode->next = head->next;
                head->next = nnode;
            }
            */

        }
        fclose(dict);
        return true;
    }
    return false;
}

/**
 * Returns number of words in dictionary if loaded else 0 if not yet loaded.
 */
unsigned int size(void)
{
    // TODO
    return num_words;
}

/**
 * Unloads dictionary from memory. Returns true if successful else false.
 */
bool unload(void)
{
    for (int i = 0; i <= 9999; i++)
    {
        while (htable[i]->next != NULL)
        {
            node *temp = htable[i];
            htable[i] = htable[i]->next;
            free(temp);
        }
        free(htable[i]);
    }
    return true;
}