Utilisation des packed records

**ChPr** · 28/01/2020, 13h06

Bonjour à toutes et à tous,

Dans une application j'utilise des packed record pour mes données de travail et d'enregistrements de fichier.

Après avoir , grâce à vous, réussi à compiler et exécuter cette application en 64 bits, je me trouve devant un autre problème : je n'arrive plus à ouvrir mes anciens fichiers créés en environnement 32 bits.

Est-ce que cela peut-être dû aux packed record et si oui, y a-t-il moyen de les redéfinir afin qu'ils acceptent un alignement 32 bits ?

Voilà ce que j'utilisais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 TParamsOpe = packed record     {Liste des paramètres liés à chaque opérateur}
    NoOrdreOpe: SmallInt;                       {Numéro d'ordre de l'opérateur}
    ClasseOpe: SmallInt;                                {Classe de l'opérateur}
    TypeOpe: SmallInt;                     {Type de l'opérateur dans la classe}
    PosOpe: TCoordXY;            {Position de l'opérateur sur le plan "schéma"}
    Int1, Int2, Int3, Int4: SmallInt;               {Paramètres de type Entier}
    Text1: string[14];             {Nom de l'unité pour les entrées et sorties}
    Hierarchique: Boolean;                   {Indique si l'opé est un SuperOpe}
    Hierarchise: Boolean;    {Indique si l'opé est dans un groupe hiérarchique}
    case SmallInt of
 1:(NomOpe: string16;                                      {Nom de l'opérateur}
    Val1, Val2, Val3, Val4, Val5,
    Val6, Val7, Val8, Val9: Extended;               {Paramètres de type Etendu}
    NoOpeSub: array[0..3] of SmallInt; {Numéros des Sub opérateurs d'interface}
                    {[0] est la sortie, [1] à [3] sont les éventuelles entrées}
    NoOpeSup: SmallInt;                                    {Numéro du SuperOpe}
    Test1, Test2, Test3, Test4: Boolean);          {Paramètres de type Booléen}
 2:(Txt: string[NbChrTxt]);{Variant de type string pour les opérateurs "Texte"}
 3:(Interdit: string[NbChrTxt-(43+1)];                         {Zone interdite}
    Text0: string[43]);  {Nom affichage si sortie principale, NomDLL si FctExt}
 4:(Bloque: string[56];
    Text2: string[53];
    AdrFchExcit: PFichierCourbe);
 5:(NomEtat: string16;                                     {Nom de l'opérateur}
    E01, E02: Single;
    SProp: Word;
    PEch: Extended;
    A11, A12, A21, A22, B11, B12, B21, B22: Single;
    C11, C12, C21, C22, D11, D12, D21, D22: Single);
  end;

Cordialement.

Pierre.

**Roland Chastain** · 28/01/2020, 13h28

Bonjour !

Je dirais que le moyen le plus simple de récupérer les anciens fichiers est de les faire convertir par l'ancien programme. Pour ma part, c'est comme ça que je m'y prendrais.

Bonne chance !

**ChPr** · 28/01/2020, 14h15

Envoyé par Roland Chastain

... Je dirais que le moyen le plus simple de récupérer les anciens fichiers est de les faire convertir par l'ancien programme. Pour ma part, c'est comme ça que je m'y prendrais. ...

Certes, j'ai lancé mon application 32 bits sur mon PC 64 bits et y ai ouvert mes anciens fichiers sans problème. Mais de là, comment faire pour les enregistrer sous un format 64 bits, si tant est que ce soit le problème.

Cela voudrait dire que sous win32, dans mon ancienne application, je puisse programmer un packed record compatible 64 bits ???

Une solution autonome ne requérant pas l'ancienne, consisterait à ouvrir mes fichiers avec ma version 64 bits mais avec un packed record 32 bits, mais comment le ferais-je ?

Cordialement.

Pierre

**Roland Chastain** · 28/01/2020, 14h32

Envoyé par ChPr

Certes, j'ai lancé mon application 32 bits sur mon PC 64 bits et y ai ouvert mes anciens fichiers sans problème. Mais de là, comment faire pour les enregistrer sous un format 64 bits, si tant est que ce soit le problème.

Cela voudrait dire que sous win32, dans mon ancienne application, je puisse programmer un packed record compatible 64 bits ???

Eh bien, oui, je pense, à moins qu'il y ait quelque chose qui m'échappe. Il me semble que la seule différence vient des types de données qui ont le même nom mais qui sont en réalité différents, comme integer par exemple. Après, peut-être que je dis n'importe quoi. J'avoue que je ne sais pas vraiment ce que c'est qu'un packed record. Peut-être quelqu'un va-t-il nous l'expliquer.

Sinon, une autre solution serait de passer par un format intermédiaire pour récupérer vos anciens fichiers, un format passe-partout.

**Roland Chastain** · 28/01/2020, 14h44

Pourquoi pas déclarer un type enregistrement avec les mêmes champs, mais non "packed" ?

J'ai juste un doute sur le type PFichierCourbe.

**ChPr** · 28/01/2020, 14h45

Envoyé par Roland Chastain

... Sinon, une autre solution serait de passer par un format intermédiaire pour récupérer vos anciens fichiers, un format passe-partout.

Sauf s'il y a moyen de rendre "compatibles" des "packed record 32 et 64 bits", effectivement, la solution est de passer par un fichier type texte.

Cordialement.

Pierre

**tourlourou** · 28/01/2020, 15h57

Bonjour,
Les pointeurs n'ont pas la même taille dans les 2 environnements (PFichierCourbe en est-il un ?), et j'ai un souvenir étonnant, que je viens de confirmer : pour un souci de compatibilité (inter-OS ?) le type Extended du FPC 64 Bits est codé sur 8 octets au lieu des 10 attendus par l'utilisateur du FPC 32 Bits !

**BeanzMaster** · 28/01/2020, 16h04

Salut le problème vient des propriétés de type "Extended" qui ne sont pas codées sur le même nombre de bits entre 32 et 64bits. Changes les par des "Double" tu devrais ainsi pouvoir ouvrir tes fichiers.

EDIT : cf ici et là

l faut retenir de ceci que ce type n'est donc pas adapté pour les échange de données entre ordinateurs.

Si cela ne marche pas fais le changement en Double recompile ton appli en 32bits et re-sauvegardes tes fichiers. Tu pourras ainsi ouvrir tes fichiers avec ton appli compilée en 64bits
A+

Jérôme

**BeanzMaster** · 28/01/2020, 16h43

Envoyé par Roland Chastain

Eh bien, oui, je pense, à moins qu'il y ait quelque chose qui m'échappe. Il me semble que la seule différence vient des types de données qui ont le même nom mais qui sont en réalité différents, comme integer par exemple. Après, peut-être que je dis n'importe quoi. J'avoue que je ne sais pas vraiment ce que c'est qu'un packed record. Peut-être quelqu'un va-t-il nous l'expliquer.

Salut la différence en un Record et un packed record c'est que le Record sera aligné en mémoire ; le compilateur pour rajouter des octets pour y parvenir, ce qui permettra d'accélérer les accès en mémoire, tandis le packed record prendra exactement le nombre d'octets qu'il contient. Moins de place en mémoire mais les performances d'accès sont réduit.
il est d'usage lors de l'utilisation d'un record de placer ses propriétés suivant leur taille dans l'ordre descendant : du plus grand au plus petit.

Note FPC dispose d'un commande préprocesseur : {$PackRecords X} pour contrôler l'alignement des données dans un "record"

A+

Jérôme

**tourlourou** · 28/01/2020, 18h23

Je viens de voir cette unité pour Delphi qui ajoute un type TExtendedX87 compatible avec le Extended du 32 Bits. A tester !

**ChPr** · 28/01/2020, 18h25

Envoyé par BeanzMaster

Salut le problème vient des propriétés de type "Extended" qui ne sont pas codées sur le même nombre de bits entre 32 et 64bits. Changes les par des "Double" tu devrais ainsi pouvoir ouvrir tes fichiers. ...

Dans la version 32 bits ou 64 bits ?

Si les "double" en 64 bits occupent 10 octets, alors cela fonctionnerait, mais je suppose que c n'est pas le cas. Existe-t-il un type de variable sur 10 octets dans la version 64 bits ?

Envoyé par BeanzMaster

... Si cela ne marche pas fais le changement en Double recompile ton appli en 32bits et re-sauvegardes tes fichiers. Tu pourras ainsi ouvrir tes fichiers avec ton appli compilée en 64bits ...

Pour que cela fonctionne, il faut que j'ouvre un fichier dans la version 32 bits, et dans cette version, le recoder avec un nouveau packed record contenant des double à la place des extended. Je vais voir si c'est possible.

Après cela, est-ce que, comme le dit tourlourou, je ne vais pas avoir de problème avec les variables de type pointeur?

Cordialement.

Pierre.

**BeanzMaster** · 28/01/2020, 20h38

Envoyé par ChPr

Dans la version 32 bits ou 64 bits ?

Si les "double" en 64 bits occupent 10 octets, alors cela fonctionnerait, mais je suppose que c n'est pas le cas. Existe-t-il un type de variable sur 10 octets dans la version 64 bits ?

En 32 bits le type Extended est codé sur 80 bits en 64 bits ce type n'existe pas et il est "remplacé" par le type Double, et non il n'existe par de type codée sur 10 octets, mis à part tester l'unité cité par Tourlourou, mais il y a des limitations donc se ne sera pas 100% compatible, et dis toi que c'est la même chose avec Delphi

En 64 bits, il n'y a pas * de support pour le type "Extended", le type Extended est interprété comme double, car l'ABI le prescrit (enfin du moins Microsoft surtout) mais il n'est pas conseiller de faire fonctionner le FPU avec du code 64 bits.

l'autre solution serait de tester avec le type Currency ou sinon tu peux lire tes valeurs avec "TExtended80Rec" (cf ci-dessous) mais ensuite il te faudra extraire la partie entière et fractionnaire, bref donc retour à la solution de Tourlourou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Type
 { Types réels:
****A point flottant:
******Simple (Single)   32 bits : 7-8 chiffres significatifs
******Double (Double)   64 bits : 15-16 chiffres significatifs
******Etendu (Extended) 80 bits : 19-20 chiffres significatifs
 
****A point fixe:
******Devise (Currency) 64 bits : 19-20 chiffres significatifs, 4 après la virgule décimale.
 }
 
  TExtended80Rec = Packed Record
    Case Integer Of
      1: (Bytes: Array[0..9] Of Byte);
      2: (Float: Extended);
  End;

avec l'unité proposée uTExtendedX87.pas

juste de voir, ça, bonjour la galère pour assigner des valeurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 var
  x1: TExtendedX87
  begin
  //Instead of: x1:= -666.666;
  TExtendedX87(x1).Frac:= $A6AA9FBE76C8B439;
  TExtendedX87(x1)._Exp:= $C008;
  end;

Envoyé par ChPr

Pour que cela fonctionne, il faut que j'ouvre un fichier dans la version 32 bits, et dans cette version, le recoder avec un nouveau packed record contenant des double à la place des extended. Je vais voir si c'est possible.

Oui c'est cela et c'est une procedure assez simple (une simple copie). le seul problème c'est si tes nombres dépasse l'intervalle possible pour le type "Double". Pour ma part je changerai le extended en double dans version 32 bits, referait les calcul et enregistrerais le fichier, plutôt que de convertir bêtement au risque de perdre en précision

Envoyé par ChPr

Après cela, est-ce que, comme le dit tourlourou, je ne vais pas avoir de problème avec les variables de type pointeur?

Je suppose que tu fais allusion à "AdrFchExcit: PFichierCourbe" comment est déclaré PFichierCourbe ? à quoi correspond ce pointeur ??? je ne vois pas l’intérêt de sauvegarder une adresse mémoire ???

A+

Jérôme

**ChPr** · 29/01/2020, 09h48

Envoyé par BeanzMaster

... Je suppose que tu fais allusion à "AdrFchExcit: PFichierCourbe" comment est déclaré PFichierCourbe ? à quoi correspond ce pointeur ??? je ne vois pas l’intérêt de sauvegarder une adresse mémoire ???

Les pointeurs de mon packed record ne servent à rien dans la sauvegarde des fichiers, mais j'utilise aussi en interne cette même structure. Je pense que ça va bien m'embêter ...

Cordialement.

Pierre

**BeanzMaster** · 29/01/2020, 17h23

Envoyé par ChPr

Les pointeurs de mon packed record ne servent à rien dans la sauvegarde des fichiers, mais j'utilise aussi en interne cette même structure. Je pense que ça va bien m'embêter ...

Cordialement.

Pierre

Salut

Bon, la sauvegarde devrait donc bien se passé. Ensuite pour les pointeur, il ne devrait pas t'embêter non plus. Si non l'idée serait de déclarer 2 structures distinctes.

A+

Jérôme

**ChPr** · 29/01/2020, 18h03

Envoyé par BeanzMaster

... Bon, la sauvegarde devrait donc bien se passé. Ensuite pour les pointeur, il ne devrait pas t'embêter non plus. Si non l'idée serait de déclarer 2 structures distinctes. ...

J'ai essayé en passant pas des fichiers texte ... pas concluant.
J'ai essayé en remplaçant dans les packed record sous xwin32 xx: Extended; par xx:Double; xxx:Word; pour conserver le même nombre de bits et les mêmes décalages : le transfert vers win64 a fonctionné pour des fichiers très simples seulement.

Le problème vient en fait de l'utilisation des variants : selon les types d'opérateurs (plusieurs dizaines) ce n'est pas le même variant que j'utilise. Donc pour le passage d'un type de packed record à un autre ou bien par fichiers texte, il faut que je distingue chaque type d'opérateurs pour choisir le bon variant : ça devient une usine à gaz

et, vu le petit nombre de fichiers que je veux passer en win64, j'aurai plus vite fait de les recréer un à un dans mon win64.

Donc, il y a certainement une solution, mais elle est trop lourde pour ce que je veux faire.

En clair et en deux mots : j'abandonne !

Cordialement.

Pierre.

**BeanzMaster** · 29/01/2020, 18h18

Envoyé par ChPr

J'ai essayé en passant pas des fichiers texte ... pas concluant.
J'ai essayé en remplaçant dans les packed record sous xwin32 xx: Extended; par xx:Double; xxx:Word; pour conserver le même nombre de bits et les mêmes décalages : le transfert vers win64 a fonctionné pour des fichiers très simples seulement.

Le problème vient en fait de l'utilisation des variants : selon les types d'opérateurs (plusieurs dizaines) ce n'est pas le même variant que j'utilise. Donc pour le passage d'un type de packed record à un autre ou bien par fichiers texte, il faut que je distingue chaque type d'opérateurs pour choisir le bon variant : ça devient une usine à gaz

et, vu le petit nombre de fichiers que je veux passer en win64, j'aurai plus vite fait de les recréer un à un dans mon win64.

Donc, il y a certainement une solution, mais elle est trop lourde pour ce que je veux faire.

En clair et en deux mots : j'abandonne !

Cordialement.

Pierre.

Effectivement, il y a une solution la RTTI

L'autre solution vu que tu as plusieurs états dans ton Record

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1:(NomOpe: string16;                                      {Nom de l'opérateur}
    Val1, Val2, Val3, Val4, Val5,
    Val6, Val7, Val8, Val9: Extended;               {Paramètres de type Etendu}
    NoOpeSub: array[0..3] of SmallInt; {Numéros des Sub opérateurs d'interface}
                    {[0] est la sortie, [1] à [3] sont les éventuelles entrées}
    NoOpeSup: SmallInt;                                    {Numéro du SuperOpe}
    Test1, Test2, Test3, Test4: Boolean);          {Paramètres de type Booléen}
 2:(Txt: string[NbChrTxt]);{Variant de type string pour les opérateurs "Texte"}
 3:(Interdit: string[NbChrTxt-(43+1)];                         {Zone interdite}
    Text0: string[43]);  {Nom affichage si sortie principale, NomDLL si FctExt}
 4:(Bloque: string[56];
    Text2: string[53];
    AdrFchExcit: PFichierCourbe);
 5:(NomEtat: string16;                                     {Nom de l'opérateur}
    E01, E02: Single;
    SProp: Word;
    PEch: Extended;
    A11, A12, A21, A22, B11, B12, B21, B22: Single;
    C11, C12, C21, C22, D11, D12, D21, D22: Single);

C'est de tout écrire dans tes fichiers. peux tu nous fournir le code de tes procedures de chargement et de sauvegarde, stp.

A+

Jérôme

**BeanzMaster** · 29/01/2020, 20h23

J'ai regardé de plus près ton enregistrement, et j'ai fait une petite application test basique avec plusieurs méthodes de lecture et d'écriture d'un enregistrement RecordTest.zip le réel problème vient surtout des chaines de caractères, présentent dans ton record.

A mon avis, le mieux, serait de repenser ta structure et ne conserver que les données nécessitant d'être sauvegarder d'en un fichier. Et pour le reste tu devrais découper ton record en plusieurs plus petits et tu pourras ainsi sauvegarder et charger sans problèmes les blocs qui t'intéresse et ta gestion de fichier en sera facilité.

Les parties qui posent problèmes, sont toutes des chaines de caractères et qui ont des emplacement commun dans l'enregistrement, sont par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
2:(Txt: string[NbChrTxt]);{Variant de type string pour les opérateurs "Texte"}
3:(Interdit: string[NbChrTxt-(43+1)];                         {Zone interdite}
    Text0: string[43]);  {Nom affichage si sortie principale, NomDLL si FctExt}
4:(Bloque: string[56];
    Text2: string[53];

En effet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
2:(Txt: string[NbChrTxt]);
3:(Interdit: string[NbChrTxt-(43+1)]; 
4:(Bloque: string[56];

occupent le même emplacement dans le record, donc lorsque tu liras les données toutes ces variables seront identiques. De plus le fait d'utiliser des type personnalisés non déclarés globalement est une très très mauvaise idée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
string[NbChrTxt]
string[NbChrTxt-(43+1)]; // pourquoi 43 + 1 et pas directement -44 ??????
string[56]

à remplacer par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Const
 cNbChrTxt = 250;
 cNbChrTxt2 = 250 - 44;
 
Type
  TMyStringA = String[cNbChrTxt];
  TMyStringB = String[cNbChrTxt2];
  TMyStringC = String[56];

Voilà je te laisses regarder ma petite appli, regardes bien les valeurs des textes dans les Edits, tu comprendras.

Ps : J'ai compilé et testé en 32 et 64 bits

La meilleur méthode à mon avis est la n°3 et 4, la n°1 fonctionne bien, la n°2 pose problème lors de l'affichage des données, je sais pas pourquoi d'ailleurs, (bug de lazarus ????? ou de moi ????)

A+

Jérôme

**ChPr** · 30/01/2020, 11h15

Envoyé par BeanzMaster

... Voilà je te laisses regarder ma petite appli, regardes bien les valeurs des textes dans les Edits, tu comprendras. ...

Je te remercie beaucoup, Jérôme, pour le temps que tu as dû passer à faire cette petite application qui montre bien différents manières de traiter de 'l'ouverture et enregistrement d'un packed record. Je m'en inspirerai.

Envoyé par BeanzMaster

... La meilleur méthode à mon avis est la n°3 et 4 ...

Comme je l'ai dit :

Envoyé par Pierre

Le problème vient en fait de l'utilisation des variants : selon les types d'opérateurs (plusieurs dizaines) ce n'est pas le même variant que j'utilise. Donc pour le passage d'un type de packed record à un autre ou bien par fichiers texte, il faut que je distingue chaque type d'opérateurs pour choisir le bon variant : ça devient une usine à gaz ...

donc pour mon application, seule la quatrième méthode est la bonne car elle différencie les variants à choisir lors des enregistrement et ouverture.

Le problème est que ce distinguo est fait dans des endroits de l'application dont je ne suis "plus" sûr tout maîtriser les implications.

Ci-après tous les cas que je dois aller fouiller pour y distinguer quel variant ou partie de variant je dois utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    case Classe of
    0:case Fonction of                                {Fonctions mathématiques}
        0   : Operateur:= TMultiplication.Create(ScrollSchema);
        1   : Operateur:= TDivision.Create(ScrollSchema);
        2   : Operateur:= TInverse.Create(ScrollSchema);
        3   : Operateur:= TCarre.Create(ScrollSchema);
        4   : Operateur:= TRacineCarree.Create(ScrollSchema);
        5   : Operateur:= TVAbsolue.Create(ScrollSchema);
        6   : Operateur:= TLnNeperien.Create(ScrollSchema);
        7   : Operateur:= TExponentielle.Create(ScrollSchema);
        8   : Operateur:= TSinus.Create(ScrollSchema);
        9   : Operateur:= TCosinus.Create(ScrollSchema);
        10  : Operateur:= TTangente.Create(ScrollSchema);
        11  : Operateur:= TArcSinus.Create(ScrollSchema);
        12  : Operateur:= TArcCosinus.Create(ScrollSchema);
        13  : Operateur:= TArcTangente.Create(ScrollSchema);
     end;
    1:case Fonction of                                  {Fonctions temporelles}
        0   : Operateur:= TOrdreUnEnP.Create(ScrollSchema);
        1   : Operateur:= TOrdreDeuxEnP.Create(ScrollSchema);
        2   : Operateur:= TOrdreDeuxEnZ.Create(ScrollSchema);
        3   : Operateur:= TRetardPur.Create(ScrollSchema);
        4   : Operateur:= TIntegrateur.Create(ScrollSchema);
        5   : Operateur:= TEchantillonnage.Create(ScrollSchema);
        6   : Operateur:= TNumDenEnP.Create(ScrollSchema);
        7   : Operateur:= TNumDenEnZ.Create(ScrollSchema);
        8   : Operateur:= TBloqueurOrd1.Create(ScrollSchema);
      end;
    2:case Fonction of                               {Fonctions de l'amplitude}
        0   : Operateur:= TGain.Create(ScrollSchema);
        1   : Operateur:= TSeuil.Create(ScrollSchema);
        2   : Operateur:= TSaturation.Create(ScrollSchema);
        3   : Operateur:= TCombiSatSeuil.Create(ScrollSchema);
        4   : Operateur:= THysteresis.Create(ScrollSchema);
        5   : Operateur:= TQuantification.Create(ScrollSchema);
        6   : Operateur:= TEgalEmax.Create(ScrollSchema);
        7   : Operateur:= TEgalEmin.Create(ScrollSchema);
        8   : Operateur:= TSaut.Create(ScrollSchema);
        9   : Operateur:= TJeu.Create(ScrollSchema);
      end;
    3:case Fonction of                                     {Fonctions diverses}
        0   : Operateur:= TVarEntree.Create(ScrollSchema);
        1   : Operateur:= TVarSortie.Create(ScrollSchema);
        2   : Operateur:= TSommateur.Create(ScrollSchema);
        3   : Operateur:= TJonction.Create(ScrollSchema);
        4   : Operateur:= TMultiplex.Create(ScrollSchema);
        5   : Operateur:= TFctExterieure.Create(ScrollSchema);
        6   : begin
                Operateur:= TTexte.Create(ScrollSchema);
                with TTexte(Operateur), Params do
                  if Int3 > 0 then
                  begin  {Récupération du texte des opé Texte des versions DOS}
                    MemoActionOpe:= ActionOpe;
                    ActionOpe:= Creer;
//                    Texte.Text:= InfoTextSIS[Int3-1];
                    Texte.Modified:= True;
                    Texte.CMMouseLeave(Msg);
                    ActionOpe:= MemoActionOpe;
                    Int3:= 0;
                  end
              end;
        7   : Operateur:= TTexteSuite.Create(ScrollSchema);
        8   : Operateur:= TSuperOpe.Create(ScrollSchema);
        9   : Operateur:= TStopSimul.Create(ScrollSchema);
      end;

NOTA : si tout le code source t'intéresse ...

Cordialement.

Pierre

**BeanzMaster** · 30/01/2020, 11h43

Salut Pierre, pour le test une petit demie-heure ça va.😉
Le mieux à mon avis c est que pour chaque variante il faudrait faire un record puis les incorporer dans le record principale. La gestion des données et des fichiers serait simplifiée et il n'y aurait pas de risque lors de l'affectation qu'une donnée soit remplacer par une autre comme dans mon exemple. Pour le code je t'envois un mp cet après midi. Et je pourrais t'aider à mettre à jour ton application.

A+
Jérôme

**ChPr** · 30/01/2020, 16h35

Ouf

! j'ai enfin réussi à transférer ... 98 % de mes fichiers sans toucher à la structure de mon application.

NOTA : l'icône "ptdr" me fait plutôt penser à un gars qui s'éponge la tête après pas mal d'efforts ; c'est pourquoi je l'ai utilisée.

La modification doit avoir lieu dans l'environnement win32.

Je suis passé par un fichier texte et je l'ai réenregistré en changeant les extended et les pointeurs des variants.

Extended -> Double : pour ne plus occuper que 8 octets
Pointeur -> Deux pointeurs : pour occuper 64 octets au lieu de 32.

Je vais voir si cela ne me cause pas trop de conditions pour pouvoir recréer les cas 2, 3, 4 et 5 du variant. qui ne sont que des cas relativement rares dans mes applications.

Cordialement.

Pierre

Utilisation des packed records [Lazarus]

Lazarus Pascal

Discussions similaires

Partager

Partager