args.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004, 2006 Symbian Software Ltd.                        *
 *   All rights reserved.                                                  *
 *   Copyright (C) 2007-2011 Mike Kinghan, imk@strudl.org                  *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@strudl.org                *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Symbian Software Ltd. nor the names of its        *
 *   contributors may be used to endorse or promote products derived from  *
 *   this software without specific prior written permission.              *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include "platform.h"
#include "args.h"
#include "report.h"
#include "contradiction.h"
#include "io.h"
#include "line_despatch.h"
#include "configured_symbols.h"
#include "filesys.h"
#include "dataset.h"



STATE_DEF(args)
{
    INCLUDE_PUBLIC(args);
    ptr_vector_h argfile_argv;
    char        *memfile;
    int arg_dirs_ignored;
}
STATE_T(args);

IMPLEMENT(args,USER_INITABLE)


DEFINE_USER_INIT(args)(STATE_T(args) * args_st)
{
    args_st->argfile_argv = ptr_vector_new(NULL,NULL);
}

DEFINE_USER_FINIS(args)(STATE_T(args) * args_st)
{
    ptr_vector_dispose((SET_STATE(args,argfile_argv)));
    SET_STATE(args,argfile_argv) = NULL;
}

#define PROGRESS_GAGGED() \
((GET_PUBLIC(args,diagnostic_filter) & MSGCLASS_PROGRESS) != 0)


enum option_codes {
    OPT_FILE = 'f',             
    OPT_REPLACE = 'r',          
    OPT_BACKUP = 'b',           
    OPT_DEF = 'D',                      
    OPT_UNDEF = 'U',            
    OPT_CONFLICT = 'x',         
    OPT_GAG = 'g',                      
    OPT_VERBOSE = 'V',          
    OPT_COMPLEMENT = 'c',       
    OPT_DEBUG = 1,                      
    OPT_EVALCONSTS = 'E',       
    OPT_DISCARD = 'k',          
    OPT_LINE = 2,                       
    OPT_POD = 'P',                      
    OPT_RECURSE = 'R',          
    OPT_FILTER = 'F',           
    OPT_KEEPGOING = 'K',        
    OPT_IFS = 'i',                      
    OPT_DEFS = 'd',                     
    OPT_UNDEFS = 'u',           
    OPT_INCLUDES = 3,       
    OPT_LOCATE = 'L',           
    OPT_ONCE = 'o',                     
    OPT_SYSTEM = 's',           
    OPT_LOCAL = 'l',            
    OPT_ACTIVE = 'A',           
    OPT_INACTIVE = 'I',         
    OPT_EVALSYMS = 'e',         
    OPT_IMPLICIT = 'm'          
};

static struct option long_options [] = {
    { "file", required_argument, NULL, OPT_FILE },
    { "replace",no_argument, NULL, OPT_REPLACE },
    { "backup",required_argument,NULL,OPT_BACKUP},
    { "define", required_argument, NULL, OPT_DEF },
    { "undef", required_argument, NULL, OPT_UNDEF },
    { "conflict", required_argument, NULL, OPT_CONFLICT },
    { "gag", required_argument, NULL, OPT_GAG },
    { "verbose", no_argument, NULL, OPT_VERBOSE },
    { "complement", no_argument, NULL, OPT_COMPLEMENT },
    { "debug", no_argument, NULL, OPT_DEBUG },
    { "evalconsts", no_argument, NULL, OPT_EVALCONSTS },
    { "discard", required_argument, NULL, OPT_DISCARD },
    { "line", no_argument, NULL, OPT_LINE },
    { "pod", no_argument, NULL, OPT_POD },
    { "recurse", no_argument, NULL, OPT_RECURSE },
    { "filter", required_argument, NULL, OPT_FILTER },
    { "keepgoing", no_argument, NULL, OPT_KEEPGOING },
    { "ifs", no_argument, NULL, OPT_IFS },
    { "defs", no_argument, NULL, OPT_DEFS },
    { "undefs", no_argument, NULL, OPT_UNDEFS },
    { "includes", no_argument, NULL, OPT_INCLUDES },
    { "locate", no_argument, NULL, OPT_LOCATE },
    { "once", no_argument, NULL, OPT_ONCE },
    { "system", no_argument, NULL, OPT_SYSTEM },
    { "local", no_argument, NULL, OPT_LOCAL },
    { "active", no_argument, NULL, OPT_ACTIVE },
    { "inactive", no_argument, NULL, OPT_INACTIVE },
    { "evalsyms", no_argument, NULL, OPT_EVALSYMS },
    { "implicit", no_argument, NULL, OPT_IMPLICIT },
    { 0, 0, 0, 0 }
};

