fish/fish_shell/fish_core.c

//
// Created by Antoine Bartuccio on 11/05/2017.
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include "fish_core.h"

#define FISH_BUFFER_SIZE 1024
#define FISH_TOKENS " \t\r\n\a"

void fishLoop(Settings * settings){
    char * line = NULL;
    WordArray * splited = NULL;
    int status = 1;

    do {
        printf("%s", settings->PS1);
        line = fishReadLine();
        line = fishExpand(line);

        splited = split(line, FISH_TOKENS);

        status = fishExecute(splited);

        freeWordArray(splited);
        free(line);
    } while(status);
}

int countSeparators(char *string, char *separators) {
    int nb = 0;
    int i = 0;
    int k = 0;
    while (string[i] != '\0'){
        while (separators[k] != '\0'){
            if (string[i] == separators[k]){
                nb++;
            }
            k++;
        }
        i++;
        k = 0;
    }
    return nb;
}

WordArray * split(char *string, char *separator){
    int array_size = countSeparators(string, separator) + 1;
    WordArray *tokens = (WordArray*) malloc(sizeof(WordArray));
    char *to_delete = strdup(string);
    char *token = NULL;
    int i = 0;

    if (tokens != NULL){
        tokens->words = (char **) malloc(sizeof(char*) * (array_size + 1));
        tokens->words[array_size] = NULL;
        tokens->size = array_size;
    }

    if (tokens == NULL || to_delete == NULL || tokens->words == NULL){
        fprintf(stderr, "fish: Error allocating fucking pointer !");
        exit(EXIT_FAILURE);
    }

    while((token = strsep(&to_delete, separator)) != NULL){
        tokens->words[i] = strdup(token);
        i++;
    }

    free(to_delete);

    return tokens;
}

void freeWordArray(WordArray *array) {
    int i;
    if (array != NULL) {
        for (i = 0; i < array->size; i++) {
            free(array->words[i]);
        }
        free(array);
    }

}

char *fishReadLine() {
    size_t bufferSize = FISH_BUFFER_SIZE;
    int position = 0;
    char *line = malloc(sizeof(char*) * bufferSize);
    int c;

    if (line == NULL){
        fprintf(stderr, "fish: Error allocating fucking buffer shit !");
        exit(EXIT_FAILURE);
    }

    while (1){
        c = getchar();

        switch (c){
            case '\n':
                line[position] = '\0';
                return line;
            case EOF:
                exit(EXIT_SUCCESS);
            default:
                line[position] = (char) c;
        }

        position++;

        if ((size_t) position > bufferSize){
            bufferSize+=bufferSize;
            line = realloc(line, bufferSize);
            if (line == NULL){
                fprintf(stderr, "fish: Error allocating fucking buffer shit !");
                exit(EXIT_FAILURE);
            }
        }
    }


    return NULL;
}

char *fishExpand(char *line) {
    return line;
}

Settings *getSettings() {
    Settings *s = (Settings*) malloc(sizeof(Settings));
    if (s == NULL){
        fprintf(stderr, "fish: Error allocating fucking settings");
        exit(EXIT_FAILURE);
    }
    s->PS1 = strdup("\n~>");

    return s;
}

int fishLoad(WordArray *array) {
    pid_t pid;
    int status;

    pid = fork();
    if (pid == 0){
        /* Executes only in the child process */
        if (execvp(array->words[0], array->words) == -1){
            /* Error during system call */
            perror("fish");
        }
        exit(EXIT_FAILURE);
    } else if (pid < 0){
        /* Fork failed */
        perror("fish");
    } else {
        /* Handle parent process */

        /* Wait for the child process to finish */
        do {
            waitpid(pid, &status, WUNTRACED);
        } while (!WIFEXITED(status) && !WIFSIGNALED(status));
    }

    return 1;
}

int fishExecute(WordArray *array) {
    int i;
    if (array->size < 0)
        return 1;

    for (i=0; i < getNbBuiltins(); i++){
        if (!strcmp(array->words[0], getBuiltinCommandsStr()[i])){
            return getBuiltinCommands()[i](array);
        }
    }

    return fishLoad(array);
}