Utilizando el análisis de iterador con Boost :: Spirit gramáticas

Question

Cuando intento utilizar la forma iterador de análisis sintáctico para una gramática Espíritu consigo un argumento que pasa error de conversión del tipo de iterador a const char *. ¿Cómo puedo solucionar esto?

Existen algunas restricciones. Estoy usando un adaptador iterador en grandes entradas, por lo que no es factible para mí a convertir en una cadena estilo C.

Aquí está el código de ejemplo que demuestra el problema:

#include <boost/spirit/core.hpp>
#include <boost/spirit/iterator/file_iterator.hpp>
#include <vector>
#include <string>
using std;
using boost::spirit;
struct ex : public grammar<route_grammar> {
  template <typename ScannerT> struct defintion {
    definition(ex const& self) {
      expression = real_p; 
    }
    rule<ScannerT> expression;
    rule<ScannerT> const& start() const { return expression; }
};

int main() {
  file_iterator<char> first;
  file_iterator<char> last = first.make_end();
  ex ex_p;
  parse_info<file_iterator<char> > info = parse(first, last, ex_p, space_p);
  return 0;
}

Este código rompe con: Error: No se puede convertir a const boost::spirit::file_iterator<char_t, boost::spirit::fileiter_impl::mmap_file_iterator<char_t> > const char* en el argumento que pasa

Answer 1

difícil saber a partir del código tal como fue anunciado, ya que contiene algunos errores básicos. Después de la corrección de éstos, que compila bien en mi máquina (con MSVC ++ 7.1):

#include <boost/spirit/core.hpp>
#include <vector>
#include <string>
using namespace std;
using namespace boost::spirit;
struct ex : public grammar<ex> {
template <typename ScannerT> 
struct definition {
    definition(ex const& self)
    {
    expression = real_p; 
    }
    rule<ScannerT> expression;
    rule<ScannerT> const& start() const { return expression; }
};
};

int main() {
vector<char> v;
v.push_back('3'); v.push_back('.'); v.push_back('2');
ex ex_p;
parse_info<vector<char>::iterator> info = parse(v.begin(), v.end(), ex_p, space_p);
return 0;
}

Answer 2

Esta es una manera de conseguir el char * 's apuntando a los mismos elementos que los iteradores:

&v.front() // v.begin()
&v.back() + 1 // v.end()

No estoy seguro de cómo lo que tienes Esto permite compilar sin embargo:

vector<char> v;
v.push_back("3.2");

Answer 3

El error de compilación no estaba en la muestra proporcionada. En la gramática anterior no tengo acciones semánticas, mientras que en el código que estaba simplificando lo hice.

Las devoluciones de llamada para esas acciones utilizadas char * en lugar del tipo de iterador que estaba usando.

Answer 4

Usted puede tratar de asegurarse de que sus acciones semánticas fueron polimórficos en el tipo del argumento. Precisamente en el código que te gustaría algo como esto:

struct my_action {
  template <class ParamType>
  void operator()(ParamType const & parameter) const {
    // deal with parameter
  }
};

Se podría utilizar una acción semántica unario como éste, como se muestra a continuación:

real_p[my_action()]

O si se necesitaba una acción semántica binario, que haría algo como:

struct binary_action {
  template <class ParamType>
  void operator()(ParamType const & param1, ParamType const & param2) const {
    // deal with either parameter
  }
};

(*char_p)[binary_action()]