static char opts[(sizeof(long_options)/sizeof(struct option)) * 3];

static struct cmd_option commands [] = {
    { "help", CMD_HELP, CMD_HELP_MASK },
    { "-h", CMD_HELP, CMD_HELP_MASK },
    { "--help", CMD_HELP, CMD_HELP_MASK },
    { "version", CMD_VERSION, CMD_VERSION_MASK },
    { "-v", CMD_VERSION, CMD_VERSION_MASK },
    { "--version", CMD_VERSION, CMD_VERSION_MASK },
    { "source", CMD_SOURCE, CMD_SOURCE_MASK },
    { "symbols", CMD_SYMBOLS, CMD_SYMBOLS_MASK },
    { "includes", CMD_INCLUDES, CMD_INCLUDES_MASK },
    { "defs", CMD_DEFS, CMD_DEFS_MASK },
    { "pragmas", CMD_PRAGMAS, CMD_PRAGMAS_MASK },
    { "errors", CMD_ERRORS, CMD_ERRORS_MASK },
    { "directives", CMD_DIRECTIVES, CMD_DIRECTIVES_MASK },
    { 0, 0 }
};

static int const source_cmd_exclusions[] = {
    OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES, OPT_LOCATE,
    OPT_ONCE, OPT_SYSTEM, OPT_LOCAL, OPT_ACTIVE, OPT_INACTIVE,
    OPT_EVALSYMS, 0
};
static int const symbols_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_SYSTEM,
    OPT_LOCAL, OPT_BACKUP, OPT_COMPLEMENT, 0
};
static int const includes_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_BACKUP,
    OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES, OPT_COMPLEMENT, OPT_EVALSYMS, 0
};
static int const directives_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_BACKUP,
    OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES, OPT_COMPLEMENT, OPT_EVALSYMS, 0
};
static int const defs_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_BACKUP,
    OPT_SYSTEM, OPT_LOCAL, OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES,
    OPT_COMPLEMENT, OPT_EVALSYMS, 0
};
static int const pragmas_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_BACKUP,
    OPT_SYSTEM, OPT_LOCAL, OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES,
    OPT_COMPLEMENT, OPT_EVALSYMS, 0
};
static int const errors_cmd_exclusions[] = {
    OPT_REPLACE, OPT_CONFLICT, OPT_DISCARD, OPT_LINE, OPT_BACKUP,
    OPT_SYSTEM, OPT_LOCAL, OPT_IFS, OPT_DEFS, OPT_UNDEFS, OPT_INCLUDES,
    OPT_COMPLEMENT, OPT_EVALSYMS, 0
};



static struct exclusion_list const cmd_exclusion_lists[] = {
    /* Dummy 0th element*/
    {   0, NULL },
    /* Exclusion list for the help command*/
    {   CMD_HELP, NULL },
    /* Exclusion list the version command*/
    {   CMD_VERSION, NULL },
    /* Exclusion list the code command*/
    {   CMD_SOURCE, source_cmd_exclusions},
    /* Exclusion list for the symbols command*/
    {   CMD_SYMBOLS, symbols_cmd_exclusions },
    /* Exclusion list for the includes command*/
    {   CMD_INCLUDES, includes_cmd_exclusions },
    /* Exclusion list for the defs command*/
    {   CMD_DEFS, defs_cmd_exclusions },
    /* Exclusion list for the pragmas command*/
    {   CMD_PRAGMAS, pragmas_cmd_exclusions },
    /* Exclusion list for the pragmas command*/
    {   CMD_ERRORS, errors_cmd_exclusions },
    /* Exclusion list for the directives command*/
    {   CMD_DIRECTIVES, directives_cmd_exclusions },
    { 0, NULL }
};

static void
make_opts_list(void)
{
    struct option * longopt = long_options;
    char *opts_str = opts;
    for (       ; longopt->name; ++longopt, ++opts_str) {
        *opts_str = longopt->val;
        switch(longopt->has_arg) {
        case no_argument:
            break;
        case optional_argument:
            ++opts_str;
            *opts_str = ':';
            /* Yes, fall through */
        case required_argument:
            ++opts_str;
            *opts_str = ':';
            break;
        default:
            assert(0);
        }
    }
}


