spell_checker.c

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

struct TreeNode
{
    char *word;
    char *meaning;
    char *grammar;
    struct TreeNode *left;
    struct TreeNode *right;
};

void toLowercase(char *str)
{
    for (int i = 0; str[i]; i++)
    {
        str[i] = tolower((unsigned char)str[i]);
    }
}

void removePunctuation(char *str)
{
    int i, j;
    for (i = 0, j = 0; str[i] != '\0'; i++)
    {
        if (ispunct(str[i]))
            continue;
        str[j++] = str[i];
    }
    str[j] = '\0';
}

struct TreeNode *createNode(char *word, char *meaning, char *grammar)
{
    struct TreeNode *newNode = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    newNode->word = (word != NULL) ? strdup(word) : NULL;
    newNode->meaning = (meaning != NULL) ? strdup(meaning) : NULL;
    newNode->grammar = (grammar != NULL) ? strdup(grammar) : NULL;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

struct TreeNode *insertCaseInsensitive(struct TreeNode *root, char *word, char *meaning, char *grammar)
{
    toLowercase(word);
    char *cleanedWord = strdup(word);
    removePunctuation(cleanedWord);

    if (root == NULL)
        return createNode(cleanedWord, meaning, grammar);

    int cmp = strcasecmp(cleanedWord, root->word);
    if (cmp < 0)
        root->left = insertCaseInsensitive(root->left, cleanedWord, meaning, grammar);
    else if (cmp > 0)
        root->right = insertCaseInsensitive(root->right, cleanedWord, meaning, grammar);
    return root;
}

void readCsvFile(char filename, char *words, char *meanings, char **grammars, int *index)
{
    FILE *csvFile = fopen(filename, "r");
    if (csvFile == NULL)
    {
        perror("Error opening CSV file");
        return;
    }

    char line[1000];
    int lineCounter = 0;
    while (fgets(line, sizeof(line), csvFile) != NULL)
    {

        line[strcspn(line, "\n")] = '\0';
        lineCounter++;

        char *word = strtok(line, ",");
        char *grammar = strtok(NULL, ",");
        char *meaning = strtok(NULL, ",");

        if (word != NULL)
        {
            toLowercase(word);
            char *cleanedWord = strdup(word);
            removePunctuation(cleanedWord);

            (*words)[*index] = cleanedWord;
            (*meanings)[*index] = (meaning != NULL) ? strdup(meaning) : NULL;
            (*grammars)[*index] = (grammar != NULL) ? strdup(grammar) : NULL;

            (*index)++;
        }
        else
        {
            continue;
        }
    }

    fclose(csvFile);
}

struct TreeNode *createBalancedBST(char **words, char **meanings, char **grammars, int start, int end)
{
    if (start > end)
    {
        return NULL;
    }

    int mid = (start + end) / 2;
    struct TreeNode *newNode = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    newNode->word = strdup(words[mid]);
    newNode->meaning = (meanings[mid] != NULL) ? strdup(meanings[mid]) : NULL;
    newNode->grammar = (grammars[mid] != NULL) ? strdup(grammars[mid]) : NULL;

    newNode->left = createBalancedBST(words, meanings, grammars, start, mid - 1);
    newNode->right = createBalancedBST(words, meanings, grammars, mid + 1, end);

