Bon, une heure pour pondre cet algorithme, j'aimerais savoir ce que vous en pensez. Ca m'a l'air 100 fois plus sérieux que ma proposition d'hier (déjà à moitié codée, c'est malin, je ferais bien de m'arrêter réfléchir plus...)

MainEval( EXPR )
Si (EXPR n'a pas d'opétateur)
	Alors	EXPR
	Sinon	Eval( arg1 OP arg2 )		// EXPR == arg1 OP arg2
						// arg1 est la première valeur numérique trouvée
						// arg2 est le reste de l'expression, et peut contenir
						// lui-même plusieurs opérations
						// OP est l'opérateur qui les sépare


Eval( arg1 OP arg2 )
Si (arg2 n'a pas d'opérateurs)

	Alors	OP( arg1 , arg2 )

	Sinon	Si Priorite( OP1 ) > Priorite( OP2 )			// On décompose alors arg2 == arg3 OP2 arg4

			Alors	OP1( arg1 , arg3 ) -> arg1		// On résoud l'opérateur prioritaire
				Eval( arg1 OP2 arg4 )			// Récursion terminale, vu qu'on a déjà
									// le premier résultat

			Sinon	OP1( arg1 , Eval( arg3 OP2 arg4 ))	// Là on a Priorite( OP1 ) < Priorite( OP2 )
									// Récursion profonde, vu qu'on a pas encore le
									// résultat de arg1 OP arg2

L'idée est qu'on peut appliquer un opérateur si on en a pas de prioritaire derrière. S'il n'y en a pas, on peut résoudre ce que l'on a trouvé, sinon, il faut attendre d'avoir le résultat suivant pour pouvoir exécuter l'opération.