How to fix a C Program bug, preventing Multiple File Creations in a single execution?

initializeFileArray() is called from within loadIndexes(), which is called just once, at the start of the program.

When processing the first file, you call freeFileArray() at the end of FcreateList(), which sets *fileArray to NULL. Then initializeFileArray() is not called again before the next call to FcreateList() to process the next file, and so you call addFileToArray with *fileArray == NULL. As such, attempting to write to (*fileArray)[*size] crashes the program.

(Side note: it's very confusing to have a global variable called fileArray, and have all your functions take an argument with the same name that is a pointer to the global variable.)

[As Nate pointed out] it is better to use a struct instead of three separate variables.

So, I refactored the code to use one (e.g. struct arr below).

FcreateList and loadIndexes used the global fileArray but addFileToArray used an argument for this.

If we were creating a [reusable] library for this, we'd want to avoid the [inconsistent] usage of global variables.

Now, most functions take a single argument (a pointer to the struct) instead of separate arguments for array, size, and capacity.

Note that some functions [that would change the array] have to have indirect pointers.

With the struct, all functions can take consistent arguments.

Although this was intended as [merely] a first cut before debugging the [real] issue, in so doing, it seems to have eliminated your bug:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <errno.h>

#ifdef __linux__
#define DIRECTORY_NAME "TDL_File"
#include <unistd.h>
#define _access access
#define _strdup strdup
#define _mkdir(_file)   mkdir(_file,0755)
#define CLEAR   do { } while (0)
#else
#include <direct.h>
#include <io.h>
#define DIRECTORY_NAME "C:\\Users\\abood\\OneDrive\\Desktop\\TDL File"
#define CLEAR   system("cls")
#endif

#if 0
#define INDEX_FILE "index_data.txt"
#else
#define INDEX_FILE "index_data"
#endif
#define MAX_FILENAME_LENGTH 256

char input[100];
int choice = 0;
char listName[MAX_FILENAME_LENGTH];
char line[255];
FILE *fh;
bool keepGoing = true;
char fullPath[MAX_FILENAME_LENGTH];

// NOTE/BUG: [inconsistently] using globals like this is problematic (a source
// of bugs)
#if 0
char **fileArray = NULL;
int size = 0;
int capacity = 0;
#else
struct arr {
    char **data;
    int size;
    int capacity;
};
#endif

void
displayFiles(const struct arr *arr)
{
    printf("\nFiles and their indexes:\n");
    if (arr->size == 0) {
        printf("No files available.\n");
        return;
    }
    for (int i = 0; i < arr->size; i++) {
        printf("Index %d: %s\n", i, arr->data[i]);
    }
}

void
addFileToArray(struct arr *arr, const char *fileName)
{
    if (fileName == NULL || strlen(fileName) == 0) {
        printf("Error: Invalid file name.\n");
        return;
    }

    // Check if size is smaller or equals to the current capacity of elements
    if (arr->size >= arr->capacity) {
        // double the capacity number
        arr->capacity *= 2;

        // Resize the array
        char **newArray = realloc(arr->data, arr->capacity * sizeof(char *));

        // Check if realloc succeeded
        if (newArray == NULL) {
            perror("Failed to reallocate memory");
            exit(EXIT_FAILURE);
        }

        arr->data = newArray;
    }

    // Attempt to duplicate the file name and store it in the array
    arr->data[arr->size] = _strdup(fileName);
    if (arr->data[arr->size] == NULL) {
        perror("Failed to duplicate file name");
        exit(EXIT_FAILURE);
    }

    // Increase the size of the file array
    arr->size++;
}

void
freeFileArray(struct arr *arr)
{
    if (arr->data != NULL) {
        for (int i = 0; i < arr->size; i++) {
            free(arr->data[i]);
        }

        free(arr->data);
        arr->data = NULL;

#if 1
        arr->size = 0;
        arr->capacity = 0;
#endif
    }
}

void
prependDirectory(char *fullPath, const char *fileName)
{
    snprintf(fullPath, MAX_FILENAME_LENGTH, "%s/%s.txt",
        DIRECTORY_NAME, fileName);
}

void
saveIndexes(const struct arr *arr)
{
    char indexPath[MAX_FILENAME_LENGTH];

    // Prepend directory to index file name
    prependDirectory(indexPath, INDEX_FILE);

    FILE *file = fopen(indexPath, "w");

    if (!file) {
        perror("Failed to open index file for writing");
        return;
    }

    for (int i = 0; i < arr->size; i++) {
        fprintf(file, "%s\n", arr->data[i]);
    }

    fclose(file);
}

void
FcreateList(struct arr *arr)
{
    scanf("%s", listName);
    getchar();

    // Prepend directory to file name
    prependDirectory(fullPath, listName);

    fh = fopen(fullPath, "w");
    if (fh == NULL) {
        printf("Error creating file '%s' -- %s\n",fullPath,strerror(errno));
        return;
    }

    CLEAR;
    fclose(fh);

    addFileToArray(arr, fullPath);
    printf("File '%s' created and stored at index %d.\n",
        fullPath, arr->size - 1);

    CLEAR;

    // Display all files with their indexes
    displayFiles(arr);

    // Save indexes to the persistent file
    saveIndexes(arr);

    // Free allocated memory
    freeFileArray(arr);
}

void
ensureDirectoryExists(void)
{

    // Check if directory exists
    if (_access(DIRECTORY_NAME, 0) == -1) {
        // Create the directory if it doesn't exist
        if (_mkdir(DIRECTORY_NAME) != 0) {
            perror("Failed to create directory");
            exit(EXIT_FAILURE);
        }
    }
}

void
initializeFileArray(struct arr *arr)
{
    // The Array starts with 2
    arr->capacity = 2;

    // Allocate memory for the array of pointers
    arr->data = malloc(arr->capacity * sizeof(char *));

    // Check if malloc succeeded
    if (arr->data == NULL) {
        perror("Failed to allocate memory for file array");
        exit(EXIT_FAILURE);
    }

// NOTE/FIX: don't rely on caller doing this
#if 1
    arr->size = 0;
#endif
}

void
loadIndexes(struct arr *arr)
{
    char indexPath[MAX_FILENAME_LENGTH];

    // Prepend directory to index file name
    prependDirectory(indexPath, INDEX_FILE);

    FILE *file = fopen(indexPath, "r");

    if (!file) {
        printf("No existing index file found. Initializing empty file array.\n");
        // Ensure the file array is initialized
        initializeFileArray(arr);
#if 0
        arr->size = 0;
#endif
        return;
    }

    char buffer[MAX_FILENAME_LENGTH];

#if 0
    arr->size = 0;
#endif
    initializeFileArray(arr);

    while (fgets(buffer, sizeof(buffer), file)) {
        buffer[strcspn(buffer, "\n")] = '\0';
        addFileToArray(arr, buffer);
    }

    fclose(file);
}

int
main(void)
{

// NOTE/FIX: eliminate [critical] globals
#if 1
    static struct arr fileArray;
    struct arr *arr = &fileArray;
#endif

    ensureDirectoryExists();

    loadIndexes(arr);

    do {
        printf("1. Create a new List\n");
        printf("2. Add a new Task\n");
        printf("3. Show your List\n");

        scanf("%d", &choice);
        getchar();

        switch (choice) {
        case 1:
            printf("Type a name for your list\n");
            FcreateList(arr);
            printf("List has been created successfully\n");
            break;
        case 2:
            printf("Blank\n");
            break;
        case 3:
            printf("Blank\n");
            break;
        default:
            printf("Error opening the file\n");
            break;
        }

        printf("\nPress A to return to main Menu. Press any other Key To Exit: ");
#if 0
        scanf(" %c", &input);
#else
        scanf(" %c", input);
#endif

        CLEAR;
    } while (input[0] == 'A' || input[0] == 'a');

    return 0;
}

In the code above, I've used cpp conditionals to denote old vs. new code:

#if 0
// old code
#else
// new code
#endif

#if 1
// new code
#endif

Note: this can be cleaned up by running the file through unifdef -k