runall.cpp

Go to the documentation of this file.

 
#include <assert.h>     /* for assert() */
#include <errno.h>      /* for errno */
#include <stdlib.h>     /* for exit(), free() */
#include <string.h>     /* for memcpy(), ... */
#include <stdio.h>      /* for FILE, fopen(), ... */
 
#include <ctype.h>      /* for isspace */
#include <limits.h>     /* for PATH_MAX */
#include <sys/types.h>
#include <sys/stat.h>
#ifndef _WIN32
#  include <sys/wait.h>   /* for WIFEXITED(), ... */
#endif
 
#include "cmdopt.h"
#include "display.h"
#include "exec.h"
#include "output.h"
#include "util.h"
 
#include "target.h"
 
#ifndef ENOENT
#  define ENOENT 2
#endif   /* ENOENT */
 
#ifndef S_IXUSR
#  define S_IXUSR 0100
#endif   /* S_IXUSR */
 
#ifndef S_IXGRP
#  define S_IXGRP 0010
#endif   /* S_IXGRP */
 
#ifndef S_IXOTH
#  define S_IXOTH 0001
#endif   /* S_IXOTH */
 
#if !defined (PATH_MAX) || PATH_MAX < 128 || 4096 < PATH_MAX
   // deal  with undefined, bogus, or excessive values
#  undef  PATH_MAX
#  define PATH_MAX   1024
#endif
 
static char**
merge_argv (const char* target, char* const argv [])
{
    size_t tlen;
    char ** split;
    unsigned i, arg_count = 0, spl_count = 0, wld_count = 0;
 
    assert (0 != target);
    assert (0 != argv);
 
    tlen = strlen (target);
    split = split_opt_string (target);
 
    /* If the split of target only contains a single value, we may have a 
     bare executable name */
    if (!split [1]) {
        /* Check if last character in the target is whitespace */
        if (isspace (target [tlen])) {
            /* If it is, we've got a complex executable with no arguments.
               Therfore, return it as is.
            */
            return split;
        } /* Otherwise, it's a bare executable, so append argv */
 
        /* Figure out how many arguments we've got in argv*/
        for (/* none */; argv [arg_count]; ++arg_count);
 
        /* reallocate memory for copying them, extending the buffer */
        split = (char**)RW_REALLOC (split, (arg_count + 2) * sizeof (char*));
            
        /* And copy the pointers */
        for (i=0; i < arg_count; ++i)
            split [i+1] = argv [i];
 
        /* Then terminate the array*/
        split [++i] = (char*)0;
 
        return split;
    } /* Otherwise, it's a complex executable with 1 or more arguments */
 
    /* Figure out how many instances of '%x' we've got */
    for (spl_count = 1; split [spl_count]; ++spl_count) {
        if ('%' == split [spl_count][0] && 'x' == split [spl_count][1] 
            && '\0' == split [spl_count][2])
            ++wld_count;
    }
 
    /* If we don't have any instances of '%x', we have a valid argv array, 
       so return it as it is.
    */
    if (0 == wld_count)
        return split;
 
    /* Now we need to determine how large the argv array is */
    for (/* none */; argv [arg_count]; ++arg_count);
 
    if (0 == arg_count) {
        /* We want to shrink the array, removing the '%x' terms*/
        unsigned found = 0;
        for (i = 1; i <= spl_count; ++i) {
            if (split [i] && '%' == split [i][0] && 'x' == split [i][1] 
                && '\0' == split [i][2])
                ++found;
            else
                split [i - found] = split [i];
        }
    }
    else if (1 == arg_count) {
        /* We need to replace all the %x terms with argv [0] */
        
        for (i = 1; i < spl_count; ++i) {
            if ('%' == split [i][0] && 'x' == split [i][1] 
                && '\0' == split [i][2])
                split [i] = argv [0];
        }
    }
    else {
        /* We need to resize the split array to hold the insertion (s) */
        /* First, we realloc the array */
        const unsigned new_len = spl_count + (arg_count - 1) * wld_count;
        split = (char**)RW_REALLOC (split, sizeof (char**) * new_len);
 
        /* Then we itterate backwards through the split array, transcribing 
           elements as we go.  We have to go backwards, so we don't clobber
           data in the process.
        */
        for (/* none */; wld_count; --spl_count) {
            if (split [spl_count] && '%' == split [spl_count][0] 
                && 'x' == split [spl_count][1] 
                && '\0' == split [spl_count][2]) {
                --wld_count;
                for (i = arg_count; i; --i) {
                    split [spl_count + (arg_count - 1) * wld_count + i - 1] = 
                        argv [i - 1];
                }
            }
            else
                split [spl_count + (arg_count - 1) * wld_count] = 
                    split [spl_count];
        }
    }
    return split;
}
 