static void
usage(FILE * fp)
{
    const char *prog_name = GET_PUBLIC(args,prog_name);

    fprintf(fp,"usage:\n"
            "%s COMMAND [OPTION... [FILE...]]\n"
            "1. %s { help | --help | -h }\n"
            "\tDisplay this message and exit.\n"
            "2. %s { version | --version | -v }\n"
            "\tDisplay version information and exit.\n"
            "3. %s source OPTION... [FILE...]\n"
            "\tSimplify source FILEs in accordance with OPTIONs, "
            "parsing in the manner of the C preprocessor.\n"
            "\tInput lines may be dropped from output. Truth functional directives "
            "may be simplified on output.\n"
            "4. %s symbols OPTION... [FILE...]\n"
            "\tList preprocessor symbols from FILEs in accordance with "
            "OPTIONs, parsing in the manner of the C preprocessor.\n"
            "5. %s includes OPTION... [FILE...]\n"
            "\tList #includes fom FILEs in accordance with OPTIONs, parsing in "
            "the manner of the C preprocessor\n"
            "6. %s defs OPTION... [FILE...]\n"
            "\tList #defines and #undefs fom FILEs in accordance with OPTIONs, "
            "parsing in the manner of the C preprocessor.\n"
            "7. %s pragmas OPTION... [FILE...]\n"
            "\tList #pragmas fom FILEs in accordance with OPTIONs, parsing in the "
            "manner of the C preprocessor\n"
            "8. %s directives OPTION... [FILE...]\n"
            "\tList #-directives fom FILEs in accordance with OPTIONs, "
            "parsing in the manner of the C preprocessor. "
            "(Directives are #includes, #defines, #undefs, "
            "#pragmas, #errors).\n"
            "General OPTIONS:\n"
            "\t-fARGFILE, --file ARGFILE\n"
            "\t\tRead other arguments from ARGFILE.\n"
            "\t-R, --recurse\n"
            "\t\tRecurse into directories to find input files.\n"
            "\t-FEXT1[,EXT2...]\n"
            "\t--filter EXT1[,EXT2...]\n"
            "\t\tProcess only input files that have one of the file extensions "
            "EXT1,EXT2...\n"
            "\t-DSYM[=VAL], --define SYM[=VAL]\n"
            "\t\tAssume symbol SYM to be defined [=VAL]\n"
            "\t-USYM, --undef SYM\n"
            "\t\tAssume symbol SYM to be undefined.\n"
            "\t-m, --implicit\n"
            "\t\tAssume that any symbol that is not --define-ed is implicitly --undef-ed.\n"
            "\t-g{p|i|w|e|a},\n"
            "\t--gag { progress| info | warning | error | abend }\n"
            "\t\tSuppress diagnostics no worse than "
            "{progress | info | warning | error | abend}.\n"
            "\t-gs, --gag summary\n"
            "\t\tSuppress summary diagnostics at exit.\n"
            "\t\t(Default: -gp -gi -gs)\n"
            "\t-V, --verbose\n"
            "\t\tOutput all diagnostics.\n"
            "\t--debug\n"
            "\t\tDisplay debugging info.\n"
            "\t-K, --keepgoing\n"
            "\t\tIf a parse error is encountered in an input file, continue "
            "processing subsequent input files.\n"
            "\t-P, --pod\n"
            "\t\tApart from #-directives, input is Plain Old Data.\n"
            "\t\tComments and quotations will not be parsed.\n"
            "\t-E, --evalconsts\n"
            "\t\tEvaluate constants occurring as truth-functional operands #ifs. "
            "By default constants as truth-functional operands are not evaluated.\n"
            "source OPTIONs:-\n"
            "\t-r, --replace\n"
            "\t\tOverwrite input file with output file. Implied by --recurse\n"
            "\t\tWith -r, stdin supplies the input *filenames*.\n"
            "\t\tOtherwise stdin supplies an input *file*; "
            "the output file is stdout.\n"
            "\t-BSUFFIX, --backup SUFFIX\n"
            "\t\tBackup each input file by appending SUFFIX to the name.\n"
            "\t\tApplies only with -r.\n"
            "\t-kd, --discard drop\n"
            "\t\tDrop discarded lines from output.\n"
            "\t-kb, --discard blank\n"
            "\t\tBlank discarded lines on output.\n"
            "\t-kc, --discard comment\n"
            "\t\tComment out discarded lines on output.\n"
            "\t-xd, --conflict delete\n"
            "\t\tDelete #defines and #undefs that contradict -D or -U options.\n"
            "\t-xc, --conflict comment\n"
            "\t\tInsert diagnostic comments on contradictions as per -xd. "
            "(Default.)\n"
            "\t-xe, --conflict error\n"
            "\t\tInsert diagnostic #errors on contradictions as per -xd.\n"
            "\t--line\n"
            "\t\tGenerate #line directives to make CPP line-numbering of output "
            "agree with input even of lines are dropped.\n"
            "\t-c, --complement\n"
            "\t\tComplement. Retain the lines that ought to be dropped and "
            "vice versa.\n"
            "\t\t(Retained #-directives will still be simplified where possible.)\n"
            "symbols OPTIONs:-\n"
            "\t-i, --ifs\n"
            "\t\tList symbols that occur #if[[n]def]/#elif directives.\n"
            "\t-d, --defs\n"
            "\t\tList symbols that occur in #define directives.\n"
            "\t-u, --undefs\n"
            "\t\tList symbols that occur in #undef directives.\n"
            "\t--includes\n"
            "\t\tList symbols that occur in #include directives.\n"
            "\t(Default: -i -d -u --includes)\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each symbol. "
            "(Default: List all occurrences.)\n"
            "\t-A, --active\n"
            "\t\tList only symbols from operative directives\n"
            "\t-I, --inactive\n"
            "\t\tList only symbols from inoperative directives\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n"
            "\t-e, --evalsyms\n"
            "\t\tReport the resolved value of each symbol.\n"
            "includes OPTIONs:-\n"
            "\t-s, --system\n"
            "\t\tList system headers, i.e. <header.h>\n"
            "\t-L, --local\n"
            "\t\tList local headers, i.e. \"header.h\"\n"
            "\t(Default: -s -L)\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each header. "
            "(Default: List all occurrences.)\n"
            "\t-A --active\n"
            "\t\tList only headers from operative directives.\n"
            "\t-I --inactive\n"
            "\t\tList only headers from inoperative directives.\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n"
            "defs OPTIONs:-\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each distinct #define or "
            "#undef directive (Default: List all occurrences.)\n"
            "\t-A --active\n"
            "\t\tList only operative #define and #undef directives.\n"
            "\t-I --inactive\n"
            "\t\tList only inoperative #define and #undef directives.\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n"
            "pragmas OPTIONs:-\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each distinct pragma "
            "(Default: List all occurrences.)\n"
            "\t-A, --active\n"
            "\t\tList only pragmas from lines that are retained.\n"
            "\t-I, --inactive\n"
            "\t\tList only pragmas from lines that are dropped.\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n"
            "errors OPTIONs:-\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each #error directive "
            "(Default: List all occurrences.)\n"
            "\t-A, --active\n"
            "\t\tList only operative #error directives.\n"
            "\t-I, --inactive\n"
            "\t\tList only inoperative #error directives.\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n"
            "directives OPTIONs:-\n"
            "\t-o, --once\n"
            "\t\tList only the first occurrence of each distinct directive "
            "(Default: List all occurrences.)\n"
            "\t-A, --active\n"
            "\t\tList only operative directives.\n"
            "\t-I, --inactive\n"
            "\t\tList only inoperative directives.\n"
            "\t-L, --locate\n"
            "\t\tReport the source file and line number of each listed "
            "occurrence.\n",
            prog_name,prog_name,prog_name,
            prog_name,prog_name,prog_name,
            prog_name,prog_name,prog_name);
}