    return newNode;
}

void findSmallestAndLargest(struct TreeNode *node, char **smallest, char **largest)
{
    if (node == NULL)
    {
        return;
    }

    if (*smallest == NULL || strcmp(node->word, *smallest) < 0)
    {
        *smallest = node->word;
    }

    if (*largest == NULL || strcmp(node->word, *largest) > 0)
    {
        *largest = node->word;
    }

    findSmallestAndLargest(node->left, smallest, largest);
    findSmallestAndLargest(node->right, smallest, largest);
}

void printSmallestAndLargest(struct TreeNode *root)
{
    if (root == NULL)
    {
        printf("The tree is empty.\n");
        return;
    }

    char *smallestLeft = NULL;
    char *largestLeft = NULL;
    char *smallestRight = NULL;
    char *largestRight = NULL;
    char *largestLeftRight = NULL;
    char *smallestLeftRight = NULL;
    char *largestRightRight = NULL;
    char *smallestRightLeft = NULL;

    printf("\n\t\t\t\t\t     %s\n", root->word);

    findSmallestAndLargest(root, &smallestLeft, &largestRight);

    printf("\t\t\t\t       (%s---%s)\n", (smallestLeft != NULL) ? smallestLeft : "N/A", (largestRight != NULL) ? largestRight : "N/A");
    printf("\t\t\t\t\t  /\t      \\ \n");
    printf("\t\t\t\t    %s\t     %s\n", root->left->word, root->right->word);

    findSmallestAndLargest(root->left, &smallestLeft, &largestLeft);
    findSmallestAndLargest(root->right, &smallestRight, &largestRight);

    printf("\t\t\t      (%s---%s)        (%s---%s)\n", (smallestLeft != NULL) ? smallestLeft : "N/A", (largestLeft != NULL) ? largestLeft : "N/A", (smallestRight != NULL) ? smallestRight : "N/A", (largestRight != NULL) ? largestRight : "N/A");
    printf("\t\t\t       /\t    \\\t       /\t       \\\n");
    printf("\t\t\t   %s\t  %s   %s\t      %s\n", root->left->left->word, root->left->right->word, root->right->left->word, root->right->right->word);

    findSmallestAndLargest(root->left->left, &smallestLeft, &largestLeftRight);
    findSmallestAndLargest(root->left->right, &smallestLeftRight, &largestLeft);
    findSmallestAndLargest(root->right->left, &smallestRight, &largestRightRight);
    findSmallestAndLargest(root->right->right, &smallestRightLeft, &largestRight);

    printf("\t\t\t  (%s-        (%s-   (%s-     (%s-\n", (smallestLeft != NULL) ? smallestLeft : "N/A", (smallestLeftRight != NULL) ? smallestLeftRight : "N/A", (smallestRight != NULL) ? smallestRight : "N/A", (smallestRightLeft != NULL) ? smallestRightLeft : "N/A");
    printf("\t\t\t -%s)    -%s)    -%s)   -%s)\n\n", (largestLeftRight != NULL) ? largestLeftRight : "N/A", (largestLeft != NULL) ? largestLeft : "N/A", (largestRightRight != NULL) ? largestRightRight : "N/A", (largestRight != NULL) ? largestRight : "N/A");
}

void freeArray(char **array, int size)
{
    for (int i = 0; i < size; i++)
    {
        free(array[i]);
    }
    free(array);
}

bool searchAndGetMeaningCaseInsensitive(struct TreeNode *root, char *word, char **meaning, char **grammar)
{
    if (root == NULL)
    {
        return false;
    }

    int cmp = strcasecmp(word, root->word);
    if (cmp < 0)
    {
        return searchAndGetMeaningCaseInsensitive(root->left, word, meaning, grammar);
    }
    else if (cmp > 0)
    {
        return searchAndGetMeaningCaseInsensitive(root->right, word, meaning, grammar);
    }
    else
    {
        *meaning = (root->meaning != NULL) ? root->meaning : "The meaning of the word is unknown as the word was added to the database by the user.";
        *grammar = (root->grammar != NULL) ? root->grammar : "The grammar of the word is unknown as the word was added to the database by the user.";
        return true;
    }
}

void checkSpellingOfSentence(struct TreeNode *root, char *sentence)
{
    char *token = strtok(sentence, " ");
    while (token != NULL)
    {
        removePunctuation(token);
        char *meaning;
        char *grammar;
        if (searchAndGetMeaningCaseInsensitive(root, token, &meaning, &grammar))
        {
            printf("The word '%s' is spelled correctly.\n", token);
            printf("Grammar: %s\n", grammar);
            printf("Meaning: %s\n", meaning);
        }
        else
        {
            printf("The word '%s' is not found/spelled correctly.\n", token);
            printf("Do you want to add this word to the database? (y/n): ");
            char addWordChoice;
            scanf(" %c", &addWordChoice);
            if (addWordChoice == 'y' || addWordChoice == 'Y')
            {
                root = insertCaseInsensitive(root, token, NULL, NULL);
                printf("The word has been added to the database.\n");
            }
        }
        token = strtok(NULL, " ");
    }
}

void inOrderTraversal(struct TreeNode *root, FILE *csvFile)
{
    if (root == NULL)
    {
        return;
    }
    inOrderTraversal(root->left, csvFile);
    if (root->word != NULL)
    {
        fprintf(csvFile, "%s,", root->word);
    }
    if (root->grammar != NULL)
    {
        fprintf(csvFile, "%s,", root->grammar);
    }
    else
    {
        fprintf(csvFile, ",");
    }
    if (root->meaning != NULL)
    {
        char *meaningCopy = strdup(root->meaning);
        char *pos;
        while ((pos = strchr(meaningCopy, ',')) != NULL)
        {
            *pos = ';';
        }
        fprintf(csvFile, "%s", meaningCopy);
        free(meaningCopy);
    }
    else
    {
        fprintf(csvFile, ",");
    }
    fprintf(csvFile, "\n");
    inOrderTraversal(root->right, csvFile);
}

void writeCsvFile(struct TreeNode *root, char *filename)
{
    FILE *csvFile = fopen(filename, "w");
    if (csvFile == NULL)
    {
        perror("Error opening CSV file for writing");
        return;
    }
    inOrderTraversal(root, csvFile);
    fclose(csvFile);
}

void freeTree(struct TreeNode *root)
{
    if (root == NULL)
        return;
    freeTree(root->left);
    freeTree(root->right);
    free(root->word);
    free(root->meaning);
    free(root->grammar);
    free(root);
}

int main()
{

    int index = 0;
    char **words = malloc(sizeof(char *) * 5000);
    char **meanings = malloc(sizeof(char *) * 5000);
    char **grammars = malloc(sizeof(char *) * 5000);

    readCsvFile("word.csv", &words, &meanings, &grammars, &index);

    struct TreeNode *root = createBalancedBST(words, meanings, grammars, 0, index - 1);

    printSmallestAndLargest(root);

    freeArray(words, index);
    freeArray(meanings, index);
    freeArray(grammars, index);

    while (1)
    {
        char inputSentence[256];
        printf("Enter a word or sentence to check its spelling (or 'q' to quit): ");
        scanf(" %[^\n]%*c", inputSentence);
        if (strcmp(inputSentence, "q") == 0)
        {
            break;
        }
        checkSpellingOfSentence(root, inputSentence);
    }

    writeCsvFile(root, "word.csv");
    freeTree(root);
    return 0;
}