uqparallel.c

#include <csse2310a3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#include <signal.h>
#include <getopt.h>
#include <sys/wait.h>
//REF:chatGPT help me define the value name
#define DEFAULT_MAX_JOBS 110
#define EXIT_USAGE_ERROR 5
#define EXIT_SIGNAL_TERMINATION 70
#define EXIT_EMPTY_COMMAND 80
#define EXIT_INTERRUPTED 8

volatile bool interrupted = false;

typedef struct {
    int maxJobs;
    bool abortOnError;
    bool printOnly;
    bool usePipe;
    char* argsFile;
    char** cmd;
    int cmdCount;
    char** perTaskArgs;
    int perTaskArgsCount;
} Options;

typedef struct {
    char** args;
    int argCount;
    pid_t pid;
    int status;
    bool completed;
} Task;

//functions
//REF:chatGPT help me rename the function name to be more clear
void parse_arguments(int argc, char** argv, Options* options);
void print_usage(void);

void execute_tasks(Options* options);
void read_args_from_file(Options* options, Task*** tasks, int* taskCount);
void read_args_from_stdin(Options* options, Task*** tasks, int* taskCount);
void create_tasks_from_cmdline(Options* options, Task*** tasks, int* taskCount);

void execute_task(Task* task, int stdinFd, int stdoutFd);
void print_task(int jobNum, Task* task, bool isPipe);
void handle_sigint(int sig);
void setup_signal_handlers(void);

void free_task(Task* task);
void free_tasks(Task** tasks, int taskCount);
void free_options(Options* options);

bool reap_tasks(Task** tasks, int taskCount, bool waitForAll);
void terminate_tasks(Task** tasks, int taskCount, int signal);
int count_running_tasks(Task** tasks, int taskCount);

void wait_for_one_second(void);
void execute_pipeline(Options* options, Task** tasks, int taskCount);

//main function
int main(int argc, char* argv[]){

    //argc--; // argc-- to skip the program name
    //argv++; // argv++ to point to the first argument
    
    //printf("Hello\n");
    //printf("have a good day\n");
    
    Options options = {
        .maxJobs = DEFAULT_MAX_JOBS,
        .abortOnError = false,
        .printOnly = false,
        .usePipe = false,
        .argsFile = NULL,
        .cmd = NULL,
        .cmdCount = 0,
        .perTaskArgs = NULL,
        .perTaskArgsCount = 0
    };

    parse_arguments(argc, argv, &options);//parse command line

    setup_signal_handlers(); //set up signal handler
    execute_tasks(&options);
    free_options(&options);

    return 0;
}

void setup_signal_handlers(void) {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = handle_sigint;
    sigaction(SIGINT, &sa, NULL);
}

void handle_sigint(int sig) {
    (void)sig; // Unused parameter
    interrupted = true;
}

void print_usage(void) {
    fprintf(stderr, "Usage: ./uqparallel [--jobs n] [--abort-on-error] "
            "[--print] [--pipe] [--args-file argument-file] "
            "[cmd [fixed-args ...]] [::: per-task-args ...]\n");
}