static void
usage_error_summary(void)
{
    usage(stderr);
}

static void
usage_error(int reason, const char *format,...)
{
    if (format) {
        va_list argp;
        atexit(usage_error_summary);
        va_start(argp,format);
        vbail(reason,format,argp);
        va_end(argp);
    } else {
        usage_error(GRIPE_USAGE_ERROR,"Invalid usage");
    }
}

static void
usage_help(void)
{
    usage(stdout);
    exit(MSGCLASS_NONE);
}

#ifndef VERSION
#ifdef NIX
#error VERSION not defined.
#endif

#define VERSION "4.2.3"
#endif

static void
version(void)
{
    printf("%s, version %s for %s (built %s, %s)\n",
           GET_PUBLIC(args,prog_name),VERSION,OS_TYPE,__DATE__,__TIME__);
    exit(MSGCLASS_NONE);
}

static void
config_diagnostics(const char * arg)
{
    int mask = MSGCLASS_NONE;
    if (GET_PUBLIC(args,diagnostic_filter) < 0 && strcmp(arg,"verbose")) {
        report(GRIPE_VERBOSE_ONLY,NULL,
               "Can't mix --verbose with --gag.'--gag %s' ignored",arg);
        return;
    }
    if (!strcmp(arg,"progress")) {
        mask = MSGCLASS_PROGRESS;
    } else if (!strcmp(arg,"info")) {
        mask = MSGCLASS_INFO;
    } else if (!strcmp(arg,"warning")) {
        mask = MSGCLASS_WARNING;
    } else if (!strcmp(arg,"error")) {
        mask = MSGCLASS_ERROR;
    } else if (!strcmp(arg,"abort")) {
        mask = MSGCLASS_ABEND;
    } else if (!strcmp(arg,"summary")) {
        mask = MSGCLASS_SUMMARY;
    } else if (!strcmp(arg,"verbose")) {
        int diagnostic_filter = GET_PUBLIC(args,diagnostic_filter);
        if (diagnostic_filter > 0) {
            report(GRIPE_VERBOSE_ONLY,NULL,
                   "Can't mix --verbose with --gag. '--verbose' ignored");
            return;
        } else if (diagnostic_filter < 0) {
            report(GRIPE_DUPLICATE_MASK,NULL,"'--verbose' already seen");
            return;
        }
        SET_PUBLIC(args,diagnostic_filter) = -1;
        return;
    } else {
        usage_error(GRIPE_USAGE_ERROR,"Invalid argument for --gag: \"%s\"",arg);
    }
    if (mask & GET_PUBLIC(args,diagnostic_filter)) {
        report(GRIPE_DUPLICATE_MASK,NULL,
               "'--gag %s' already seen",arg);
    }
    SET_PUBLIC(args,diagnostic_filter) |=  mask;
    if (mask == MSGCLASS_INFO) {
        config_diagnostics("progress");
    } else if (mask == MSGCLASS_WARNING) {
        config_diagnostics("info");
    } else if (mask == MSGCLASS_ERROR) {
        config_diagnostics("warning");
    } else if (mask == MSGCLASS_ABEND) {
        config_diagnostics("error");
    }
}

