/*=============================================================================
    Wave: A Standard compliant C++ preprocessor library

    Copyright (c) 2001-2004 Hartmut Kaiser
    http://spirit.sourceforge.net/

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/

#include "cpp.hpp"                  // global configuration

///////////////////////////////////////////////////////////////////////////////
//  This sample requires the program_options library written by Vladimir Prus,
//  which is already accepted into Boost, but not included with the 
//  distribution yet. 
//  It is available here: http://boost-sandbox.sourceforge.net/program_options.
//
#include <boost/program_options.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/timer.hpp>

///////////////////////////////////////////////////////////////////////////////
//  Include Wave itself
#include <boost/wave.hpp>

//  Include the lexer related stuff
#include <boost/wave/token_ids.hpp>                   // token Id's
#include <boost/wave/cpplexer/cpp_lex_token.hpp>      // token type
#include <boost/wave/cpplexer/cpp_lex_iterator.hpp>   // lexer type

#include "trace_macro_expansion.hpp"

///////////////////////////////////////////////////////////////////////////////
//  include lexer specifics, import lexer names
//
#if BOOST_WAVE_SEPARATE_LEXER_INSTANTIATION == 0
#include <boost/wave/cpplexer/re2clex/cpp_re2c_lexer.hpp>
#endif 

///////////////////////////////////////////////////////////////////////////////
//  include the grammar definitions, if these shouldn't be compiled separately
//  (ATTENTION: _very_ large compilation times!)
//
#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION == 0
#include <boost/wave/grammars/cpp_intlit_grammar.hpp>
#include <boost/wave/grammars/cpp_chlit_grammar.hpp>
#include <boost/wave/grammars/cpp_grammar.hpp>
#include <boost/wave/grammars/cpp_expression_grammar.hpp>
#include <boost/wave/grammars/cpp_predef_macros_grammar.hpp>
#include <boost/wave/grammars/cpp_defined_grammar.hpp>
#endif 

///////////////////////////////////////////////////////////////////////////////
//  import required names
using namespace boost::spirit;

using std::string;
using std::pair;
using std::vector;
using std::getline;
using std::ifstream;
using std::cout;
using std::cerr;
using std::endl;
using std::ostream;
using std::istreambuf_iterator;

namespace po = boost::program_options;
namespace fs = boost::filesystem;

///////////////////////////////////////////////////////////////////////////////
// print the current version
int print_version()
{
    typedef boost::wave::cpplexer::lex_iterator<
            boost::wave::cpplexer::lex_token<> >
        lex_iterator_t;
    typedef boost::wave::context<
            std::string::iterator, lex_iterator_t,
            boost::wave::iteration_context_policies::load_file_to_string,
            trace_macro_expansion> 
        context_t;
        
    string version (context_t::get_version_string());
    cout 
        << version.substr(1, version.size()-2)  // strip quotes
        << " (" << CPP_VERSION_DATE << ")"      // add date
        << endl;
    return 0;                       // exit app
}

///////////////////////////////////////////////////////////////////////////////
// print the copyright statement
int print_copyright()
{
char const *copyright[] = {
        "",
        "Wave: A Standard conformant C++ preprocessor",
        "Copyright (c) 2001-2004 Hartmut Kaiser",
        "It is hosted by http://spirit.sourceforge.net/.", 
        "",
        "Use, modification and distribution is subject to the Boost Software",
        "License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at",
        "http://www.boost.org/LICENSE_1_0.txt)",
        0
    };
    
    for (int i = 0; 0 != copyright[i]; ++i)
        cout << copyright[i] << endl;
        
    return 0;                       // exit app
}

///////////////////////////////////////////////////////////////////////////////
namespace cmd_line_util {

    // Additional command line parser which interprets '@something' as an 
    // option "config-file" with the value "something".
    pair<string, string> at_option_parser(string const&s)
    {
        if ('@' == s[0]) 
            return std::make_pair(string("config-file"), s.substr(1));
        else
            return pair<string, string>();
    }

    // class, which keeps include file information from the command line
    class include_paths {
    public:
        include_paths() : seen_separator(false) {}

        vector<string> paths;       // stores user paths
        vector<string> syspaths;    // stores system paths
        bool seen_separator;        // command line contains a '-I-' option

        // Function which validates additional tokens from command line.
        static void 
        validate(boost::any &v, vector<string> const &tokens)
        {
            if (v.empty())
                v = boost::any(include_paths());

            include_paths *p = boost::any_cast<include_paths>(&v);

            BOOST_SPIRIT_ASSERT(p);
            // Assume only one path per '-I' occurrence.
            string t = tokens[0];
            if (t == "-") {
            // found -I- option, so switch behaviour
                p->seen_separator = true;
            } 
            else if (p->seen_separator) {
            // store this path as a system path
                p->syspaths.push_back(t); 
            } 
            else {
            // store this path as an user path
                p->paths.push_back(t);
            }            
        }
    };

    // Workaround for a problem in the program_options library: all options 
    // stored in a variables_map, which have an assigned validator function
    // need an extraction operator.
    std::istream& operator>>(std::istream& is, include_paths& p)
    {
        return is;
    }

    // Read all options from a given config file, parse and add them to the
    // given variables_map
    void read_config_file_options(string const &filename, 
        po::options_description const &desc, po::variables_map &vm,
        bool may_fail = false)
    {
    ifstream ifs(filename.c_str());

        if (!ifs.is_open()) {
            if (!may_fail) {
                cerr << filename 
                    << ": command line warning: config file not found"
                    << endl;
            }
            return;
        }
        
    vector<string> options;
    string line;

        while (std::getline(ifs, line)) {
        // skip empty lines
            string::size_type pos = line.find_first_not_of(" \t");
            if (pos == string::npos) 
                continue;

        // skip comment lines
            if ('#' != line[pos])
                options.push_back(line);
        }

        if (options.size() > 0) {
        po::options_and_arguments oa = po::parse_command_line(options, desc);

            po::store(oa, vm, desc);
        }
    }

///////////////////////////////////////////////////////////////////////////////
}

///////////////////////////////////////////////////////////////////////////////
namespace {

  class auto_stop_watch : public stop_watch
  {
  public:
      auto_stop_watch(bool print_time_, std::ostream &outstrm_)
      :   print_time(print_time_), outstrm(outstrm_)
      {
      }
      
      ~auto_stop_watch()
      {
          if (print_time) {
              outstrm << "Elapsed time: " 
                    << this->format_elapsed_time() 
                    << std::endl;
          }
      }
  
  private:
      bool print_time;
      std::ostream &outstrm;
  };
  
///////////////////////////////////////////////////////////////////////////////
}   // anonymous namespace

///////////////////////////////////////////////////////////////////////////////
//  do the actual preprocessing
int do_actual_work (po::options_and_arguments const opts, 
    po::variables_map const &vm)
{
// current file position is saved for exception handling
boost::wave::util::file_position_t current_position;

    try {
    // process the given file
    string file_name(opts.arguments().front());
    ifstream instream(file_name.c_str());
    string instring;

        if (!instream.is_open()) {
            cerr << "wave: could not open input file: " << file_name << endl;
            return -1;
        }
        instream.unsetf(std::ios::skipws);
        
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
        // this is known to be very slow for large files on some systems
        copy (istream_iterator<char>(instream),
              istream_iterator<char>(), 
              inserter(instring, instring.end()));
#else
        instring = string(istreambuf_iterator<char>(instream.rdbuf()),
                          istreambuf_iterator<char>());
#endif 

    //  This sample uses the lex_iterator and lex_token types predefined with 
    //  the Wave library, but it is possible to use your own types.
        typedef boost::wave::cpplexer::lex_iterator<
                boost::wave::cpplexer::lex_token<> >
            lex_iterator_t;
        typedef boost::wave::context<
                std::string::iterator, lex_iterator_t,
                boost::wave::iteration_context_policies::load_file_to_string,
                trace_macro_expansion> 
            context_t;

    // The C++ preprocessor iterators shouldn't be constructed directly. They 
    // are to be generated through a boost::wave::context<> object. This 
    // boost::wave::context object is additionally to be used to initialize and 
    // define different parameters of the actual preprocessing.
    // The preprocessing of the input stream is done on the fly behind the 
    // scenes during iteration over the context_t::iterator_t stream.
    std::ofstream traceout;
    boost::wave::trace_policies::trace_flags enable_trace = 
        boost::wave::trace_policies::trace_nothing;
    
        if (vm.count("traceto")) {
        // try to open the file, where to put the trace output
        string trace_file (vm["traceto"].as<string>());
        
            if (trace_file != "-") {
                traceout.open(trace_file.c_str());
                if (!traceout.is_open()) {
                    cerr << "wave: could not open trace file: " << trace_file 
                        << endl;
                    return -1;
                }
            }
            enable_trace = boost::wave::trace_policies::trace_macros;
        }
        if ((enable_trace & boost::wave::trace_policies::trace_macros) && 
            !traceout.is_open()) 
        {
        // by default trace to std::cerr
            traceout.copyfmt(cerr);
            traceout.clear(cerr.rdstate());
            static_cast<std::basic_ios<char> &>(traceout).rdbuf(cerr.rdbuf());
        }
        
    context_t ctx (instring.begin(), instring.end(), file_name.c_str(),
        trace_macro_expansion(traceout, enable_trace));

#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
    // enable C99 mode, if appropriate (implies variadics)
        if (vm.count("c99")) {
#if BOOST_WAVE_ENABLE_CPP0X_EXTENSIONS != 0
            if (vm.count("c++0x")) {
                cerr << 
                    "wave: the C99 and C++0x modes are mutually exclusive, "
                    "working in C99 mode." << endl;
            }
#endif 
            ctx.set_language(boost::wave::support_c99);
        }
#if BOOST_WAVE_ENABLE_CPP0X_EXTENSIONS != 0
    // enable experimental C++0x mode (implies variadics)
        else if (vm.count("c++0x")) {
            ctx.set_language(boost::wave::support_cpp0x);
        }
#endif 
        else if (vm.count("variadics")) {
        // enable variadics and placemarkers, if appropriate
            ctx.set_language(boost::wave::enable_variadics(ctx.get_language()));
        }
#endif // BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
        
    // add include directories to the system include search paths
        if (vm.count("sysinclude")) {
        vector<string> syspaths = vm["sysinclude"].as<vector<string> >();
        
            vector<string>::const_iterator end = syspaths.end();
            for (vector<string>::const_iterator cit = syspaths.begin(); 
                 cit != end; ++cit)
            {
                ctx.add_sysinclude_path((*cit).c_str());
            }
        }
        
    // add include directories to the include search paths
        if (vm.count("include")) {
            cmd_line_util::include_paths const &ip = 
                vm["include"].as<cmd_line_util::include_paths>();
            vector<string>::const_iterator end = ip.paths.end();

            for (vector<string>::const_iterator cit = ip.paths.begin(); 
                 cit != end; ++cit)
            {
                ctx.add_include_path((*cit).c_str());
            }

        // if on the command line was given -I- , this has to be propagated
            if (ip.seen_separator) 
                ctx.set_sysinclude_delimiter();
                 
        // add system include directories to the include path
            vector<string>::const_iterator sysend = ip.syspaths.end();
            for (vector<string>::const_iterator syscit = ip.syspaths.begin(); 
                 syscit != sysend; ++syscit)
            {
                ctx.add_sysinclude_path((*syscit).c_str());
            }
        }
    
    // add additional defined macros 
        if (vm.count("define")) {
            vector<string> macros = vm["define"].as<vector<string> >();
            vector<string>::const_iterator end = macros.end();
            for (vector<string>::const_iterator cit = macros.begin(); 
                 cit != end; ++cit)
            {
                ctx.add_macro_definition(*cit);
            }
        }

    // add additional predefined macros 
        if (vm.count("predefine")) {
            vector<string> predefmacros = vm["predefine"].as<vector<string> >();
            vector<string>::const_iterator end = predefmacros.end();
            for (vector<string>::const_iterator cit = predefmacros.begin(); 
                 cit != end; ++cit)
            {
                ctx.add_macro_definition(*cit, true);
            }
        }

    // undefine specified macros
        if (vm.count("undefine")) {
            vector<string> undefmacros = vm["undefine"].as<vector<string> >();
            vector<string>::const_iterator end = undefmacros.end();
            for (vector<string>::const_iterator cit = undefmacros.begin(); 
                 cit != end; ++cit)
            {
                ctx.remove_macro_definition((*cit).c_str(), true);
            }
        }

    // maximal include nesting depth
        if (vm.count("nesting")) {
            int max_depth = vm["nesting"].as<int>();
            if (max_depth < 1 || max_depth > 100000) {
                cerr << "wave: bogus maximal include nesting depth: " 
                    << max_depth << endl;
                return -1;
            }
            ctx.set_max_include_nesting_depth(max_depth);
        }
        
    // open the output file
    std::ofstream output;
    
        if (vm.count("output")) {
        // try to open the file, where to put the preprocessed output
        string out_file (vm["output"].as<string>());
        
            output.open(out_file.c_str());
            if (!output.is_open()) {
                cerr << "wave: could not open output file: " << out_file << endl;
                return -1;
            }
        }
        else {
        // output the preprocessed result to std::cout
            output.copyfmt(cout);
            output.clear(cout.rdstate());
            static_cast<std::basic_ios<char> &>(output).rdbuf(cout.rdbuf());
        }

    // analyze the input file
    context_t::iterator_t first = ctx.begin();
    context_t::iterator_t last = ctx.end();
    
    // preprocess the required include files 
        if (vm.count("forceinclude")) {
        // add the filenames to force as include files in _reverse_ order
        // the second parameter 'is_last' for the force_include function should
        // be set to true for the last (first given) file.
            vector<string> force = vm["forceinclude"].as<vector<string> >();
            vector<string>::const_reverse_iterator rend = force.rend();
            for (vector<string>::const_reverse_iterator cit = force.rbegin(); 
                 cit != rend; /**/)
            {
                string filename(*cit);
                first.force_include(filename.c_str(), ++cit == rend);
            }
        }
        
    // loop over all generated tokens outputing the generated text 
    auto_stop_watch elapsed_time(vm.count("timer") > 0, cerr);
    
        while (first != last) {
        // print out the string representation of this token (skip comments)
            using namespace boost::wave;

        // store the last known good token position
            current_position = (*first).get_position();

        token_id id = token_id(*first);

            if (T_CPPCOMMENT == id || T_NEWLINE == id) {
            // C++ comment tokens contain the trailing newline
                output << endl;
            }
            else if (id != T_CCOMMENT) {
            // print out the current token value
                output << (*first).get_value();
            }
            ++first;        // advance to the next token
        }
    }
    catch (boost::wave::cpp_exception &e) {
    // some preprocessing error
        cerr 
            << e.file_name() << "(" << e.line_no() << "): "
            << e.description() << endl;
        return 1;
    }
    catch (boost::wave::cpplexer::lexing_exception &e) {
    // some lexing error
        cerr 
            << e.file_name() << "(" << e.line_no() << "): "
            << e.description() << endl;
        return 2;
    }
    catch (std::exception &e) {
    // use last recognized token to retrieve the error position
        cerr 
            << current_position.get_file() 
            << "(" << current_position.get_line() << "): "
            << "exception caught: " << e.what()
            << endl;
        return 3;
    }
    catch (...) {
    // use last recognized token to retrieve the error position
        cerr 
            << current_position.get_file() 
            << "(" << current_position.get_line() << "): "
            << "unexpected exception caught." << endl;
        return 4;
    }
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//  main entry point
int
main (int argc, char const *argv[])
{
    try {
    // analyze the command line options and arguments
    vector<string> cfg_files;
    
    // declare the options allowed from the command line only
    po::options_description desc_cmdline ("Options allowed on the command line only");
        
        desc_cmdline.add_options()
            ("help,h", "", "print out program usage (this message)")
            ("version,v", "", "print the version number")
            ("copyright,c", "", "print out the copyright statement")
            ("config-file", po::parameter("filepath", &cfg_files),
                "specify a config file (alternatively: @filepath)")
        ;

    // declare the options allowed on command line and in config files
    po::options_description desc_generic ("Options allowed additionally in a config file");

        desc_generic.add_options()
            ("output,o", "path", "specify a file to use for output instead of stdout")
            ("include,I", "path", "specify an additional include directory").
                validator(&cmd_line_util::include_paths::validate)
            ("sysinclude,S", po::parameter<vector<string> >("syspath"), 
                "specify an additional system include directory")
            ("forceinclude,F", po::parameter<vector<string> >("file"),
                "force inclusion of the given file")
            ("define,D", po::parameter<vector<string> >("macro[=[value]]"), 
                "specify a macro to define")
            ("predefine,P", po::parameter<vector<string> >("macro[=[value]]"), 
                "specify a macro to predefine")
            ("undefine,U", po::parameter<vector<string> >("macro"), 
                "specify a macro to undefine")
            ("nesting,n", po::parameter<int>("depth"), 
                "specify a new maximal include nesting depth")
        ;
        
    po::options_description desc_ext ("Extended options (allowed everywhere)");

        desc_ext.add_options()
            ("traceto,t", "path", "output trace info to a file [path] or to stderr [-]")
            ("timer", "", "output overall elapsed computing time to stderr")
#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
            ("variadics", "", "enable certain C99 extensions in C++ mode")
            ("c99", "", "enable C99 mode (implies --variadics)")
#endif 
#if BOOST_WAVE_ENABLE_CPP0X_EXTENSIONS != 0
            ("c++0x", "", "enable C++0x support (implies --variadics)")
#endif 
        ;
    
    // combine the options for the different usage schemes
    po::options_description desc_overall_cmdline;

        desc_overall_cmdline.add(desc_cmdline);    
        desc_overall_cmdline.add(desc_generic);
        desc_overall_cmdline.add(desc_ext);

    po::options_description desc_overall_cfgfile;

        desc_overall_cfgfile.add(desc_generic);
        desc_overall_cfgfile.add(desc_ext);
        
    // parse command line and store results
    po::options_and_arguments opts = po::parse_command_line(argc, argv, 
        desc_overall_cmdline, 0, cmd_line_util::at_option_parser);
    po::variables_map vm;
    
        po::store(opts, vm, desc_overall_cmdline);

    // Try to find a wave.cfg in the same directory as the executable was 
    // started from. If this exists, treat it as a wave config file
    fs::path filename(argv[0], fs::native);

        filename = filename.branch_path() / "wave.cfg";
        cmd_line_util::read_config_file_options(filename.string(), 
            desc_overall_cfgfile, vm, true);

    // if there is specified at least one config file, parse it and add the 
    // options to the main variables_map
        if (vm.count("config-file")) {
            vector<string>::const_iterator end = cfg_files.end();
            for (vector<string>::const_iterator cit = cfg_files.begin(); 
                 cit != end; ++cit)
            {
            // parse a single config file and store the results
                cmd_line_util::read_config_file_options(*cit, 
                    desc_overall_cfgfile, vm);
            }
        }

    // ... act as required 
        if (vm.count("help")) {
        po::options_description desc_help (
            "Usage: wave [options] [@config-file(s)] file");

            desc_help.add(desc_cmdline);    
            desc_help.add(desc_generic);
            desc_help.add(desc_ext);
            cout << desc_help << endl;
            return 1;
        }
        
        if (vm.count("version")) {
            return print_version();
        }

        if (vm.count("copyright")) {
            return print_copyright();
        }
        
    // if there is no input file given, then exit
        if (0 == opts.arguments().size()) {
            cerr << "wave: no input file given, "
                 << "use --help to get a hint." << endl;
            return 5;
        }

    // preprocess the given input file
        return do_actual_work(opts, vm);
    }
    catch (std::exception &e) {
        cout << "wave: exception caught: " << e.what() << endl;
        return 6;
    }
    catch (...) {
        cerr << "wave: unexpected exception caught." << endl;
        return 7;
    }
}