UNE CALCULATRICE TRAITANT LES CARACTÈRES....

// maDLL.cpp : définit les fonctions exportées pour l'application DLL.
//

#include "stdafx.h"

// Programme créant une calculatrice
//#include <iostream>						// Pour le flot entré sortie
#include <cstdlib>						// Pour la fonction exit()
#include <cctype>						// Pour la fonction isdigit()
using namespace std;

const int MAX = 255;

void eatspace(char * str);
double expr(char* str);					// fonction évaluant une expression arithmétique
double term(char* str, int& index);		// Fonction extrayant la valeur d'un terme
double number(char* str, int& index);	// fonction reconnaissant un nombre dans une chaine
char* extract(char* str, int& index);	// Fonction extrayant une sous-chaine entre parenthèse

extern "C" __declspec(dllexport) double __stdcall calcul(char* buffer)
{
//	char* buffer = {0};		//Zone de stockage de l'expression
	//strcpy_s(buffer,sizeof(texte),texte);
	for(;;)
	{
		eatspace(buffer);
		if(!buffer[0])
			return 0;
		return expr(buffer);
	}
}

char* extract(char* str, int& index)
{
	char buffer[MAX];							//	 Espace temporaire pour une sous chaine
	char* pstr = 0;								//	Pointeur désignant la nouvelle chaine à retourner
	int numL = 0;								//	Nombre de parenthèse gauche
	int bufindex = index;						// Enregistre la valeur de début de l'index
	do
	{
		buffer[index - bufindex] = *(str + index);
		switch(buffer[index - bufindex])
		{
			case ')':
				if(numL == 0)
				{
					buffer[index - bufindex] = '\0'; // Remplacd ')' par '\0'
					++index;
					pstr = new char[index - bufindex];
					if(!pstr)
					{
						//cout << "Erreur d'allocation de mémoire,"
						//	 << " programme terminé.";
						exit(1);
					}
					strcpy_s(pstr,sizeof(buffer), buffer);		// Copy la sous chaine dans la nouvelle mémoire..
					return pstr;
				}		
				else
					numL--;	
				break;
			
			case '(': numL ++;break;			// Augmente le nombre de ( à égaliser
		}
	} while(*(str + index++) != '\0');			// Boucle - ne pas dépasser la fin de la chaine

	exit(1);
	return pstr;
}

void eatspace(char * str)
{//	cout << "\nentrée de eatspace\n";

	int j = 0;		// index source de la chaine
	int i = 0;		// index cible de la chaine
	

	while((*(str + i) = *(str + j++)) != '\0')
		
		if(*(str + i) != ' ')
			i++;
//	cout << "\nsorti de eatspace\n";

	return;
}
	

//fonction reconnaissant un nombre dans une chaine
// ou une expression entre parenthèse
double number(char* str, int& index)
{
	double value = 0.0;									// Stock la valeur résultante
	//cout << "\nentrée de number\n";
	if(*(str + index) == '(')							// Début des parenthèse
	{
		char* psubstr = 0;					// Pointeur de sous chaine
		psubstr = extract(str, ++index);	// Extrait la sous-chaine entre parenthèse
		value = expr(psubstr);				// Extrait la valeur de la sous chaine
		delete[] psubstr;					// Nettoie le tas
		return value;
	}
	// Récupération de la partie entière du nombre
	while(isdigit(*(str + index)))	// 
		value = 10 * value + (*(str + index++) - 48);

	if((*(str + index) != '.')&&(*(str + index) != ','))
		return value;

	double factor = 1.0;
	
	// Récupération de la partie décimal du nombre
	while(isdigit(*(str + (++index))))
	{
		factor *= 0.1;
		value = value + (*(str +index) - 48)*factor;
	}
	
	return value;

}

// Fonction extrayant la valeur d'un terme
double term(char* str, int& index)
{	//cout << "\nentré dans term\n";
	double value = 0.0;			// Cumul du résultat

	value = number(str, index);		//Extrai du 1er nombre du term

	// Itération tant que l'opérateur n'est pas aproprié
	while((*(str + index) == '*') || (*(str + index) == '/'))
	{
		if(*(str + index) == '*')
			value *= number(str, ++index);
		
		if(*(str + index) == '/')
			value /= number(str, ++index);
	}
	//cout << "\nsortie dans term\n";
	return value;
}

//fonction évaluant une expression arithmétique
double expr(char* str)
{	//cout << "\nentré dans expr\n";
	double value = 0.0;				// Stocke le résultat ici
	int index = 0;					// Suit l'emplacement du caractère courant
	value = term(str, index);		// Extrait le premier terme

	for(;;)	// boucle infini
	{
		switch(*(str + index++)) // choisie l'opération à partir du caractère courant
		{
			case '\0': return value;
			case '+' : value += term(str, index); break;//
			case '-' : value -= term(str, index); break;//
			default : 
				exit(1);
		}
	}
//	cout << "\nsorti de expression\n";		
}