Discussion :

[jbat]

Bonjour.

D'ordinaire, pour instancier une structure dans un programme Delphi, il suffit de déclarer la définition de la structure et d'en instancier une variable. Le tout codé en dur dans le source du programme bien sur.

Ma question est la suivante :

Je souhaite instancier une structure dont la définition (MaStruct = record [...mes proprietés...] end) n'est donnée qu'à l'execution.

Entendons-nous bien, le problème n'est pas de stocker ces valeurs en mémoire, ça je sais le faire en passant par d'autres moyens. Ce que je souhaite faire, c'est déclarer la "définition" d'une structure à l'execution (description fournie dans un xml par exemple) puis instancier cette "structure dynamique".

Le but est qu'en mémoire, les données de l'instance de cette "structure dynamique" soient exactement identique à celles qu'auraient été une instance d'une structure normale.

Toute aide sera la bienvenue.

Merci.

Jbat.

[ShaiLeTroll]

Hum, cela peut aller loin, disons, que si ce n'est que pour faire une image de la structure, tu peux allouer via GetMem un bloc mémoire, puis écrire toi même dans ce bloc, les données via des CopyMemory successifs (ne prend que des types finis genre integer ou shortstring, ...)

Peut-être devrait tu expliquer ce que tu veux vraiement faire ?
Si c'est pour envoyer les données vers un Stream sur TCP/IP ou vers un Fichier, et que tu dois absolument avoir un format type structure, c'est vrai que ce n'est pas évident ...

[jbat]

Re

Merci pour ta réactivité.

Voici ce que je souhaite faire.

J'ai un programme qui a est capable d'exploiter des DLL inconnues de lui au moment de sa compilation. Au moment de l'execution, il n'est aidé que par un fichier qui décrit les fonctions exportées ainsi que l'ordre et les types des arguments de chaque fonction. Pour transférer des valeurs simples, mon programme dépose simplement sur la pile (via des instructions assembleur) les valeurs requises en fonction de la convention d'appel spécifiée (stdcall, register, etc...).
Tant qu'il s'agit de types simples, il est possible de les empiler. Sauf qu'aujourd'hui, nous souhaitons pouvoir passer des tableaux ou des structures voir des tableaux de structures etc... Bref, des types élaborés pour nous permettre de nous interfacer avec des DLL plus complexes.

Notre hypothèse est que les types élaborés ne sont pas transmis directements sur la pile, mais leur ce serait leur pointeur qui est empilé (et en plus, nous n'en sommes même pas sur). La DLL récupèrera donc ce pointeur et sera en mesure d'utiliser la structure. Encore faut-il que nous ayons instancié correctement la structure dans notre programme afin de fournir un pointeur pointant vers une zone mémoire correctement formatté en relation avec ce que la DLL s'attends à trouver à l'adresse de ce pointeur.

C'est pourquoi si je déclare la structure dans le code source, tout fonctionne, mais je ne peux pas déclarer la définition de la structure dans le code source car sa définition doit pouvoir être donnée par un fichier externe.

Voilà pourquoi je voudrait instancier une "structure dynamique"... Je ne suis pas sur d'avoir été clair

[ShaiLeTroll]

Lol, le Modèle COM n'est pas justement là pour cela ? avec les Bibliothèques de Type ?

ces DLL, tu en seras l'auteur ou elles devront suivre le modèle imposé ? ou alors n'importe quel DLL devra pourvoir être utilisée ?

Pour ne pas echanger entre ton programme et ces DLL, des buffers XML (principe du SOAP) ... même si ton défit de programmation est très interessant (si je n'avais que cela à faire, ça me ferait bien plaisir de faire ce genre de dev ...) mais tu risque de partir dans quelques d'assez compliqué ...

Sinon, il faut que tu définisse un protocole de données mis à plat, comme on le ferait pour un echange de données via TCP\IP, ...

As-tu songé à de la génération de code automatique pour générer une sorte de connecteur entre la DLL et ton Exe ? ou au DelphiScript ?

[jbat]

Bonjour.

Je ne connais pas toutes les techniques que tu proposes en lieu et place de l'architecture actuelle et je serait joyeux de pouvoir les mettre en place - je n'aime pas trop faire de la programmation à l'ancienne - , mais le programme existait déjà avant que je ne rejoigne ce projet et il ne faut surtout pas changer ce qui "fonctionne"...
Qui plus est, pour répondre à ta question, il faudrait que le programme soit capable d'exploiter n'importe quelle DLL, qu'elle ai été développée en interne ou à l'externe.

[ShaiLeTroll]

D'accord,

"il ne faut surtout pas changer ce qui "fonctionne"... ", c'est le principe du TPCM (touche pas, ça marche) de Pleinpopossum ...

Alors, effectivement, si cela doit être compatible avec n'importe quelle DLL, tu dois passer par de l'écriture mémoire dans un bloc (GetMem, CopyMemory, FreeMem) ... en fait tu veux faire un principe de RTTI dynamique ... tu devrais lire "Enregistrement de record non finalisé", pour maitriser la gestion d'un record à la main, faut que tu maitrise déjà parfait leur fonctionnement (initialization, libération, alignement mémoire, ...), d'ailleurs, si SJRD pouvait faire un tour dans ce sujet ... il devrait pouvoir nous donner des idées (voire une lib déjà prête ... )

[Aka Guymelef]

Bon je ne sais pas si cela va convenir mais je vais quand même exposé une solution que l'on avait mis en place dans mon ancienne entreprise et que je trouvais vraiment sympa.

L'idée est d'utiliser les Variants mais surtout le fait qu'un Variant puisse être un tableau de Variant (voir la routine VarArrayCreate). L'idée est que la DLL ne prennent qu'un seul paramètre de type OleVariant qui est en fait un tableau de Variant créé dynamiquement.

Côté expéditeur on dispose d'une classe qui permet d'ajouter un élément (paire nom:String/valeur:Variant) et une méthode d'export qui va compacter les éléments dans une variable Variant stockant un tableau de Variant. La méthode d'export va donc créé un tableau du nombre d'élément puis remplir chaque case avec un autre tableau de variant contenant deux cases : une pour le nom et l'autre pour la valeur.

Côté receveur on dispose d'une classe qui décompacte le tableau en le parcourant (grâce au fonctions Low et High) et pour chaque case du premier tableau on prend le tableau qu'elle contient et on extrait d'une part le nom et d'autre part la valeur, chaque couple étant réinjectée dans une collection avec des méthodes pour obtenir une valeur suivant le nom etc...

Et inversement pour envoyer des réponses