static void
finalise_diagnostics(void)
{
    int mask = GET_PUBLIC(args,diagnostic_filter);
    if (!mask) {
        /* Default diagnostic masking to no progress
                messages, no infos, no summaries*/
        config_diagnostics("info");
        config_diagnostics("summary");
    } else if (mask == -1) {
        /* --verbose was temporarily set as -1 to block later
                --gag options. Can now reset as 0*/
        SET_PUBLIC(args,diagnostic_filter) = 0;
    }
}

static void
error_invalid_opt(cmd_option_t const *cmd, int bad_opt)
{
    char const *cmdname = cmd->name;
    char const *optname = get_long_opt_name(long_options,bad_opt);
    assert(optname);
    usage_error(GRIPE_INVALID_ARGS,
                "\"%s\" is not a valid option for command \"%s\"",optname,cmdname);
}

static bool
add_files(char const *path)
{
        bool verdict = true;
    fs_obj_type_t obj_type = fs_obj_type(path);
        if (obj_type == FS_OBJ_NONE) {
        report(GRIPE_NO_FILE,NULL,
            "No such file or directory as \"%s\"",path);
                verdict = false;
        }
    else if (FS_IS_FILE(obj_type)) {
        dataset_add(path);
    }
        else if (FS_IS_DIR(obj_type)) {
                if (!GET_PUBLIC(args,recurse)) {
                        report(GRIPE_DIR_IGNORED,NULL,
                                   "--recurse not specified. Ignoring directory \"%s\"",path);
                        verdict = false;
                }
        dataset_add(path);
        }
        else if (FS_IS_SLINK(obj_type)) {
                report(GRIPE_BROKEN_SYMLINK,NULL,
                                "Broken symbolic link \"%s\" ignored",path);
                verdict = false;
        }
        else {
                assert(0);
        }
        return verdict;
}

/* Forward decl*/
static void
parse_args_file(const char *argsfile);


