Voilà j'ai un grand nombre de DLL mathématiques compilées ainsi que les fichiers "*.h" (en C) décrivants les signatures de chaque fonction de chaque DLL. Pour ne pas arranger les choses, la liste des DLL doit pouvoir évoluer (sorte de plugins).

Donc ce que je veux faire, c'est, à l'exécution, demander à l'utilisateur le nom d'une DLL, puis d'une fonction, puis des valeurs de chaque paramètre.
Ensuite, je fais les étapes suivantes :

- charger la DLL dont le nom n'est connu qu'à l'exécution (je sais faire)
- pointer vers la fonction dont le nom n'est connu qu'à l'exécution (je sais faire)
- convertir chaque paramètre depuis une chaîne de caractères vers le bon type (connu aprés analyse des fichiers "*.h") (je sais faire)
- appeller la fonction (c'est là ou ça coinçe)

Grand pb. s'il en est !

Donc mon idée est d'allouer à l'exécution une zone mémoire exécutable
et d'y écrire (à la brutos) les prologues & épilogues ASM ainsi qu'un simple call vers la fonction de la DLL ; et ce pour chaque fonction, une fois que je connais le nom de la DLL.

En gros c'est le problème classique d'appel de fonctions entre un monde "interprétée" et un monde "compilée" (mais je veux une solution légère et simple à mettre en oeuvre).

Je penses que ma méthode est viable, et je ne vois pas comment faire mieux. Mais est-ce que je risque des "General Protection Fault" (comment rendre mon code plus sur ?). En effet, est-ce que cela ne me posera des pbs. si les DLLs utilisent des technos avancées comme C++ mangling, COM+, exceptions (C++, structurées), ... Quand est-il des calling conventions, ... ?

Je penses qu'un simple lien vers une présentation des prologue & épilogues "classiques" (par convention d'appel) pour proc x486 serait d'un grand secours.