Usando Iterator analisar com boost :: Espírito Gramáticas

Question

Quando tento usar o formulário de iterador de análise para uma gramática Espírito recebo um argumento passando erro de conversão do tipo de iterador para const char *. Como faço para corrigir isso?

Existem algumas restrições. Eu estou usando um adaptador de iterador em grandes entradas, por isso não é viável para me converter para uma string estilo C.

Aqui está o código de exemplo que demonstra o 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 com: erro: não pode converter const boost::spirit::file_iterator<char_t, boost::spirit::fileiter_impl::mmap_file_iterator<char_t> > para const char* de passagem argumento

Answer 1

É difícil dizer a partir do código conforme publicado, uma vez que contém alguns erros básicos. Após a correção destes, ele compila bem na minha máquina (com 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

Aqui está uma maneira de obter o char * 's apontando para os mesmos elementos que os iteradores:

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

Eu não sei como você conseguiu isso para compilar entanto:

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

Answer 3

O erro de compilação não estava no exemplo fornecido. Na gramática acima não tenho ações semânticas, enquanto no código que eu estava simplificando eu fiz.

As chamadas de retorno para as acções de char * utilizados em vez da iteração tipo I foi de utilizar.

Answer 4

Você pode tentar certificar-se de que suas ações semânticas foram polimórficos do tipo do argumento. Precisamente no código que você iria querer algo parecido com isto:

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

Você usaria uma ação semântica unário assim como mostrado abaixo:

real_p[my_action()]

Ou se você precisava de uma ação semântica binário, você faria 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()]