void parse_arguments(int argc, char** argv, Options* options) {
    static struct option longOptions[] = { //define the long options
        {"jobs", required_argument, 0, 'j'},
        {"abort-on-error", no_argument, 0, 'a'},
        {"print", no_argument, 0, 'p'},
        {"pipe", no_argument, 0, 'i'},
        {"args-file", required_argument, 0, 'f'},
        {0, 0, 0, 0}
    };
    opterr = 0;

    int opt;
    int optionIndex = 0;
    bool foundTripleColon = false;

    //add duplicate check signal
    bool seenJobs = false;
    bool seenAbort = false;
    bool seenPrint = false;
    bool seenPipe = false;
    bool seenArgsFile = false;

    while ((opt = getopt_long(argc, argv, "", longOptions, &optionIndex)) != -1) {
        //REF: chatGPT help me recode switch part
        switch (opt) {
            case 'j': {
                if (seenJobs) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                seenJobs = true;

                char* endptr;
                options->maxJobs = strtol(optarg, &endptr, 10);
                if (*endptr != '\0' || options->maxJobs < 1 || 
                        options->maxJobs > 110) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                break;
            }
            case 'a':
                if (seenAbort) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                seenAbort = true;
                options->abortOnError = true;
                break;
            case 'p':
                if (seenPrint) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                seenPrint = true;
                options->printOnly = true;
                break;
            case 'i':
                if (seenPipe) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                seenPipe = true;
                options->usePipe = true;
                break;
            case 'f':
                if (seenArgsFile) {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                seenArgsFile = true;

                if (optarg[0] == '\0') {
                    print_usage();
                    exit(EXIT_USAGE_ERROR);
                }
                options->argsFile = strdup(optarg);
                break;
            case '?':
                print_usage();
                exit(EXIT_USAGE_ERROR);
            default:
                print_usage();
                exit(EXIT_USAGE_ERROR);
        }
    }

    //check the remainiung arguments for cmd and :::
    if (optind < argc) {
        int i;
        for (i = optind; i < argc; i++) {
            if (strcmp(argv[i], ":::") == 0) {
                foundTripleColon = true;

                // Save command and fixed args
                if (i > optind) {
                    options->cmdCount = i - optind;
                    options->cmd = (char**)malloc(options->cmdCount * sizeof(char*));
                    if (!options->cmd) {
                        fprintf(stderr, "Memory allocation failed\n");
                        exit(EXIT_FAILURE);
                    }
                    for (int j = 0; j < options->cmdCount; j++) {
                        options->cmd[j] = strdup(argv[optind + j]);
                    }
                }

                // Save per-task args
                options->perTaskArgsCount = argc - i - 1;
                if (options->perTaskArgsCount > 0) {
                    options->perTaskArgs = 
                        (char**)malloc(options->perTaskArgsCount * sizeof(char*));
                    if (!options->perTaskArgs) {
                        fprintf(stderr, "Memory allocation failed\n");
                        exit(EXIT_FAILURE);
                    }
                    for (int j = 0; j < options->perTaskArgsCount; j++) {
                        options->perTaskArgs[j] = strdup(argv[i + 1 + j]);
                    }
                }
                break;
            }
        }

        if (!foundTripleColon) {
            options->cmdCount = argc - optind;
            options->cmd =(char**) malloc(options->cmdCount * sizeof(char*));
            if (!options->cmd) {
                fprintf(stderr, "Memory allocation failed\n");
                exit(EXIT_FAILURE);
            }
            for (int j = 0; j < options->cmdCount; j++) {
                options->cmd[j] = strdup(argv[optind + j]);
            }
        }
    }

    if (options->argsFile != NULL && foundTripleColon) {
        // Can't have both --args-file and :::
        print_usage();
        exit(EXIT_USAGE_ERROR);
    }

    if (options->usePipe && !options->argsFile && !foundTripleColon) {
        // Can't read from stdin if --pipe is specified
        print_usage();
        exit(EXIT_USAGE_ERROR);
    }

    if (options->cmdCount > 0 && options->cmd[0][0] == '\0') {
        print_usage();
        exit(EXIT_USAGE_ERROR);
    }
}

void free_options(Options* options) {
    if (options->argsFile) {
        free(options->argsFile);
    }
    
    if (options->cmd) {
        for (int i = 0; i < options->cmdCount; i++) {
            free(options->cmd[i]);
        }
        free(options->cmd);
    }
    
    if (options->perTaskArgs) {
        for (int i = 0; i < options->perTaskArgsCount; i++) {
            free(options->perTaskArgs[i]);
        }
        free(options->perTaskArgs);
    }
}

void free_task(Task* task) {
    if (task->args) {
        for (int i = 0; i < task->argCount; i++) {
            free(task->args[i]);
        }
        free(task->args);
    }
}

void free_tasks(Task** tasks, int taskCount) {
    if(tasks){
        for (int i = 0; i < taskCount; i++) {
            if (tasks[i]) {
                free_task(tasks[i]);
                free(tasks[i]);
            }
        }
        free(tasks);
    }
}

void print_task(int jobNum, Task* task, bool isPipe) {
    printf("%d: ", jobNum);

    for (int i = 0; i < task->argCount; i++) {
        bool hasSpace = false;
        for (int j = 0; task->args[i][j] != '\0'; j++) {
            if (task->args[i][j] == ' ') {
                hasSpace = true;
                break;
            }
        }

        if (hasSpace) {
            printf("\"%s\"", task->args[i]);
        } 
        else {
            printf("%s", task->args[i]);
        }

        // Add space if not the last argument
        if (i < task->argCount - 1) {
            printf(" ");
        }
    }

    if (isPipe) {
        printf(" |");
    }

    printf("\n");
}
//REF:edSTEM week 7
void read_args_from_file(Options* options, Task*** tasks, int* taskCount) 
{
    FILE* file = fopen(options->argsFile, "r");
    if (!file) {
        fprintf(stderr, "uqparallel: unable to open %s\n", options->argsFile);
        exit(EXIT_USAGE_ERROR);
    }

    char* line = NULL;
    size_t len = 0;
    ssize_t read;

    // Count lines first to allocate tasks array
    *taskCount = 0;
    while ((read = getline(&line, &len, file)) != -1) {
        if (read <= 1 && options->cmdCount == 0) {
            continue;
        }
        (*taskCount)++;
    }

    if (fseek(file, 0, SEEK_SET) != 0) {
        fprintf(stderr, "uqparallel: Error seeking in file\n");
        fclose(file);
        free(line);
        exit(EXIT_FAILURE);
    }
    
    //REF: chatGPT help me to add this
    //handle case of no tasks
    if (*taskCount == 0) {
        free(line);
        fclose(file);
        *tasks = NULL;
        return;
    }

    // Allocate tasks array
    *tasks = malloc(*taskCount * sizeof(Task*));
    if (!*tasks) {
        fprintf(stderr, "Memory allocation failed\n");
        free(line);
        fclose(file);
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < *taskCount; i++) {
        (*tasks)[i] = malloc(sizeof(Task));
        if (!(*tasks)[i]) {
            fprintf(stderr, "Memory allocation failed\n");
            for (int j = 0; j < i; j++) {
                free((*tasks)[j]);
            }
            free(*tasks);
            free(line);
            fclose(file);
            exit(EXIT_FAILURE);
        }

        (*tasks)[i]->args = NULL;
        (*tasks)[i]->argCount = 0;
        (*tasks)[i]->pid = -1;
        (*tasks)[i]->status = 0;
        (*tasks)[i]->completed = false;
    }

    // Read file again to fill tasks
    int taskIndex = 0;
    while ((read = getline(&line, &len, file)) != -1) 
    {
        // Remove newline if present
        if (read > 0 && line[read - 1] == '\n') {
            line[read - 1] = '\0';
            read--;
        }

        if (read == 0 && options->cmdCount == 0) {
            continue;
        }

        int numTokens;
        char** lineArgs = split_space_not_quote(line, &numTokens);
        if (!lineArgs) {
            fprintf(stderr, "Error parsing line\n");
            continue;
        }

        // Create the task's argument list
        if (options->cmdCount > 0) {
            // Command is provided on command line
            (*tasks)[taskIndex]->argCount = options->cmdCount + numTokens;
            (*tasks)[taskIndex]->args = (char**) malloc((*tasks)[taskIndex]->argCount * sizeof(char*));
            if (!(*tasks)[taskIndex]->args) {
                fprintf(stderr, "Memory allocation failed\n");
                for (int j = 0; j < numTokens; j++) {
                    free((*tasks)[j]);
                }
                free(*tasks);
                free(line);
                fclose(file);
                exit(EXIT_FAILURE);
            }

            // Copy command and fixed args
            for (int i = 0; i < options->cmdCount; i++) {
                (*tasks)[taskIndex]->args[i] = strdup(options->cmd[i]);
            }

            for (int i = 0; i < numTokens; i++) {
                (*tasks)[taskIndex]->args[options->cmdCount + i] = 
                    strdup(lineArgs[i]);
            }
        } 
        else {
            (*tasks)[taskIndex]->argCount = numTokens;
            (*tasks)[taskIndex]->args = 
                (char**)malloc(numTokens * sizeof(char*));
            if (!(*tasks)[taskIndex]->args) {
                fprintf(stderr, "Memory allocation failed\n");
                for (int i = 0; i < numTokens; i++) {
                    free(lineArgs[i]);
                }
                free(lineArgs);
                free(line);
                fclose(file);
                exit(EXIT_FAILURE);
            }

            // Copy line args
            for (int i = 0; i < numTokens; i++) {
                (*tasks)[taskIndex]->args[i] = 
                    strdup(lineArgs[i]);
            }
        }

        // Free the parsed line arguments
        for (int i = 0; i < numTokens; i++) {
            free(lineArgs[i]);
        }
        free(lineArgs);

        taskIndex++;
    }

    free(line);
    fclose(file);
}

//REF:edSTEM week 7
void read_args_from_stdin(Options* options, Task*** tasks, int* taskCount) {
    char* line = NULL;
    size_t len = 0;
    ssize_t read;
    
    // Allocate tasks array dynamically
    int capacity = 10;
    *tasks = malloc(capacity * sizeof(Task*));
    if (!*tasks) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    
    *taskCount = 0;
    
    while ((read = getline(&line, &len, stdin)) != -1) {
        // Remove newline if present
        if (read > 0 && line[read - 1] == '\n') {
            line[read - 1] = '\0';
            read--;
        }
        
        // Skip empty lines if no command provided
        if (read == 0 && options->cmdCount == 0) {
            continue;
        }
        
        // Resize tasks array if needed
        if (*taskCount >= capacity) {
            capacity *= 2;
            Task** newTasks = realloc(*tasks, capacity * sizeof(Task*));
            if (!newTasks) {
                perror("Failed to realloc tasks array");
                free(line);
                free_tasks(*tasks, *taskCount);
                exit(EXIT_FAILURE);
            }
            *tasks = newTasks;
        }
        
        // Allocate new task
        (*tasks)[*taskCount] = malloc(sizeof(Task));
        if (!(*tasks)[*taskCount]) {
            fprintf(stderr, "Memory allocation failed\n");
            free(line);
            free_tasks(*tasks, *taskCount);
            exit(EXIT_FAILURE);
        }

        (*tasks)[*taskCount]->args = NULL;
        (*tasks)[*taskCount]->argCount = 0;
        (*tasks)[*taskCount]->pid = -1;
        (*tasks)[*taskCount]->status = 0;
        (*tasks)[*taskCount]->completed = false;
        
        int numTokens;
        char** lineArgs = split_space_not_quote(line, &numTokens);
        if (!lineArgs) {
            fprintf(stderr, "Error parsing line\n");
            free((*tasks)[*taskCount]);
            continue;
        }
        
        if (options->cmdCount > 0) {
            (*tasks)[*taskCount]->argCount = options->cmdCount + numTokens;
            (*tasks)[*taskCount]->args = 
                malloc((*tasks)[*taskCount]->argCount * sizeof(char*));
            if (!(*tasks)[*taskCount]->args) {
                fprintf(stderr, "Memory allocation failed\n");
                for (int i = 0; i < numTokens; i++) {
                    free(lineArgs[i]);
                }
                free(lineArgs);
                free(line);
                free((*tasks)[*taskCount]);
                free_tasks(*tasks, *taskCount);
                exit(EXIT_FAILURE);
            }
            
            for (int i = 0; i < options->cmdCount; i++) {
                (*tasks)[*taskCount]->args[i] = strdup(options->cmd[i]);
            }
            
            for (int i = 0; i < numTokens; i++) {
                (*tasks)[*taskCount]->args[options->cmdCount + i] = 
                    strdup(lineArgs[i]);
            }
        } 
        else {
            // Command is from stdin
            (*tasks)[*taskCount]->argCount = numTokens;
            (*tasks)[*taskCount]->args = malloc(numTokens * sizeof(char*));
            if (!(*tasks)[*taskCount]->args) {
                fprintf(stderr, "Memory allocation failed\n");
                for (int i = 0; i < numTokens; i++) {
                    free(lineArgs[i]);
                }
                free(lineArgs);
                free(line);
                free((*tasks)[*taskCount]);
                free_tasks(*tasks, *taskCount);
                exit(EXIT_FAILURE);
            }
            
            for (int i = 0; i < numTokens; i++) {
                (*tasks)[*taskCount]->args[i] = strdup(lineArgs[i]);
            }
        }
        
        for (int i = 0; i < numTokens; i++) {
            free(lineArgs[i]);
        }
        free(lineArgs);
        
        (*taskCount)++;
    }
    
    free(line);

    //REF: chatGPT help me add this condition
    // If no tasks were read, handle appropriately
    if (*taskCount == 0) {
        free(*tasks);
        *tasks = NULL;
    }
}

void create_tasks_from_cmdline(Options* options, Task*** tasks, int* taskCount) 
{
    *taskCount = options->perTaskArgsCount;
    if (*taskCount == 0) {
        *tasks = NULL;
        return;
    }
    *tasks = malloc(*taskCount * sizeof(Task*));
     if (!*tasks) {
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }

    for (int i = 0; i < *taskCount; i++) {
        (*tasks)[i] = malloc(sizeof(Task));
        if (!(*tasks)[i]) {
            fprintf(stderr, "Memory allocation failed\n");
            for (int j = 0; j < i; j++) {
                free_task((*tasks)[j]);
                free((*tasks)[j]);
            }
            free(*tasks);
            exit(EXIT_FAILURE);
        }

        (*tasks)[i]->pid = -1;
        (*tasks)[i]->status = 0;
        (*tasks)[i]->completed = false;

        // Set up args array
        (*tasks)[i]->argCount = options->cmdCount + 1;
        (*tasks)[i]->args = malloc((*tasks)[i]->argCount * sizeof(char*));

        // Copy command and fixed args
        for (int j = 0; j < options->cmdCount; j++) {
            (*tasks)[i]->args[j] = strdup(options->cmd[j]);
        }

        (*tasks)[i]->args[options->cmdCount] = strdup(options->perTaskArgs[i]);
    }
}

void execute_task(Task* task, int stdinFd, int stdoutFd) 
{
    if (task->argCount == 0 || task->args[0][0] == '\0') {
        fprintf(stderr, "uqparallel: can't execute empty command\n");
        task->status = EXIT_EMPTY_COMMAND;
        task->completed = true;
        return;
    }

    //Fork a child process
    pid_t pid = fork();
    
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } 
    else if (pid == 0) {
        if (stdinFd != STDIN_FILENO) {
            dup2(stdinFd, STDIN_FILENO);
            close(stdinFd);
        }

        if (stdoutFd != STDOUT_FILENO) {
            dup2(stdoutFd, STDOUT_FILENO);
            close(stdoutFd);
        }
        for (int i = 3; i < 256; i++) {
            close(i);
        }
        execvp(task->args[0], task->args);
        
        fprintf(stderr, "uqparallel: \"%s\" can't be executed\n", task->args[0]);
        raise(SIGUSR1);
        
        // Should not reach here, but just in case
        exit(EXIT_FAILURE);
    } 
    else {
        // Parent process
        task->pid = pid;
    }
}