static void
parse_command_args(int argc, char *argv[])
{
    static bool parsing_file;
    int args = argc;
    int opt, save_ind, long_index;
    cmd_option_t const * command = GET_PUBLIC(args,command);
    if (!opts[0]) {
        make_opts_list();
    }
    for ( optind = 0;
            (opt = getopt_long(argc,argv,opts,long_options,&long_index)) != -1; ) {
        if (!opts_are_compatible(command->cmd_code,opt,cmd_exclusion_lists,true)) {
            error_invalid_opt(command,opt);
        }
        switch (opt) {
        case OPT_FILE:  /* Read further args from file*/
            save_ind = optind;
            /* Remember where we have parsed up to*/
            parsing_file = true;
            parse_args_file(optarg); /* Parse file*/
            parsing_file = false;
            optind = save_ind; /* Restore position*/
            break;
        case OPT_CONFLICT: {    /* Policy for contradictions*/
            int conflict_policy = CONTRADICTION_COMMENT;
            if (strlen(optarg) > 1) {
                if (!strcmp(optarg,"delete")) {
                    conflict_policy = CONTRADICTION_DELETE;
                } else if (!strcmp(optarg,"comment")) {
                    conflict_policy = CONTRADICTION_COMMENT;
                } else if (!strcmp(optarg,"error")) {
                    conflict_policy = CONTRADICTION_ERROR;
                } else {
                    usage_error(GRIPE_USAGE_ERROR,
                                "Invalid argument for --conflict: \"%s\"",optarg);
                }
            } else {
                switch(*optarg) {
                case 'd':
                    conflict_policy = CONTRADICTION_DELETE;
                    break;
                case 'c':
                    conflict_policy = CONTRADICTION_COMMENT;
                    break;
                case 'e':
                    conflict_policy = CONTRADICTION_ERROR;
                    break;
                default:
                    usage_error(GRIPE_USAGE_ERROR,
                                "Invalid argument for -x: \"%c\"",*optarg);
                }
            }
            contradiction_policy(conflict_policy);
        }
        break;
        case OPT_GAG: {
            char const *gag_arg = optarg;
            if (strlen(optarg) == 1) {
                switch(*optarg) {
                case 'p':
                    gag_arg = "progress";
                    break;
                case 'i':
                    gag_arg = "info";
                    break;
                case 'w':
                    gag_arg = "warning";
                    break;
                case 'e':
                    gag_arg = "error";
                    break;
                case 'a':
                    gag_arg = "abend";
                    break;
                case 's':
                    gag_arg = "summary";
                    break;
                default:
                    assert(false);
                }
            }
            config_diagnostics(gag_arg);
        }
        break;
        case OPT_VERBOSE:
            config_diagnostics("verbose");
            break;
        case OPT_DEF: /* define a symbol*/
            symbol_evaluate_status(true,optarg,NULL,NULL);
            break;
        case OPT_UNDEF: /* undef a symbol*/
            symbol_evaluate_status(false,optarg,NULL,NULL);
            break;
        case OPT_COMPLEMENT: /* treat -D as -U and vice versa*/
            SET_PUBLIC(args,complement) = true;
            break;
        case OPT_REPLACE:
            SET_PUBLIC(args,replace) = true;
            break;
        case OPT_BACKUP:
            SET_PUBLIC(args,backup_suffix) = optarg;
            break;
        case OPT_DEBUG:
            debugging(true);
            break;
        case OPT_EVALCONSTS:
            SET_PUBLIC(args,eval_consts) = true;
            break;
        case OPT_DISCARD: /* policy for discarding lines on output*/
            if (strlen(optarg) > 1) {
                if (!strcmp("drop",optarg)) {
                    SET_PUBLIC(args,discard_policy) = DISCARD_DROP;
                } else if (!strcmp("blank",optarg)) {
                    SET_PUBLIC(args,discard_policy) = DISCARD_BLANK;
                } else if (!strcmp("comment",optarg)) {
                    SET_PUBLIC(args,discard_policy) = DISCARD_COMMENT;
                } else {
                    usage_error(GRIPE_USAGE_ERROR,
                                "Invalid argument for --discard: \"%s\"",optarg);
                }
            } else {
                switch(*optarg) {
                case 'd':
                    SET_PUBLIC(args,discard_policy) = DISCARD_DROP;
                    break;
                case 'b':
                    SET_PUBLIC(args,discard_policy) = DISCARD_BLANK;
                    break;
                case 'c':
                    SET_PUBLIC(args,discard_policy) = DISCARD_COMMENT;
                    break;
                default:
                    usage_error(GRIPE_USAGE_ERROR,
                                "Invalid argument for -k: \"%c\"",*optarg);
                }
            }
            break;
        case OPT_LINE:
            SET_PUBLIC(args,line_directives) = true;
            break;
        case OPT_LOCATE:
            SET_PUBLIC(args,list_locate) = true;
            break;
        case OPT_ACTIVE:
            SET_PUBLIC(args,list_only_active) = true;
            break;
        case OPT_INACTIVE:
            SET_PUBLIC(args,list_only_inactive) = true;
            break;
        case OPT_EVALSYMS:
            SET_PUBLIC(args,resolve_symbols) = true;
            break;
        case OPT_ONCE:
            SET_PUBLIC(args,list_only_once) = true;
            break;
        case OPT_IFS:
            SET_PUBLIC(args,list_symbols_in_ifs) = true;
            break;
        case OPT_DEFS:
            SET_PUBLIC(args,list_symbols_in_defs) = true;
            break;
        case OPT_UNDEFS:
            SET_PUBLIC(args,list_symbols_in_undefs) = true;
            break;
        case OPT_INCLUDES:
            SET_PUBLIC(args,list_symbols_in_includes) = true;
            break;
        case OPT_SYSTEM:
            SET_PUBLIC(args,list_system_includes) = true;
            break;
        case OPT_LOCAL:
            SET_PUBLIC(args,list_local_includes) = true;
            break;
        case OPT_POD: /* don't parse quotes or comments*/
            SET_PUBLIC(args,plaintext) = true;
            break;
        case OPT_RECURSE: /* recurse into directories*/
            SET_PUBLIC(args,recurse) = true;
            if (command->cmd_code == CMD_SOURCE) {
                SET_PUBLIC(args,replace) = true;
            }
            break;
        case OPT_FILTER: /* Filter input by file extensions*/
            dataset_filter_filetypes(optarg);
            break;
        case OPT_KEEPGOING: /* Continue to process subsequent in
                                                                put files after errors*/
            SET_PUBLIC(args,keepgoing) = true;
            break;
                case OPT_IMPLICIT: /* Implicitly --undef any unconfigured symbol */
                        SET_PUBLIC(args,implicit) = true;
                        break;
        default:
            usage_error(GRIPE_USAGE_ERROR,
                        "Invalid option: \"%s\"",argv[optind - 1]);
        }
    }
    if (!parsing_file) {
        SET_PUBLIC(args,got_opts) = true;
        finalise_diagnostics();
        if (!PROGRESS_GAGGED()) {
            heap_str argstr = concatenate(args,argv,' ');
            report(PROGRESS_GOT_OPTIONS,NULL,"Args: %s",argstr);
            free(argstr);
        }
        if (command->cmd_code == CMD_SOURCE) {
            ptr_set_h st = GET_PUBLIC(configured_symbols,global_sym_tab);
            if (ptr_set_count(st) == 0) {
                report(GRIPE_NO_SYMS,NULL,
                    "You have not --define-ed or --undef-ed any symbols. "
                    "Only in-source #define/#undef directives will have any effects");
            }
        }
    }
    if (argc) {
        report(PROGRESS_BUILDING_TREE,NULL,"Building input tree");
    }
    argc -= optind;
    argv += optind;
    for (       ; argc; --argc,++argv) {
        if (!add_files(*argv)) {
            ++SET_STATE(args,arg_dirs_ignored);
        }
    }
}

