Digamos que tengo un código como este (números de línea para referencia):

1:
2:function FuncName_1 {
3:    var Var_1 = 3;
4:    var  Var_2 = 4;
5:    ...

Quiero escribir una gramática que analice dicho texto, ponga todos los identificadores (nombres de funciones y variables) en un árbol (¿utree?). Cada nodo debe conservar: line_num, column_num y el valor del símbolo. ejemplo:

root: FuncName_1 (line:2,col:10)
  children[0]: Var_1 (line:3, col:8)
  children[1]: Var_1 (line:4, col:9)

Quiero ponerlo en el árbol porque planeo atravesar ese árbol y para cada nodo debo conocer el 'contexto': (todos los nodos principales de los nodos actuales).

Por ejemplo, mientras se procesa el nodo con Var_1, debo saber que este es un nombre para la variable local para la función FuncName_1 (que actualmente se está procesando como nodo, pero un nivel anterior)

No puedo entender algunas cosas.

¿Se puede hacer esto en espíritu con acciones semánticas y de utree? ¿O debería usar variante <> árboles?¿Cómo pasar al nodo esas tres informaciones (columna, línea, nombre de símbolo) al mismo tiempo? Sé que debo usar pos_iterator como tipo de iterador para la gramática, pero ¿cómo acceder a esa información en acción semática?

Soy un novato en Boost, así que leo la documentación del Spirit una y otra vez. Intento buscar mis problemas en Google, pero de alguna manera no puedo juntar todas las piezas para encontrar la solución. Parece que no había nadie con un caso de uso como el mío antes (o simplemente no puedo encontrarlo) Parece que las únicas soluciones con iterador de posición son las que manejan los errores de análisis, pero este no es el caso. Estoy interesado en. El código que solo analiza el código que estaba tomando está abajo, pero no sé cómo seguir adelante.

  #include <boost/spirit/include/qi.hpp>
  #include <boost/spirit/include/support_line_pos_iterator.hpp>

  namespace qi = boost::spirit::qi;
  typedef boost::spirit::line_pos_iterator<std::string::const_iterator> pos_iterator_t;

  template<typename Iterator=pos_iterator_t, typename Skipper=qi::space_type>
  struct ParseGrammar: public qi::grammar<Iterator, Skipper>
  {
        ParseGrammar():ParseGrammar::base_type(SourceCode)
        {
           using namespace qi;
           KeywordFunction = lit("function");
           KeywordVar    = lit("var");
           SemiColon     = lit(';');

           Identifier = lexeme [alpha >> *(alnum | '_')];
           VarAssignemnt = KeywordVar >> Identifier >> char_('=') >> int_ >> SemiColon;
           SourceCode = KeywordFunction >> Identifier >> '{' >> *VarAssignemnt >> '}';
        }

        qi::rule<Iterator, Skipper> SourceCode;
        qi::rule<Iterator > KeywordFunction;
        qi::rule<Iterator,  Skipper> VarAssignemnt;
        qi::rule<Iterator> KeywordVar;
        qi::rule<Iterator> SemiColon;
        qi::rule<Iterator > Identifier;
  };

  int main()
  {
     std::string const content = "function FuncName_1 {\n var Var_1 = 3;\n var  Var_2 = 4; }";

     pos_iterator_t first(content.begin()), iter = first, last(content.end());
     ParseGrammar<pos_iterator_t> resolver;    //  Our parser
     bool ok = phrase_parse(iter,
                            last,
                            resolver,
                            qi::space);

     std::cout << std::boolalpha;
     std::cout << "\nok : " << ok << std::endl;
     std::cout << "full   : " << (iter == last) << std::endl;
     if(ok && iter == last)
     {
        std::cout << "OK: Parsing fully succeeded\n\n";
     }
     else
     {
        int line   = get_line(iter);
        int column = get_column(first, iter);
        std::cout << "-------------------------\n";
        std::cout << "ERROR: Parsing failed or not complete\n";
        std::cout << "stopped at: " << line  << ":" << column << "\n";
        std::cout << "remaining: '" << std::string(iter, last) << "'\n";
        std::cout << "-------------------------\n";
     }
     return 0;
  }