Discussion :

[SKone]

Bonsoir,
A la découverte de boost::spirit je me suis dit qu'un outil comme celui là ne pourrait qu'accélérer le développement de mes parsers. Mais je n'arrive pas à faire ce dont j'ai besoin. A terme je voudrais faire un parsers de fonction ( C-like ) que je pourrait appeler dans mon code. Les fonctions étant entrées dynamiquement... Bref je n'en suis pas encore là !

Je voudrais simplement appeler une fonction voici mon parser issus d'un exemple que j'essaye d'upgrader :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
typedef std::string::const_iterator	Iterator;
typedef float						TYPE;
 
struct Calculator :
	boost::spirit::qi::grammar< Iterator, TYPE() >
{
	Calculator() :
		Calculator::base_type( expr )
	{
		using boost::spirit::qi::word;
		using boost::spirit::qi::float_;
		using boost::spirit::qi::_1;
		using boost::spirit::qi::_val;
 
		expr =
			term					[ _val =	_1 ]
			>>	*(	'+' >> term		[ _val +=	_1 ]
				|	'-' >> term		[ _val -=	_1 ]
				);
 
		term =
			factor					[ _val =	_1 ]
			>>	*(	'*' >> factor	[ _val *=	_1 ]
				|	'/' >> factor	[ _val /=	_1 ]
				|	'^' >> factor	[ _val = Math::Pow( _val, _1 ) ]
				);
 
		factor =
				float_				[ _val =  _1 ]
			//|	func_call
			|	'(' >> expr			[ _val =  _1 ] >> ')'
			|	'-' >> factor		[ _val -= _1 ]
			|	'+' >> factor		[ _val =  _1 ]
			;
 
		/*func_call =
				word				[ m_sFunctionName = _1() ]
				>> '(' >> -( expr	[ m_oParams.push( _1 ) ]
				>> *( ',' >> expr	[ m_oParams.push( _1 ) ]	) ) >> ')';*/
	}
 
	boost::spirit::qi::rule< Iterator, TYPE() > expr, term, factor/*, func_call*/;
 
private:
	//std::stack< boost::phoenix::actor< boost::spirit::argument< 0 > > >		m_oParams;
	//std::string												m_sFunctionName;
};
 
	// Dans mon Main :
	Calculator oCalc;
	float32 fResult;
	Iterator oBegin = sInput.begin();
	Iterator oEnd = sInput.end();
	bool bRet = parse( oBegin, oEnd, oCalc, fResult );
	if ( bRet )
	{
		cout << sInput << " = " << fResult << endl;
	}

Le problème vient de la ligne qui contient Math:ow(). En effet je ne peux pas faire cela puisque mon Pow prend soit un float, soit un double ou soit un long double. _val est de type : boost::phoenix::actor< boost::spirit::argument< 0 > >. J'ai essayé d'évalué la lambda expression avec l'opérateur (). Mais rien n'y fait je n'arrive toujours pas à retrouver la valeur.

Voilà mon problème. Les opérateurs de base on été surchargées pour les lambdas (+, -, <<, ...). Mais comment faire pour récupérer les valeurs de mes arguments, pour les utiliser avec des types de base du C++ ?

[Arzar]

Bonjour,
Est-ce que tu aurais un exemple *minimale et compilable* reproduisant le problème ? C'est particulièrement difficile avec Spirit de comprendre d’où provient une erreur sans pouvoir essayer et compiler soi-même.

[Arzar]

Ok, j'ai finalement réussi à comprendre quand même.

A la découverte de boost::spirit je me suis dit qu'un outil comme celui là ne pourrait qu'accélérer le développement de mes parsers. Mais je n'arrive pas à faire ce dont j'ai besoin.

Symptomatique de spirit.

Ok, si je prends la ligne de ton code qui cause problème, en remplaçant Math::pow par std::pow :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

|	'^' >> factor	[ _val = std::pow( _val, _1 ) ]