#define READ_BUF_LEN 64
 
static
void count_warnings (const char* const target, unsigned* counter, 
                     const char* const match)
{
    size_t path_len;
    char* tmp_name;
    FILE* data;
 
    assert (0 != target);
    assert (0 != counter);
 
    if (0 == match)
        return; /* Don't have a match string, so don't tally warnings */
 
    path_len = strlen (target);
    tmp_name = (char*)RW_MALLOC (path_len + 5);
    memcpy (tmp_name, target, path_len + 1);
    strcat (tmp_name,".log");
 
    data = fopen (tmp_name, "r");
    if (data) {
        size_t pos = 0, limit = strlen (match);
        while (!feof (data)) {
            char buf [READ_BUF_LEN];
            size_t nread;   /* bytes read */
 
            /* First, read a block from the file into the buffer */
            nread = fread (buf, 1, sizeof buf, data);
            if (ferror (data)) {
                warn ("Error reading %s: %s\n", tmp_name, strerror (errno));
                break;
            }
 
            /* Then, look for the search string within it. */
            for (size_t i = 0; i < nread; ++i) {
                if (buf [i] != match [pos])
                    pos = 0;
                else if (++pos == limit) {
                    pos = 0;
                    ++*counter;
                }
            }
        }
 
        fclose (data);
    }
    else if (ENOENT != errno)
        warn ("Error opening %s: %s\n", tmp_name, strerror (errno));
 
    free (tmp_name);
}
 
