Bon, j'ai réussi à coucher un algo qui me semble complet (manque juste les labels, mais c'est rien, c'est résoudru par ailleurs.

Ce qui me fait suer, c'est que l'algo de PpHd me semble mieux en vitesse et en mémoire, mais j'aimerais bien essayer le mien (qui devrait rester rapide pour les expressions simples, ie dans 99% des cas).

IMM , Ptr_apres_EXPR MainEval( EXPR )
Si (EXPR n'a pas d'opetateur)
 
	Alors	Si (EXPR termine par une parenthese fermante)
			BR_COUNT--				// Erreur si <0
		EXPR -> IMM					// Il ne s'agit que d'un chiffre ou d'un symbole à lire
 
	Sinon	EXPR -> arg1 OP arg2				// On décompose EXPR 
								// arg1 est la premiere valeur numerique trouvee
								// arg2 est le reste de l'expression, et peut contenir 
								// lui-meme plusieurs opérations
								// OP est l'operateur qui les sépare
		Eval( arg1 OP arg2 ) 




IMM Eval( arg1 OP arg2 ) 
Si (arg2 commence par une parenthese)
 
	Alors	BR_COUNT++
		MainEval( arg2 ) -> arg2						// On stocke le resultat
		Si (Operateur_apres_parenthese)						// Du boulot apres la parenthese ?

			Alors Si( Priorite( OP ) < Priorite(Operateur_apres_parenthese)	// Si c'est prioritaire

				Alors	arg2 -> arg3 OP2 arg4				// On decompose
					OP( arg1, Eval( arg3 OP2 arg4 ))		// Et on appelle dans le bon ordre

				Sinon Eval( OP1( arg1, arg2 ) OP2  arg3)		// Sinon on resoud la premiere operande
											// avec le resultat de la parenthese
			Sinon OP( arg, arg2 )						// Si il n'y a rien apres la parenthese,
											// on a une simple operation a faire

 
Si (arg2 n'a pas d'opérateur) 
 
	Alors	OP( arg1, arg2 ) 
 
	Sinon	arg2 -> arg3 OP2 arg4 					// On decompose alors arg2 == arg3 OP2 arg4
		Si Priorite( OP1 ) > Priorite( OP2 ) 
 
			Alors	OP1( arg1 , arg3 ) -> arg1		// On resoud l'operateur prioritaire
				Eval( arg1 OP2 arg4 )			// Recursion terminale, vu qu'on a deja
									// le premier resultat
 
			Sinon	OP1( arg1 , Eval( arg3 OP2 arg4 ))	// La on a Priorite( OP1 ) < Priorite( OP2 )
									// Recursion profonde, vu qu'on a pas encore le
									// resultat de arg1 OP arg2
 
 
arg1 est une valeur numerique
arg2 est un pointeur la suite de l'expression 
OP est un tag

Ca me semble bon, même si c'est sûrement trop complexe. Mais je verrai ça demain, à tête reposée. En tout cas, je suis rassuré d'avoir la solution de PpHd au cas où, même si j'aime bien essayer de me démerder.

En tout cas, un grand merci à tous.