bool reap_tasks(Task** tasks, int taskCount, bool waitForAll) {
    bool anyFailed = false;
    int status;
    pid_t pid;

    while ((pid = waitpid(-1, &status, waitForAll ? 0 : WNOHANG)) > 0) {
        // Find the task with this pid
        for (int i = 0; i < taskCount; i++) {
            if (tasks[i]->pid == pid) {
                tasks[i]->status = status;
                tasks[i]->completed = true;

                // Check if the task failed
                if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
                    anyFailed = true;
                } else if (WIFSIGNALED(status)) {
                    anyFailed = true;
                }

                break;
            }
        }
    }

    return anyFailed;
}

void terminate_tasks(Task** tasks, int taskCount, int signal) {
    for (int i = 0; i < taskCount; i++) {
        if (tasks[i]->pid > 0 && !tasks[i]->completed) {
            kill(tasks[i]->pid, signal);
        }
    }
}

int count_running_tasks(Task** tasks, int taskCount) {
    int count = 0;
    for (int i = 0; i < taskCount; i++) {
        if (tasks[i]->pid > 0 && !tasks[i]->completed) {
            count++;
        }
    }
    return count;
}

void wait_for_one_second(void) {
    sigset_t mask;
    struct timespec timeout;

    sigemptyset(&mask);
    sigaddset(&mask, SIGCHLD);

    timeout.tv_sec = 1;
    timeout.tv_nsec = 0;

    sigtimedwait(&mask, NULL, &timeout);
}