Ce genre de code est impossible. On ne peut pas insérer des fonctions classiques dans les actions de Spirit. Tout simplement car, comme tu l'as découvert, les placeholers comme _val et _1 ont leur propre type qui n'est pas du tout compatible avec std::pow qui attend des double.

Si l'on veut pouvoir insérer ses propres fonctions dans des actions, alors il faut par un moyen ou un autre les wrapper pour en faire des fonctions compatibles phoenix. Le moyen le plus simple pour cela est d'utiliser un binder comme par exemple boost::phoenix::bind.

Il est donc très courant de voir du code comme ci-dessous dans les actions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
using boost::phoenix::bind;
//...
| '^' >> factor     [ _val = bind(&std::pow, _val, _1) ]

Sauf que manque de bol, std::pow est un cas particulier qui ne fonctionne pas directement avec bind. Car en fait ce qu'il se passe c'est que la fonction std::pow possède de nombreuses surcharges différentes (std::pow(double, double), std::pow(float, float), std::pow(int, int) etc) donc bind se plaint car il ne sait pas laquelle de ces surcharges choisir.

La solution est donc en fait ici de caster le pointer de fonction &std::pow vers le type de pointeur de fonction de la surcharge qui nous intéresse, c'est à dire ici double(*)(double, double) au moyen d'un static_cast :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
using boost::phoenix::bind;
//...
| '^' >> factor     [ _val = bind(static_cast<double(*)(double, double)(&std::pow), _val, _1) ]

Et là ça compile.

Une autre solution est de faire son wrapper à la main, sans passer par le raccourci de phoenix::bind :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
struct pow_imp
{
    template <typename Arg1, typename Arg2>
    struct result { typedef Arg1 type; };
 
    template <typename Arg1, typename Arg2>
    Arg1 operator()(const Arg1& arg1, const Arg2& arg2) const
    {
	return std::pow(arg1, arg2);
    }
};
boost::phoenix::function<pow_imp> pow_func;
//...
//...
//...
|	'^' >> factor	[ _val = pow_func( _val, _1 ) ]

[SKone]

Merci. Pour le pow cela fonctionne sans problème. Mais auriez vous une solution pour mes appels de fonction ?
Je voudrais gérer ça avec une pile d'argument (std::stack<float>) et un std::string pour le nom de la fonction. J'ai un manageur de fonction qui avec un std::string me retourne le pointeur de fonction adéquat.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
func_call =
	word			[ m_sFunctionName = _1() ]
	>> '(' >> -( expr	[ m_oParams.push( _1 ) ]
	>> *( ',' >> expr	[ m_oParams.push( _1 ) ]	) )
// Bref ici ce serait un peu plus complexe mais l'idée est là...
	>> ')'			[ _val = bind( &FuncManager[m_sFunctionName], m_oParams.top(), ... )];
	}
 
	boost::spirit::qi::rule< Iterator, TYPE() > expr, term, factor, func_call;
 
private:
	std::stack< float > >		m_oParams;
	std::string				m_oFunctionName;

[jblecanard]

Salut

je fais ça mais j'utilise une structure de donnée dans laquelle sont stockés les appels de fonctions, et ensuite j'exécute. Ca permet par exemple de pouvoir ré-exécuter une fonction sans avoir besoin de repasser par l'étape de parsing.

Mon code est dispo ici : https://github.com/duckie/CppCompactExpressionParser et libre de droit

[SKone]

Ah ! J'ai regardé dans tout les sens votre code et j'aime bien la manière dont vous avez solvé mon problème. Une dernière question. Est-il possible à l'utilisateur de définir une fonction au Run-Time que l'on puisse utilisé au Run-Time. Par exemple avec votre "Master" méthode (celle qui m'intéresse le plus). Je voudrais pouvoir faire un :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Expression oExp;
std::string sInput;
while( true )
{
getline( cin, sInput );
// je remplace mes variables par les fonctions arg0, ... (les UserArg)
// Je voudrais register cette fonction pour pouvoir l'utilisé dans le prochain 
// passage de boucle
}

J'espère que vous voyez ce que je veux dire. Je voudrais savoir si c'est possible.

Merci