samples/hannibal/hannibal.cpp

//  Hannibal: partial C++ grammar to parse C++ type information
//  Copyright (c) 2005-2006 Danny Havenith
//
//  Boost.Wave: A Standard compliant C++ preprocessor
//  Copyright (c) 2001-2010 Hartmut Kaiser
//
//  http://www.boost.org/
//
//  Distributed under 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)

#define HANNIBAL_DUMP_PARSE_TREE 1
//#define HANNIBAL_TRACE_DECLARATIONS
//#define BOOST_SPIRIT_DEBUG

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include <boost/spirit/include/classic_ast.hpp>
#include <boost/spirit/include/classic_tree_to_xml.hpp>
#include <boost/program_options.hpp>

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

///////////////////////////////////////////////////////////////////////////////
// Include the lexer stuff
#include <boost/wave/cpplexer/cpp_lex_token.hpp>    // token class
#include <boost/wave/cpplexer/cpp_lex_iterator.hpp> // lexer class

///////////////////////////////////////////////////////////////////////////////
//  Include the Hannibal grammar
#include "translation_unit_parser.h"
#include "translation_unit_skipper.h"

using std::vector;
using std::string;
namespace po = boost::program_options;

#if HANNIBAL_DUMP_PARSE_TREE != 0
///////////////////////////////////////////////////////////////////////////////
namespace {

    ///////////////////////////////////////////////////////////////////////////
    //  helper routines needed to generate the parse tree XML dump
    typedef boost::wave::cpplexer::lex_token<> token_type;

    token_type::string_type  get_token_id(token_type const &t)
    {
        using namespace boost::wave;
        return get_token_name(token_id(t)); // boost::wave::token_id(t);
    }

    token_type::string_type get_token_value(token_type const &t)
    {
        return t.get_value();
    }

///////////////////////////////////////////////////////////////////////////////
}   // unnamed namespace
#endif

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

    ///////////////////////////////////////////////////////////////////////////
    // Parse the command line for input files and  (system-) include paths
    // Prints usage info if needed.
    // returns true if program should continue, false if program must stop
    bool parse_command_line( int argc, char *argv[], po::variables_map &vm)
    {
        //
        // Setup command line structure
        po::options_description visible("Usage: hannibal [options] file");
        visible.add_options()
                ("help,h", "show this help message")
                ("include,I", po::value<vector<string> >(),
                    "specify additional include directory")
                ("sysinclude,S", po::value<vector<string> >(),
                    "specify additional system include directory")
                ("define,D", po::value<vector<string> >()->composing(),
                    "specify a macro to define (as macro[=[value]])")
                ("predefine,P", po::value<vector<string> >()->composing(),
                    "specify a macro to predefine (as macro[=[value]])")
                ("undefine,U", po::value<vector<string> >()->composing(),
                    "specify a macro to undefine")
            ;

        po::options_description hidden;
        hidden.add_options()
            ("input-file", "input file");

        po::options_description desc;
        desc.add( visible).add( hidden);

        po::positional_options_description p;
        p.add("input-file", 1);

        //
        // Parse
        po::store(po::command_line_parser(argc, argv).
                options(desc).positional(p).run(), vm);
        po::notify(vm);

        //
        // Print usage, if necessary
        if (!vm.count( "input-file") ||  vm.count( "help"))
        {
            std::cout << visible << std::endl;
            return false;
        }
        else
        {
            return true;
        }
    }

///////////////////////////////////////////////////////////////////////////////
}   // unnamed namespace