static int
check_target_ok (const char* target, struct target_status* status)
{
    struct stat file_info;
    int exists = 1;
    size_t path_len;
    char* tmp_name;
 
    assert (0 != target);
    assert (0 != status);
 
    path_len = strlen (target);
 
#ifndef _WIN32
    /* Otherwise, check for the .o file on non-windows systems */
    tmp_name = (char*)RW_MALLOC (path_len + 3);
    memcpy (tmp_name, target, path_len + 1);
    strcat (tmp_name,".o");
#else
    /* Or the target\target.obj file on windows systems*/
    {
        const char* const target_name = get_target ();
        size_t target_len = strlen (target_name);
        size_t tmp_len = path_len + target_len - 2;
        /* - 2 comes from removing 4 characters (extra .exe) and adding 2 
           characters (\ directory seperator and trailing null) */
        tmp_name = (char*)RW_MALLOC (tmp_len);
        memcpy (tmp_name, target, path_len - 4);
        tmp_name [path_len - 4] = default_path_sep;
        memcpy (tmp_name + path_len - 3, target_name, target_len);
        tmp_name [tmp_len - 4] = 'o';
        tmp_name [tmp_len - 3] = 'b';
        tmp_name [tmp_len - 2] = 'j';
        tmp_name [tmp_len - 1] = '\0';
    }
#endif   /* _WIN32 */
 
    count_warnings (target, &status->l_warn, "warning:");
    count_warnings (tmp_name, &status->c_warn, "warning:");
 
    if (0 > stat (target, &file_info)) {
        if (ENOENT != errno) {
            warn ("Error stating %s: %s\n", target, strerror (errno));
            status->status = ST_SYSTEM_ERROR;
            free (tmp_name);
            return 0;
        }
        file_info.st_mode = 0; /* force mode on non-existant file to 0 */
        exists = 0; /* note that it doesn't exist */
    }
 
    if (0 == (file_info.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
        /* This is roughly equivlent to the -x bash operator.
           It checks if the file can be run, /not/ if we can run it
        */
 
#if 0 /* Disable .o target check as unused */
        /* If target is a .o file, check if it exists */
        if ('.' == target [path_len-1] && 'o' == target [path_len]) {
            if (!exists)
                status->status = ST_COMPILE;
            free (tmp_name);
            return 0;
        }
#endif
            
        /* If the target exists, it doesn't have valid permissions */
        if (exists) {
            status->status = ST_EXECUTE_FLAG;
            free (tmp_name);
            return 0;
        }
 
        if (0 > stat (tmp_name, &file_info)) {
            if (ENOENT != errno) {
                warn ("Error stating %s: %s\n", tmp_name, strerror (errno));
                status->status = ST_SYSTEM_ERROR;
            }
            else
                status->status = ST_COMPILE;
        }
        else {
            status->status = ST_LINK;
        }
                
        free (tmp_name);
        return 0;
    }
    free (tmp_name);
    return 1;
}
 
static const char*
rw_basename (const char* path)
{
    const char *pos, *mark;
 
    assert (0 != path);
 
    for (mark = pos = path; '\0' != *pos; ++pos)
#ifndef _WIN32
        mark = (default_path_sep == *pos) ? pos + 1 : mark;
#else
        mark = (default_path_sep == *pos || '/' == *pos) ? pos + 1 : mark;
#endif   /* _WIN32 */
 
    return mark;
}
 
static const char* target_name;
 
const char* get_target ()
{
    return target_name;
}
 
static void
run_target (struct target_status     *summary,
            const char               *target,
            const struct target_opts *target_template)
{
    struct target_opts options;
    struct target_status results;
 
    assert (0 != target);
    assert (0 != target_template);
    assert (0 != target_template->argv);
 
    memcpy (&options, target_template, sizeof options);
    memset (&results, 0, sizeof results);
 
    /* create the argv array for this target */
    options.argv = merge_argv (target, options.argv);
 
    assert (0 != options.argv);
    assert (0 != options.argv [0]);
 
    target_name = rw_basename (options.argv [0]);
 
    /* create the names of files to redirect stdin and stdout */
    options.infname  = input_name (options.data_dir, target_name);
    options.outfname = output_name (options.argv [0]);
 
    print_target (&options);
 
    if (check_target_ok (options.argv [0], &results)) {
        exec_file (&options, &results);
        if (0 == results.exit && 0 == results.signaled)
            parse_output (&options, &results);
    }
 
    print_status (&results);
 
    if (summary) {
        /* increment summary counters */
        if (0 == results.signaled && results.exit)
            ++summary->exit;
 
        /* add cumulative times (when valid) */
        if (results.usr_time != (clock_t)-1)
            summary->usr_time += results.usr_time;
 
        if (results.sys_time != (clock_t)-1)
            summary->sys_time += results.sys_time;
 
        if (results.wall_time != (clock_t)-1)
            summary->wall_time += results.wall_time;
 
        summary->signaled += results.signaled;
        summary->c_warn   += results.c_warn;
        summary->l_warn   += results.l_warn;
        summary->t_warn   += results.t_warn;
 
        if ((unsigned)-1 != results.assert) {
            /* increment assertion counters only when they're valid */
            summary->assert += results.assert;
            summary->failed += results.failed;
        }
    }
 
    /* free data dynamically allocated for this target alone */
    free (options.argv [0]);
    free (options.argv);
    free ((char*)options.infname);
    free ((char*)options.outfname);
}
 
 
int
main (int argc, char *argv [])
{
    struct target_opts target_template;
    const char* exe_opts = "";
    const char* const* const saved_argv = (const char* const*)argv;
 
    exe_name = argv [0];
 
    if (1 < argc && '-' == argv [1][0]) {
        const int nopts =
            eval_options (argc, argv, &target_template, &exe_opts);
 
        if (0 > nopts)
            return 1;
 
        argc -= nopts;
        argv += nopts;
    }
    else {
        /* initialize data members */
        memset (&target_template, 0, sizeof target_template);
 
        --argc;
        ++argv;
    }
 
    /* set the program output mode */
    if (target_template.verbose)
        set_output_format (FMT_VERBOSE);
    else
        set_output_format (FMT_PLAIN);
 
    if (0 < argc) {
        struct target_status summary;
 
        int i;
 
        target_template.argv = split_opt_string (exe_opts);
 
        assert (0 != target_template.argv);
 
        /* print out the program's argv array in verbose mode */
        print_header (target_template.verbose ? saved_argv : 0);
 
        memset (&summary, 0, sizeof summary);
 
        /* number of program's executed */
        int progs_count = 0;
 
        for (i = 0; i < argc; ++i) {
            const char* target = argv [i];
 
            if ('@' == target [0]) {
                /* read targets from specified file */
                const char* lst_name = target + 1;
                FILE* lst = fopen (lst_name, "r");
                if (0 == lst) {
                    warn ("Error opening %s: %s\n", lst_name, strerror (errno));
                    break;
                }
 
                while (!feof (lst)) {
                    char buf [PATH_MAX];
                    target = fgets (buf, int (sizeof buf), lst);
 
                    if (ferror (lst)) {
                        warn ("Error reading %s: %s\n", lst_name, strerror (errno));
                        break;
                    }
 
                    if (target) {
                        /* remove terminating newline character if present */
                        assert (buf == target);
                        if (char* pos = strchr (buf, '\n'))
                            *pos = '\0';
                        if (*target) {
                            ++progs_count;
                            run_target (&summary, target, &target_template);
                        }
                    }
                }
 
                fclose (lst);
            }
            else {
                ++progs_count;
                run_target (&summary, target, &target_template);
            }
        }
 
        print_footer (progs_count, &summary);
 
        if (target_template.argv [0])
            free (target_template.argv [0]);
        free (target_template.argv);
    }
 
    free (target_template.core);
    free (target_template.cpu);
    free (target_template.data);
    free (target_template.fsize);
    free (target_template.nofile);
    free (target_template.stack);
    free (target_template.as);
 
    return 0;
}