Spirit2 test: OSM bounds

#include "stdafx.h"
#include <windows.h>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>

namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

double minlat = 1000;
double maxlat = -1000;
double minlon = 1000;
double maxlon = -1000;

#define min(a, b)  (((a) < (b)) ? (a) : (b))
#define max(a, b)  (((a) > (b)) ? (a) : (b))

void update_lat(double lat)
{
    minlat = min(lat, minlat);
    maxlat = max(lat, maxlat);
}

void update_lon(double lon)
{
    minlon = min(lon, minlon);
    maxlon = max(lon, maxlon);
}

template <typename Iterator>
struct osm_parser : qi::grammar<Iterator>
{
        osm_parser() : osm_parser::base_type(start)
        {
            using qi::lit;
            using qi::double_;
            using qi::lexeme;
            using ascii::char_;
            using qi::lower;
            p_anychar = char_('\x80','\x7F');
            p_lat = "lat=\"" >> double_ [&update_lat] >> '"';
            p_lon = "lon=\"" >> double_ [&update_lon] >> '"';
            p_param = +lower >> "=\"" >> +(p_anychar - '"') >> '"';
            p_ws = *(' ' | lit('\n') | '\t');
            p_until_node_closed = "</node>" | (p_anychar >> p_until_node_closed);
            p_endnode = "/>" | p_until_node_closed;
            p_node_param = p_lat | p_lon | p_param;
            p_node = "<node" >> *(p_ws >> p_node_param) >> p_endnode;
            p_tag = '<' >> *(p_anychar - '>') >> '>';
            start = *((p_node | p_tag) >> p_ws);
        }

        qi::rule<Iterator> p_lat, p_lon, p_ws, p_until_node_closed, p_endnode, p_node_param;
        qi::rule<Iterator> p_param, p_node, p_tag, p_anychar, start;
};

int _tmain(int argc, _TCHAR* argv[])
{
    if (argc < 2)
    {
        std::cerr << "Usage: bounds osmfile" << std::endl;
        return 1;
    }
    std::ifstream f(argv[1]);
    f.seekg(0, std::ios::end);
    size_t size = f.tellg();
    std::string storage(size, ' ');
    f.seekg(0);
    f.read(&storage[0], size);

    typedef std::string::const_iterator iterator_type;
    osm_parser<iterator_type> p_osm;
    std::string::const_iterator iter = storage.begin();
    std::string::const_iterator end = storage.end();
    LARGE_INTEGER t0, t1, fr;
    QueryPerformanceCounter(&t0);
    bool r = parse(iter, end, p_osm);
    QueryPerformanceCounter(&t1);
    QueryPerformanceFrequency(&fr);
    double t = (double)(t1.QuadPart - t0.QuadPart) / (double)fr.QuadPart;

    if (r && iter == end)
    {
        printf("Ok. lat=%lf..%lf lon=%lf..%lf\ntime=%lf\n", minlat, maxlat, minlon, maxlon, t);
    }
    else
    {
        std::cout << "\nParsing failed:\n";
        int n=30;
        while(iter != end && n-->0)
            std::cout << *iter++;
    }
    return 0;
}