///////////////////////////////////////////////////////////////////////////////
// main entry point
int main(int argc, char *argv[])
{
    po::variables_map vm;

    if (!parse_command_line( argc, argv, vm))
    {
        return -1;
    }

   string inputfile = vm["input-file"].as< string>();

// current file position is saved for exception handling
boost::wave::util::file_position_type current_position;

    try {
    //  Open and read in the specified input file.
        std::ifstream instream( inputfile.c_str());
        std::string instring;

        if (!instream.is_open()) {
            std::cerr << "Hannibal: could not open input file: " << inputfile
                      << std::endl;
            return -2;
        }
        instream.unsetf(std::ios::skipws);
        instring = std::string(std::istreambuf_iterator<char>(instream.rdbuf()),
                               std::istreambuf_iterator<char>());

    //  The template boost::wave::cpplexer::lex_token<> is the token type to be
    //  used by the Wave library.
        typedef boost::wave::cpplexer::lex_token<> token_type;

    //  The template boost::wave::cpplexer::lex_iterator<> is the lexer type to
    //  be used by the Wave library.
        typedef boost::wave::cpplexer::lex_iterator<token_type> lex_iterator_type;

    //  This is the resulting context type to use. The first template parameter
    //  should match the iterator type to be used during construction of the
    //  corresponding context object (see below).
        typedef boost::wave::context<
                std::string::iterator,
                lex_iterator_type,
                boost::wave::iteration_context_policies::load_file_to_string
            > context_type;

    // The preprocessor iterator shouldn't be constructed directly. It is
    // to be generated through a wave::context<> object. This wave:context<>
    // object is to be used additionally to initialize and define different
    // parameters of the actual preprocessing (not done here).
    //
    // The preprocessing of the input stream is done on the fly behind the
    // scenes during iteration over the context_type::iterator_type stream.
    context_type ctx (instring.begin(), instring.end(), inputfile.c_str());

    // add include directories to the include path
        if (vm.count("include")) {
            vector<string> const &paths =
                vm["include"].as<vector<string> >();
            vector<string>::const_iterator end = paths.end();
            for (vector<string>::const_iterator cit = paths.begin();
                cit != end; ++cit)
            {
                ctx.add_include_path((*cit).c_str());
            }
        }

    // add system include directories to the include path
        if (vm.count("sysinclude")) {
            vector<string> const &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 additional defined macros
        if (vm.count("define")) {
            vector<string> const &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> const &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> const &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);
            }
        }

    // analyze the input file
    context_type::iterator_type first = ctx.begin();
    context_type::iterator_type last = ctx.end();

    translation_unit_skipper s;

#if HANNIBAL_DUMP_PARSE_TREE != 0
    typedef boost::spirit::classic::tree_parse_info<context_type::iterator_type>
        result_type;
    translation_unit_grammar::rule_map_type rule_map;
    translation_unit_grammar g(&rule_map);

    // parse the input file
    result_type pi = boost::spirit::classic::ast_parse(first, last, g, s);
#else
    typedef boost::spirit::classic::parse_info<context_type::iterator_type>
        result_type;
    translation_unit_grammar g;

    // parse the input file
    result_type pi = boost::spirit::classic::parse(first, last, g, s);
#endif

        if (pi.full) {
            std::cout
                << "Hannibal: parsed sucessfully: " << inputfile << std::endl;

#if HANNIBAL_DUMP_PARSE_TREE != 0
            // generate xml dump from parse tree, if requested
            boost::spirit::classic::tree_to_xml(std::cerr, pi.trees, "", rule_map,
                &get_token_id, &get_token_value);
#endif
        }
        else {
            std::cerr
                << "Hannibal: parsing failed: " << inputfile << std::endl;
            std::cerr
                << "Hannibal: last recognized token was: "
                << get_token_id(*pi.stop) << std::endl;

            using boost::wave::util::file_position_type;
            file_position_type const& pos(pi.stop->get_position());
            std::cerr
                << "Hannibal: at: " << pos.get_file() << "(" << pos.get_line()
                << "," << pos.get_column() << ")" << std::endl;
            return 1;
        }
    }
    catch (boost::wave::cpp_exception const& e) {
    // some preprocessing error
        std::cerr
            << e.file_name() << ":" << e.line_no() << ":" << e.column_no()
            << ": " << e.description() << std::endl;
        return 2;
    }
    catch (boost::wave::cpplexer::lexing_exception const& e) {
    // some lexing error
        std::cerr
            << e.file_name() << ":" << e.line_no() << ":" << e.column_no()
            << ": " << e.description() << std::endl;
        return 2;
    }
    catch (std::exception const& e) {
    // use last recognized token to retrieve the error position
        std::cerr
            << current_position.get_file()
            << "(" << current_position.get_line() << "): "
            << "exception caught: " << e.what()
            << std::endl;
        return 3;
    }
    catch (...) {
    // use last recognized token to retrieve the error position
        std::cerr
            << current_position.get_file()
            << "(" << current_position.get_line() << "): "
            << "unexpected exception caught." << std::endl;
        return 4;
    }
    return 0;
}