static void
parse_args_file(const char *argsfile)
{
    char *arg, * delims=" \t\n\r";
    char **argv;
    int argc;
    size_t filesz,read;
    FILE *in;
    if (GET_STATE(args,memfile)) {
        bail(GRIPE_MULTIPLE_ARGFILES,"--file can only be used once");
    }
    in = open_file(argsfile,"r");
    fseek(in,0,SEEK_END);
    filesz = ftell(in);
    fseek(in,0,SEEK_SET); /* Back to start of file*/
    SET_STATE(args,memfile) = zallocate(filesz + 1);
    ptr_vector_append(GET_STATE(args,argfile_argv),GET_PUBLIC(args,prog_name));
    /* Remember program name comes first*/
    read = fread(GET_STATE(args,memfile),1,filesz,in);
    if (!read) { /* Read args file into heap*/
        bail(GRIPE_CANT_READ_INPUT,"Read error on file %s",argsfile);
        /* Not bullet-proof to assume that only 0 bytes read is
        a read error, but cannot portably test `read' == `filesz'
        because if there are newlines in the file then on Windows, fewer
        bytes will be read than there are in the file due to newline
        conversion*/

    }
    fclose(in);
    GET_STATE(args,memfile)[read] = '\0'; /* 0-terminate commandline*/
    for(arg = strtok(GET_STATE(args,memfile),delims);
            arg != NULL; arg = strtok(NULL,delims)) {
        ptr_vector_append(GET_STATE(args,argfile_argv),arg);
    }
    argc = (int)ptr_vector_count(GET_STATE(args,argfile_argv));
    argv = (char **)ptr_vector_begin(GET_STATE(args,argfile_argv));
    parse_command_args(argc,argv);
}

