Re: X3 employee example with semantic actions

/*=============================================================================
    Copyright (c) 2002-2015 Joel de Guzman

    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)
=============================================================================*/
///////////////////////////////////////////////////////////////////////////////
//
//  A parser for arbitrary tuples. This example presents a parser
//  for an employee structure.
//
//  [ JDG May 9, 2007 ]
//  [ JDG May 13, 2015 ]    spirit X3
//
///////////////////////////////////////////////////////////////////////////////

//#define STRICT 1
//#include <windows.h>
#include <cstddef>
#include <cstdio>
#include <cstdint>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/home/x3.hpp>
#include <boost/spirit/home/x3/support/ast/position_tagged.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/io.hpp>

#include <iostream>
#include <fstream>
#include <string>
#include <complex>
//#include "utility.h"

uintptr_t addr_storage = -1;

namespace client { namespace ast
{
    ///////////////////////////////////////////////////////////////////////////
    //  Our employee struct
    ///////////////////////////////////////////////////////////////////////////
    struct employee
    {
        int age;
        std::string surname;
        std::string forename;
        double salary;
    };

    using boost::fusion::operator<<;
}}

// We need to tell fusion about our employee struct
// to make it a first-class fusion citizen. This has to
// be in global scope.

BOOST_FUSION_ADAPT_STRUCT(client::ast::employee,
    age, surname, forename, salary
)

namespace client
{
    ///////////////////////////////////////////////////////////////////////////////
    //  Our employee parser
    ///////////////////////////////////////////////////////////////////////////////
    client::ast::employee emp;

    namespace x3 = boost::spirit::x3;

    struct print_string
    {
        template <typename Context>
        void operator()(Context const& ctx) const
        {
            static int calls = 1;
            printf( "call %d\n", calls );
            ++calls;

            //std::string str =
            //  utility::type2string< decltype( x3::_attr( ctx ) ) >();

            std::string::const_iterator iter = x3::_attr( ctx ).begin();
            std::string::const_iterator end = x3::_attr( ctx ).end();

            printf( "start offset: %x\n", std::addressof( *iter ) - addr_storage );
            printf( "end offset: %x\n", std::addressof( *end ) - addr_storage );

        }
    };

    namespace parser
    {
        namespace x3 = boost::spirit::x3;
        namespace ascii = boost::spirit::x3::ascii;

        using x3::int_;
        using x3::lit;
        using x3::double_;
        using x3::lexeme;
        using ascii::char_;

        x3::rule<class employee, ast::employee> const employee = "employee";

        // raw provides iterators
        auto const quoted_string = x3::raw[ lexeme['"' >> +(char_ - '"') >> '"'] ]
          [client::print_string()];

        auto const employee_def =
            lit("employee")
            >> '{'
            >>  int_ >> ','
            >>  quoted_string >> ','
            >>  quoted_string >> ','
            >>  double_
            >>  '}'
            ;

        BOOST_SPIRIT_DEFINE(employee);
    }
}

////////////////////////////////////////////////////////////////////////////
//  Main program
////////////////////////////////////////////////////////////////////////////
int main( int argc, char **argv )
{
    std::cout << "/////////////////////////////////////////////////////////\n\n";
    std::cout << "\t\tAn employee parser for Spirit...\n\n";
    std::cout << "/////////////////////////////////////////////////////////\n\n";

    char const* filename;
    if (argc > 1)
    {
        filename = argv[1];
    }
    else
    {
        std::cerr << "Error: No input file provided." << std::endl;
        return 1;
    }

    std::ifstream in(filename, std::ios_base::in);

    if (!in)
    {
        std::cerr << "Error: Could not open input file: "
            << filename << std::endl;
        return 1;
    }

    std::string storage; // We will read the contents here.
    in.unsetf( std::ios::skipws ); // No white space skipping!
    std::copy(
        std::istream_iterator<char>(in),
        std::istream_iterator<char>(),
        std::back_inserter(storage) );

    using boost::spirit::x3::ascii::space;
    typedef std::string::const_iterator iterator_type;
    using client::parser::employee;

    iterator_type iter = storage.begin();
    iterator_type const end = storage.end();

    printf( "storage address: %p\n", storage.data() );
    addr_storage = (uintptr_t)storage.data();
    // column header
    printf( "            0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\n" );
    for ( std::size_t i = 0; i < storage.length(); ++i )
    {
      if ( i%16 == 0 )
      {
        if ( i != 0 ) putchar('\n');
        // row header
        printf( "%8.8xh: ", i );
      }
      printf( "%2.2x ", storage[i] );
    }
    putchar('\n');

    bool r = phrase_parse( iter, end, employee, space );

    if (r && iter == end)
    {
        std::cout << boost::fusion::tuple_open('[');
        std::cout << boost::fusion::tuple_close(']');
        std::cout << boost::fusion::tuple_delimiter(", ");

        std::cout << "-------------------------\n";
        std::cout << "Parsing succeeded\n";
        std::cout << "got: " << client::emp << std::endl;
        std::cout << "\n-------------------------\n";
    }
    else
    {
        std::cout << "-------------------------\n";
        std::cout << "Parsing failed\n";
        std::cout << "-------------------------\n";
    }

    return 0;
}

employee {
66,
"Putin",
"Vladimir",
306000
}