void execute_pipeline(Options* options, Task** tasks, int taskCount) {
    (void)options;
    if (taskCount == 0) {
        return;
    }
    
    if (taskCount == 1) {
        execute_task(tasks[0], STDIN_FILENO, STDOUT_FILENO);
        int status;
        waitpid(tasks[0]->pid, &status, 0);
        tasks[0]->status = status;
        tasks[0]->completed = true;
        return;
    }

    int pipes[taskCount - 1][2];
    for (int i = 0; i < taskCount - 1; i++) {
        if (pipe(pipes[i]) == -1) {
            perror("pipe creation failed");
            exit(EXIT_FAILURE);
        }
    }

    execute_task(tasks[0], STDIN_FILENO, pipes[0][1]);
    close(pipes[0][1]);

    for (int i = 1; i < taskCount - 1; i++) {
        execute_task(tasks[i], pipes[i-1][0], pipes[i][1]);
        close(pipes[i-1][0]);
        close(pipes[i][1]);
    }

    execute_task(tasks[taskCount - 1], pipes[taskCount - 2][0], STDOUT_FILENO);
    close(pipes[taskCount - 2][0]);

    for (int i = 0; i < taskCount; i++) {
        if (tasks[i]->pid <= 0) {
            continue;
        }

        int status;
        waitpid(tasks[i]->pid, &status, 0);
        tasks[i]->status = status;
        tasks[i]->completed = true;
    }
}

