#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/spirit/repository/include/karma_embed.hpp>

namespace karma = boost::spirit::karma;

typedef char byte;
typedef std::back_insert_iterator<std::string> Iterator;
typedef unsigned int size_type;
typedef   signed int integer;

int
main (int argc, char *argv[])
{
  size_type size_;

  karma::rule< Iterator, std::vector<byte>(), karma::locals<size_type> >  pascal_string_;
  karma::rule< Iterator, size_type()>          pascal_string_size_;
  karma::rule< Iterator, std::vector<byte>()>  pascal_string_payload_;
  karma::rule< Iterator, void(size_type)>                     pascal_string_padding_;

  namespace ascii = karma::ascii;
  using boost::phoenix::ref;
  using boost::phoenix::size;
  using boost::spirit::repository::karma::embed;
  using karma::_val;
  using karma::_1;
  using karma::_a;
  using karma::_r1;

  pascal_string_ =
    embed(_a = size(_val))[ pascal_string_size_ ]
    << *karma::byte_
    << pascal_string_padding_(_a)
    ;

  pascal_string_size_ %=
    karma::eps (_val <= 0xFFF)  // guard clause
    << 'h'
    << ascii::upper [ karma::right_align (3, '0')
                      [ karma::int_generator< integer, 16 > () ] ]
    ;

  pascal_string_padding_ %=
    karma::repeat (3 - (_r1 + 3) % 4) [ karma::byte_(0) ]
    ;

  pascal_string_payload_ %=
    karma::repeat (ref (size_)) [ karma::byte_ ]
    ;

  std::vector<byte> v;
  v.push_back ('1');
  v.push_back ('2');
  v.push_back ('3');

  std::string s;

  bool r = karma::generate (std::back_inserter (s), pascal_string_, v);

  std::cout << "'" << s << "'"
            << std::endl;       // expecting 'h0031230'
}