#pragma warning (disable:4100)
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/support_ascii.hpp>
#include <boost/spirit/repository/include/qi_confix.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/home/phoenix/bind/bind_function.hpp>
#include <boost/spirit/home/phoenix/bind/bind_member_function.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/qi_eps.hpp>
#include <boost/spirit/include/qi_repeat.hpp>
#include <boost/spirit/repository/include/qi_confix.hpp>
#include <boost/spirit/home/phoenix/object/new.hpp>
#include <boost/shared_ptr.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <fstream>
#include <ostream>
#include <vector>

using std::ostream;
using std::ifstream;
using std::cin;
using std::string;
using std::vector;
using std::cout;
using std::endl;

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace repo = boost::spirit::repository;
using repo::confix;
using boost::phoenix::function;
using boost::phoenix::ref;
using boost::phoenix::val;
using namespace qi::labels;
using qi::grammar;
using qi::rule;
using qi::eps;
using qi::lexeme;
using ascii::char_;
using qi::int_;
using qi::float_;
using qi::double_;
using qi::long_;
using qi::locals;
using ascii::alpha;
using ascii::alnum;
using ascii::graph;
using ascii::print;
using ascii::space;
using ascii::cntrl;
using boost::shared_ptr;
using boost::apply_visitor;
using boost::phoenix::bind;
using boost::phoenix::new_;
using boost::spirit::qi::unused_type;

typedef const char* Iterator;

struct Print
{
    template <typename A>
    struct result
    {
        typedef float type;
    };

    float operator()(const float a) const
    {
        printf_s("float:%f\n", a);
        return a;
    }
};

typedef unsigned char uint8_t;

enum Option
{
    IF_MODE,
    ELSE_MODE,
};

struct MyGrammar : grammar<Iterator, float(), ascii::space_type>
{
    MyGrammar()
       : base_type(Root)
    {
        Root                        = ( qi::float_ )                            [_val = Print(_1)]                  
                                      ; 
    }

    rule<Iterator, float(), ascii::space_type> Root;
    function<Print> Print;
};

void main()
{    
    MyGrammar grammar;
    cout << "Enter floating:" << endl;

    string str;
    while (getline(cin, str))
    {
        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
        {
            break;
        }

        Iterator iter = (Iterator)str.c_str();
        Iterator end = iter + str.length();
        float result;
        bool r = phrase_parse(iter, end, grammar, ascii::space, result);

        if (r && iter == end)
        {
            cout << "Float: " << result << endl;
        }
        else
        {
            string rest(iter, end);
            cout << "-------------------------\n";
            cout << "Parsing failed\n";
            cout << "stopped at: \": " << rest << "\"\n";
            cout << "-------------------------\n";
        }

        cout << "Enter query:" << endl;
    }

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