//REF:edSTEM week 6
void execute_tasks(Options* options) 
{
    Task** tasks = NULL;
    int taskCount = 0;
    
    //creat tasks based on input source
    if (options->perTaskArgs != NULL) {
        create_tasks_from_cmdline(options, &tasks, &taskCount);//arguments from command line
    }
    else if (options->argsFile != NULL) {
        read_args_from_file(options, &tasks, &taskCount);//arguments from file
    }
    else{
        read_args_from_stdin(options, &tasks, &taskCount);//arguments from stdin
    }

    if (taskCount == 0) {
        if (tasks) {
            free(tasks);
        }
        exit(EXIT_EMPTY_COMMAND);
    }

    if (options->printOnly) {
        for (int i = 0; i < taskCount; i++) {
            print_task(i + 1, tasks[i], options->usePipe && i < taskCount - 1);
        }
        free_tasks(tasks, taskCount);
        return;
    }

    if (options->usePipe) {
        // Execute as pipeline
        execute_pipeline(options, tasks, taskCount);

        //REF:chatGPT help me to recode this part
        // For pipelines, we need to exit with appropriate status
        int exitStatus = 0;

        // Find the exit status of the last task
        for (int i = 0; i < taskCount; i++) {
            if (tasks[i]->completed) {
                if (WIFEXITED(tasks[i]->status)) {
                    exitStatus = WEXITSTATUS(tasks[i]->status);
                } else if (WIFSIGNALED(tasks[i]->status)) {
                    exitStatus = EXIT_SIGNAL_TERMINATION;
                }
            }
        }

        // Free tasks
        free_tasks(tasks, taskCount);

        // Exit with appropriate status
        exit(exitStatus);
    } 
    else {
        // Execute tasks in parallel
        int runningTasks = 0;
        int nextTask = 0;
        bool anyFailed = false;

        while (nextTask < taskCount || runningTasks > 0) 
        {
            // Start tasks if possible
            while (nextTask < taskCount &&
                   runningTasks < options->maxJobs &&
                   !interrupted &&
                   !(anyFailed && options->abortOnError)) 
            {
                execute_task(tasks[nextTask], STDIN_FILENO, STDOUT_FILENO);
                if (tasks[nextTask]->pid > 0) 
                {
                    runningTasks++;
                }
                nextTask++;
            }

            anyFailed = reap_tasks(tasks, taskCount, false);

            // Update running task count
            runningTasks = count_running_tasks(tasks, taskCount);

            // Handle abort conditions
            if ((anyFailed && options->abortOnError) || interrupted) 
            {
                if (runningTasks > 0) 
                {
                    // Send SIGTERM or SIGINT to running tasks
                    terminate_tasks(tasks, taskCount,
                            interrupted ? SIGINT : SIGTERM);

                    // Wait up to one second for tasks to terminate
                    wait_for_one_second();

                    reap_tasks(tasks, taskCount, false);

                    runningTasks = count_running_tasks(tasks, taskCount);

                   if (runningTasks > 0) 
                   {
                        terminate_tasks(tasks, taskCount, SIGKILL);
                        reap_tasks(tasks, taskCount, true);
                   }
                }

               if (nextTask < taskCount || runningTasks > 0) 
               {
                    if (interrupted) {
                        fprintf(stderr,
                                "uqparallel: aborting due to interruption\n");
                    }
                    else {
                        fprintf(stderr,
                                "uqparallel: execution failure - aborting\n");
                    }
                }
               // Free tasks
                free_tasks(tasks, taskCount);

                // Exit with appropriate status
                if (interrupted) {
                    exit(EXIT_INTERRUPTED);
                } 
                else {
                    // Get the status of the task that failed
                    for (int i = 0; i < taskCount; i++) {
                        if (tasks[i]->completed) {
                            if (WIFEXITED(tasks[i]->status)) {
                                int status = WEXITSTATUS(tasks[i]->status);
                                if (status != 0) {
                                    exit(status);
                                }
                            } else if (WIFSIGNALED(tasks[i]->status)) {
                                exit(EXIT_SIGNAL_TERMINATION);
                            }
                        }
                    }
                    exit(1); // Default error exit code
                }
            }
        }

        // Exit with status of last command if we get here
        int exitStatus = 0;
        //REF:charGPT help me recode the exit status part
        // Find the exit status of the last task
        for (int i = taskCount - 1; i >= 0; i--) {
            if (tasks[i]->completed) {
                if (WIFEXITED(tasks[i]->status)) {
                    exitStatus = WEXITSTATUS(tasks[i]->status);
                } else if (WIFSIGNALED(tasks[i]->status)) {
                    exitStatus = EXIT_SIGNAL_TERMINATION;
                }
               break;
            }
        }
        free_tasks(tasks, taskCount);

        exit(exitStatus);
    }
}