path: root/src/build.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>

#include <libgen.h> /* dirname(), basename() */

#include "build.h"
#include "util.h"
#define __FILENAME__ "build.c"
#include "dbg.h"

/* TODO: more useful return codes? */

const char do_file_ext[] = ".do";
const char default_name[] = "default";
const char temp_ext[] = ".redoing.tmp";

int build_target(const char *target) {
    assert(target);

    int retval = 0;
    printf("redo  %s\n", target);

    /* get the do-file which we are going to execute */
    char *do_file = get_do_file(target);
    if (do_file == NULL) {
        if (file_exists(target)) {
            /* if our target file has no do file associated but exists,
               then we treat it as a source */
            /* TODO: write dependencies */
            goto exit;
        }
        fprintf(stderr, "%s couldn't be built because no "
                "suitable do-file exists\n", target);
        retval = 1;
        goto exit;
    }

    debug("Using do-file %s\n", do_file);

    char *temp_output = concat(2, target, temp_ext);

    pid_t pid = fork();
    if (pid == -1) {
        /* failure */
        fatal("redo: failed to fork() new process");
    } else if (pid == 0) {
        /* child */

        /* change directory to our target */
        char *dirc = ec_strdup(target);
        char *dtarget = dirname(dirc);
        if (chdir(dtarget) == -1)
            fatal("redo: failed to change directory to %s", dtarget);

        free(dirc);

        /* target is now in the cwd so change path accordingly */
        char *btarget = xbasename(target);
        char *bdo_file = xbasename(do_file);

        /* read and parse shebang */
        FILE *fp = fopen(bdo_file, "rb+");
        if (!fp)
            fatal("redo: failed to open %s", bdo_file);

        const size_t bufsize = 1024;
        char buf[bufsize];

        buf[ fread(buf, 1, sizeof(buf)-1, fp) ] = '\0';
        if (ferror(fp))
            fatal("redo: failed to read from %s", bdo_file);

        fclose(fp);

        char **argv;
        size_t i = 0;
        if (buf[0] == '#' && buf[1] == '!') {
            argv = parsecmd(&buf[2], &i, 5);
        } else {
            argv = ec_malloc(7 * sizeof(char*));
            argv[i++] = "/bin/sh";
            argv[i++] = "-e";
        }

        argv[i++] = bdo_file;
        argv[i++] = (char*) btarget;
        char *basename = remove_ext(btarget);
        argv[i++] = basename;
        argv[i++] = temp_output;
        argv[i] = NULL;

        execv(argv[0], argv);

        /* execv should never return */
        fatal("redo: failed to replace the child process with %s", argv[0]);
    }

    /* parent */
    int returncode;
    waitpid(pid, &returncode, 0);
    bool remove_temp = true;

    if (WIFEXITED(returncode)) {
        if (0 != returncode) {
            fprintf(stderr, "redo: invoked do-file %s failed with %d\n",
                    do_file, WEXITSTATUS(returncode));
        } else {
            /* successfull */

            /* if the file is 0 bytes long we delete it */
            off_t f_size = fsize(temp_output);
            if (f_size == -1) {
                if (errno != ENOENT)
                    fatal("redo: failed to determine the size of %s", temp_output);
            } else if (f_size)
                remove_temp = false;
        }
    } else {
        /* something very wrong happened with the child */
        fprintf(stderr, "redo: invoked do-file did not terminate correctly\n");
    }

    if (remove_temp) {
        if (remove(temp_output))
            if (errno != ENOENT)
                fatal("redo: failed to remove %s", temp_output);
    } else {
        if (rename(temp_output, target))
            fatal("redo: failed to rename %s to %s", temp_output, target);
    }

    free(temp_output);
 exit:
    free(do_file);

    return retval;
}

/* Returns the right do-file for target */
char *get_do_file(const char *target) {
    assert(target);
    /* target + ".do" */
    char *temp = concat(2, target, do_file_ext);
    if (file_exists(temp))
        return temp;
    free(temp);

    /* default + get_extension(target) + ".do" */
    temp = concat(3, default_name, take_extension(target), do_file_ext);
    if (file_exists(temp))
        return temp;
    free(temp);

    /* Redofile */
    temp = strdup("Redofile");
    if (file_exists(temp))
        return temp;
    free(temp);

    return NULL;
}

/* Returns the extension of the target or the empty string if none was found */
char *take_extension(const char *target) {
    assert(target);
    char *temp = strrchr(target, '.');
    if (temp)
        return temp;
    else {
        return "";
    }
}

/* Checks if target exists and prints a debug message if access() failed
   except if it failed with ENOENT. */
bool file_exists(const char *target) {
    assert(target);
    if (!access(target, F_OK))
        return true;
    if (errno != ENOENT)
        debug("Failed to access %s: %s\n", target, strerror(errno));
    return false;
}

/* Returns a new copy of str with the extension removed, where the extension is
   everything behind the last dot, including the dot. */
char *remove_ext(const char *str) {
    assert(str);
    size_t len;
    char *ret, *dot = NULL;

    for (len = 0; str[len]; ++len)
        if (str[len] == '.')
            dot = (char*) &str[len];

    if (dot) /* recalculate length to only reach just before the last dot */
        len = dot - str;

    ret = ec_malloc(len+1);
    memcpy(ret, str, len);
    ret[len] = '\0';

    return ret;
}

/* Breaks cmd at spaces and stores a pointer to each argument in the returned
   array. The index i is incremented to point to the next free pointer. The
   returned array is guaranteed to have at least keep_free entries left */
char **parsecmd(char *cmd, size_t *i, size_t keep_free) {
    assert(cmd);
    size_t argv_len = 16;
    char **argv = ec_malloc(argv_len * sizeof(char*));
    size_t j = 0;
    bool prev_space = true;
    for (;; ++j) {
        switch (cmd[j]) {
        case ' ':
            cmd[j] = '\0';
            prev_space = true;
            break;
        case '\n':
        case '\r':
            cmd[j] = '\0';
        case '\0':
            return argv;
        default:
            if (!prev_space)
                break;
            /* check if we have enough space */
            while (*i+keep_free >= argv_len) {
                argv_len *= 2;
                debug("Reallocating memory (now %zu)\n", argv_len);
                /* TODO: replace realloc? */
                char **new_ptr = realloc(argv, argv_len * sizeof(char*));
                if (!new_ptr)
                    fatal("redo: couldn't realloc %zu bytes",
                          argv_len * sizeof(char*));
                argv = new_ptr;
            }

            prev_space = false;
            argv[*i] = &cmd[j];
            ++*i;
        }
    }
}

/* Returns the size of fn */
off_t fsize(const char *fn) {
    struct stat st;

    if (stat(fn, &st))
        return -1;

    return st.st_size;
}