options.h

Go to the documentation of this file.

#ifndef OPTIONS_H
#define OPTIONS_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Symbian Software Ltd.                       *
 *   All rights reserved.                                                  *
 *   Copyright (C) 2007-2013 Mike Kinghan, imk@burroingroingjoing.com      *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   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 <string>
#include <vector>

enum discard_policy {
    DISCARD_DROP,       
    DISCARD_BLANK,      
    DISCARD_COMMENT 
};

enum contradiction_policy {
    CONTRADICTION_DELETE,
    CONTRADICTION_COMMENT,
    CONTRADICTION_ERROR
};

enum command_code {
    CMD_HELP = 1,       
    CMD_VERSION,        
    CMD_SOURCE, 
    CMD_SYMBOLS,        
    CMD_INCLUDES,       
    CMD_DEFS,   
    CMD_PRAGMAS,        
    CMD_ERRORS, 
    CMD_LINES,  
    CMD_DIRECTIVES,     
    CMD_SPIN    
};

struct  options {

        static command_code get_command();

        static std::string const & exec_path() {
                return _exec_path_;
        }
        static std::string const & prog_name() {
                return _prog_name_;
        }
        static std::string const & backup_suffix() {
                return _backup_suffix_;
        }
        static bool got_opts() {
                return _got_opts_;
        }
        static bool replace() {
                return _replace_;
        }
        static bool list_location() {
                return _list_locate_;
        }
        static bool list_only_once() {
                return _list_only_once_;
        }
        static bool list_once_per_file() {
                return _list_once_per_file_;
        }
        static bool list_only_active() {
                return _list_only_active_;
        }
        static bool list_only_inactive() {
                return _list_only_inactive_;
        }
        static bool list_symbols_in_ifs() {
                return _list_symbols_in_ifs_;
        }
        static bool list_symbols_in_defs() {
                return _list_symbols_in_defs_;
        }
        static bool list_symbols_in_undefs() {
                return _list_symbols_in_undefs_;
        }
        static bool list_symbols_in_includes() {
                return _list_symbols_in_includes_;
        }
        static bool list_symbols_in_lines() {
                return _list_symbols_in_lines_;
        }
        static bool list_system_includes() {
                return _list_system_includes_;
        }
        static bool list_local_includes() {
                return _list_local_includes_;
        }
        static bool complement() {
                return _complement_;
        }
        static bool eval_wip() {
                return _eval_wip_;
        }
        static bool expand_references() {
                return _expand_references_;
        }
        static discard_policy & get_discard_policy() {
                return _discard_policy_;
        }
        static bool line_directives() {
                return _line_directives_;
        }
        static bool plaintext() {
                return _plaintext_;
        }
        static bool recurse() {
                return _recurse_;
        }
        static bool keep_going() {
                return  _keepgoing_;
        }
        static bool implicit() {
                return  _implicit_;
        }
        static bool no_transients() {
                return  _no_transients_;
        }
        static bool explain_references() {
                return  _explain_references_;
        }
        static bool selected_symbols() {
                return  _selected_symbols_;
        }
        static unsigned & max_expansion() {
                return  _max_expansion_;
        }

        static bool have_source_output() {
                static bool yes =
                                get_command() == CMD_SOURCE || get_command() == CMD_SPIN;
                return yes;
        }

        static bool list_at_most_once_per_file() {
                static bool yes =
                                _list_only_once_ || _list_once_per_file_;
                return yes;
        }

        static void parse_executable(char **argv);

        static void parse(int argc, char *argv[]);

        static bool diagnostic_gagged(unsigned reason);

        static void finish();

private:

        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_EVALWIP = 'E',      
                OPT_DISCARD = 'k',              
                OPT_LINE = 1,                   
                OPT_POD = 'P',                  
                OPT_RECURSE = 'R',              
                OPT_FILTER = 'F',               
                OPT_KEEPGOING = 'K',    
                OPT_IFS = 'i',                  
                OPT_DEFS = 'd',                 
                OPT_UNDEFS = 'u',               
                OPT_INCLUDES = 2,       
                OPT_LOCATE = 'L',               
                OPT_ONCE = 'o',                 
                OPT_SYSTEM = 's',               
                OPT_LOCAL = 'l',                
                OPT_ACTIVE = 'A',               
                OPT_INACTIVE = 'I',             
                OPT_EXPAND = 3,                 
                OPT_IMPLICIT = 'm',             
                OPT_DIR = 4,                    
                OPT_PREFIX = 'p',               
                OPT_NO_TRANSIENTS = 5,  
                OPT_EXPLAIN = 6,                
                OPT_SELECT = 7,                 
                OPT_LNS = 8,                    
                OPT_EXPAND_MAX = 9,             
                OPT_ONCE_PER_FILE = 10  
        };

        static struct option long_options [];

        static char opts [];

        static struct cmd_option commands [];

        static int const source_cmd_exclusions [];

        static int const symbols_cmd_exclusions [];

        static int const includes_cmd_exclusions[];

        static int const directives_cmd_exclusions [];

        static int const defs_cmd_exclusions [];

        static int const pragmas_cmd_exclusions [];

        static int const errors_cmd_exclusions[];

        static int const lines_cmd_exclusions[];

        static int const spin_cmd_exclusions[];

        static struct exclusion_list const cmd_exclusion_lists [];

        static void make_opts_list();

        static void
        config_diagnostics(std::string const & arg);

        static void finalise_diagnostics();

        static void
        error_invalid_opt(struct cmd_option const *cmd, int bad_opt);


        static void add_files(std::string const & path);

        static void parse_file(std::string const & argsfile);

        static void parse_command_args(int argc, char *argv[]);

        static bool progress_gagged();

        static struct cmd_option * _command_;
        static std::string _exec_path_;
        static std::string _prog_name_;
        static std::string _backup_suffix_;
        static bool     _got_opts_;
        static bool     _replace_;
        static bool     _list_locate_;
        static bool     _list_only_once_;
        static bool     _list_once_per_file_;
        static bool     _list_only_active_;
        static bool     _list_only_inactive_;
        static bool     _list_symbols_in_ifs_;
        static bool     _list_symbols_in_defs_;
        static bool     _list_symbols_in_undefs_;
        static bool     _list_symbols_in_includes_;
        static bool     _list_symbols_in_lines_;
        static bool     _list_system_includes_;
        static bool     _list_local_includes_;
        static bool     _complement_;
        static bool     _eval_wip_;
        static bool     _expand_references_;
        static discard_policy   _discard_policy_;
        static bool     _line_directives_;
        static bool     _plaintext_;
        static bool     _recurse_;
        static bool     _keepgoing_;
        static bool     _implicit_;
        static bool _no_transients_;
        static bool _explain_references_;
        static bool _selected_symbols_;
        static unsigned _max_expansion_;
        static int      _diagnostic_filter_;

        static std::vector<std::string > _argfile_argv_;
        static std::string      _memfile_;
        static int _cmd_line_files_;

        static bool _parsing_file_;
};

#endif // EOF