Ich versuche Memberfunctionpointer aus einer map mit dem synthesized attribute "_val" zu binden um damit Seiteneffekte auszulösen.
Allerdings kompiliert folgendes nicht.

Eine Grammatik soll folgendes beinhalten:

// grammar Klasse
// initialisiere die map container mit den string <-> Funktionszeiger Paaren

// ...

// Im Konstruktor der Grammatik:
qualifiers =
    eps [_val = _r1] >>  // übernehme bisherigen TypeWrapper und verändere den (Seitenfrage: Gibt es sowas wie pass by reference in rules?)
    *(
        qual // parse sowas wie "const, static, volatile" und gib den string zurück
        [
            // PROBLEM HERE !!!:
            // ich würde ja eigentlich ganz gern an den eigentlich Wert,
            // der sich hinter _1 versteckt, aber das scheint nach meiner recherche
            // nicht so einfach zu gehen.
            // Vorher hatte ich einen Workaround mit einer Membervariable der Grammatik
            // Aber das finde ich absolut hässlich.
            // Ich will aber auch nicht die lazy function binden, sondern den fptr
            // ich hatte auch sowas wie 
            // phoenix::bind(phoenix::bind(&std::map</*...*/>::at, qualifier_neg_getters, _1), _val) 
            // ausprobiert.
            // leider sind das auch keine einfachen phx::val, die man aufrufen könnte um den Wert zu bekommen
            // mir gehen die Ideen aus
            if_(phoenix::bind(phoenix::at(qualifier_neg_getters, _1), _val))   // prüfe ob qualifier von "TypeWrapper" auf false
            [
                phoenix::bind(phoenix::at(qualifier_setters, _1), _val, true)   // setze qualifier von "TypeWrapper" auf true
            ]
            .else_
            [
                _pass = false // qualifier wurde schon geparst (= ist auf true)! -> nicht gültig
            ]
        ]
    )
;

start =
    qualifiers(_val)    [_val = _1] // parse "const", "volatile", "static", "auto", "register"
// ... noch im Aufbau befindlich
;

// end of constructor 
// ...

/// RULES
qi::rule <iterator_type, TypeWrapper(TypeWrapper), ascii::space_type> qualifiers;
qi::rule <iterator_type, TypeWrapper(), ascii::space_type, qi::locals <TypeWrapper> > start;

/// SYMBOLS
type_qualifiers qual;

/// MEMBERS
std::map <std::string, void (TypeWrapper::*)(bool)> qualifier_setters;
std::map <std::string, bool (TypeWrapper::*)() const> qualifier_neg_getters;

// end of grammar class

Ist das Problem oder mein Ziel ersichtlich?