//  Copyright (c) 2001-2010 Hartmut Kaiser
// 
//  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)

//  This example is the equivalent to the following lex program:
//
//     %{
//     #include <stdio.h>
//     %}
//     %%
//     [0-9]+   { printf("%s\n", yytext); }
//     .|\n     ;
//     %%
//     main()
//     {
//             yylex();
//     }
//
//  Its purpose is to print all the (integer) numbers found in a file

#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

#include <iostream>
#include <string>

#include "example.hpp"

using namespace boost::spirit;

///////////////////////////////////////////////////////////////////////////////
//  Token definition: We use the lexertl based lexer engine as the underlying 
//                    lexer type.
///////////////////////////////////////////////////////////////////////////////
template <typename Lexer>
struct print_numbers_tokens : lex::lexer<Lexer>
{
    // define tokens and associate it with the lexer, we set the lexer flags
    // not to match newlines while matching a dot, so we need to add the
    // '\n' explicitly below
    print_numbers_tokens()
      : print_numbers_tokens::base_type(lex::match_flags::match_not_dot_newline)
    {
        this->self = lex::token_def<int>("[0-9]*") | ".|\n";
    }
};

///////////////////////////////////////////////////////////////////////////////
//  Grammar definition
///////////////////////////////////////////////////////////////////////////////
template <typename Iterator>
struct print_numbers_grammar : qi::grammar<Iterator>
{
    print_numbers_grammar()
      : print_numbers_grammar::base_type(start)
    {
        // we just know, that the token ids get assigned starting min_token_id
        // so, "[0-9]*" gets the id 'min_token_id' and ".|\n" gets the id
        // 'min_token_id+1'.
        start =  *(   qi::token(lex::min_token_id)  [ std::cout << _1  << "\n" ] 
                  |   qi::token(lex::min_token_id+1)
                  )
              ;
    }

    qi::rule<Iterator> start;
};

///////////////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[])
{
    // iterator type used to expose the underlying input stream
    typedef std::string::iterator base_iterator_type;

    // the token type to be used, 'int' is available as the type of the token 
    // attribute and no lexer state is supported
    typedef lex::lexertl::token<base_iterator_type, boost::mpl::vector<int>
      , boost::mpl::false_> token_type;

    // lexer type
    typedef lex::lexertl::lexer<token_type> lexer_type;

    // iterator type exposed by the lexer 
    typedef print_numbers_tokens<lexer_type>::iterator_type iterator_type;

    // now we use the types defined above to create the lexer and grammar
    // object instances needed to invoke the parsing process
    print_numbers_tokens<lexer_type> print_tokens;    // Our lexer
    print_numbers_grammar<iterator_type> print;       // Our parser 

    // Parsing is done based on the the token stream, not the character 
    // stream read from the input.
    std::string str (read_from_file(1 == argc ? "print_numbers.input" : argv[1]));
    base_iterator_type first = str.begin();
    bool r = lex::tokenize_and_parse(first, str.end(), print_tokens, print);

    if (r) {
        std::cout << "-------------------------\n";
        std::cout << "Parsing succeeded\n";
        std::cout << "-------------------------\n";
    }
    else {
        std::string rest(first, str.end());
        std::cout << "-------------------------\n";
        std::cout << "Parsing failed\n";
        std::cout << "stopped at: \"" << rest << "\"\n";
        std::cout << "-------------------------\n";
    }

    std::cout << "Bye... :-) \n\n";
    return 0;
}