/* API ********************************************************************/

void
parse_executable(char **argv)
{
    char *last_slash;
    SET_PUBLIC(args,exec_path) = *argv;
    last_slash = strrchr(*argv,PATH_DELIM);
    if (!last_slash) {
        SET_PUBLIC(args,prog_name) = *argv;
    } else {
        SET_PUBLIC(args,prog_name) = last_slash + 1;
    }
}

void
parse_args(int argc, char *argv[])
{
    cmd_option_t const *cmd = get_command_option(argc,argv,commands);
    if (cmd) {
        switch(cmd->cmd_code) {
        case CMD_HELP:
            usage_help();
            break;
        case CMD_VERSION:
            version();
            break;
        case CMD_SYMBOLS:
        case CMD_INCLUDES:
        case CMD_DEFS:
        case CMD_PRAGMAS:
        case CMD_ERRORS:
        case CMD_DIRECTIVES:
            line_despatch_no_op();
            /* Yes, fall through*/
        default:
            SET_PUBLIC(args,command) = (cmd_option_t *)cmd;
            argc -= 1;
            argv += 1;
            parse_command_args(argc,argv);
        }
    } else {
        usage_error(GRIPE_USAGE_ERROR,"\"%s\" is not a coan command",
                    argv[1]);
    }
}

void
finish_args(void)
{
    int command = GET_PUBLIC(args,command)->cmd_code;
    bool replace = GET_PUBLIC(args,replace);
    bool input_is_stdin = false;

    if (GET_PUBLIC(args,list_only_active) &&
            GET_PUBLIC(args,list_only_inactive)) {
        usage_error(GRIPE_USAGE_ERROR,
                    "--active is inconsistent with --inactive");
    }
    if (file_tree_is_empty(GET_PUBLIC(dataset,file_tree)) &&
            GET_STATE(args,arg_dirs_ignored) == 0) {
        /* No input files on command line*/
        if (!GET_PUBLIC(args,replace)) {
            /* Without --replace, stdin is the input file*/
            input_is_stdin = true;
        } else {
            /* With --replace, stdin supplies input filenames*/
            char * infile;
            while ((infile = read_filename()) != NULL) {
                (void)add_files(infile);
            }
        }
    }
    if (file_tree_is_empty(GET_PUBLIC(dataset,file_tree)) && !input_is_stdin) {
        bail(GRIPE_NOTHING_TO_DO,
             "Nothing to do. No input files.");
    }
    if (command == CMD_SOURCE && !input_is_stdin &&
            file_tree_count(GET_PUBLIC(dataset,file_tree),FT_COUNT_FILES,NULL) > 1 &&
            !replace) {
        bail(GRIPE_ONE_FILE_ONLY,
             "The \"source\" command needs --replace to process multiple files");
    }
    if (command == CMD_SYMBOLS) {
        if (!GET_PUBLIC(args,list_symbols_in_ifs) &&
                !GET_PUBLIC(args,list_symbols_in_defs) &&
                !GET_PUBLIC(args,list_symbols_in_undefs) &&
                !GET_PUBLIC(args,list_symbols_in_includes)) {
            /* No restriction on listed symbols implies list all*/
            SET_PUBLIC(args,list_symbols_in_ifs) = true;
            SET_PUBLIC(args,list_symbols_in_defs) = true;
            SET_PUBLIC(args,list_symbols_in_undefs) = true;
            SET_PUBLIC(args,list_symbols_in_includes) = true;
        }
    }
    if (command == CMD_INCLUDES) {
        if (!GET_PUBLIC(args,list_system_includes) &&
                !GET_PUBLIC(args,list_local_includes)) {
            /* No restriction on listed #includes implies list all*/
            SET_PUBLIC(args,list_system_includes) = true;
            SET_PUBLIC(args,list_local_includes) = true;
        }
    }
    report(PROGRESS_FILE_TALLY,NULL,"%d files to process",
           file_tree_count(GET_PUBLIC(dataset,file_tree),FT_COUNT_FILES,NULL));
}


/* EOF*/