Bonjour,

Dans mon programme, j'ai fait une DLL contenant des fonctions que j'utilise dans le programme ainsi que dans l'utilitaire de mise à jour.
J'ai pour le moment qu'une seule fonction me servant à renvoyer un integer d'après une chaine.

L'utilitaire de mise à jour se sert de cette version afin de comparer le numéro de version de update.ini et celui du programme (contenu dans un fichier INI).
Si la version de update.ini est inférieur ou égale à celle du programme, il va afficher un message indiquant qu'aucune mise à jour est disponible et quitter par un simple Exit, afin d'éviter qu'il continu le processus de mise à jour.

Le hic se trouve ici, quand il passe sur le Exit, Delphi me renvoi l'information suivante :
Echec du projet c:\prog\delphi\FicEditor\update.exe avec le message : 'violation d'accès à 0x00a75d7d : lecture de l'adresse 0xffffffff'. Processus stoppé. Utilisez Pas-à-pas ou Exécuter pour continuer.

J'ai tenté de commenter l'utilisation de la fonction de ma DLL et ça ne le fais pas.
Voici le code de la DLL :
function GetVersionInteger(Version: PChar): Integer;
var
Temp: String;
begin
Temp := MidStr(Version, 1, 1);
Temp := Temp+MidStr(Version, 3, 1);
Temp := Temp+MidStr(Version, 5, 1);
Temp := Temp+MidStr(Version, 7, 1);
Result := StrToInt(Temp);
end;

Je suppose que le problème viens donc de là.
Sinon, voila comment j'appel la fonction depuis l'EXe :
function GetVersionInteger(Version: PChar): Integer; stdcall; external 'divers';

Pour la déclaration, et pour l'utilisation :
IntVersion := GetVersionInteger(PChar(Version));
IntVersionIni := GetVersionInteger(PChar(VersionIni));

Merci d'avance.

tes numeros de version sont sous ce format  ?

Major.minor.release.build ?

alors ne fait pas comme cela.

stocke la version en Int dans le ini (readinteger, writeinteger) comme ceci :

[version]
maj = 1
min = 2
rel = 0
bui = 3

deja se sera plus simple que de traiter avec un string.

ensuite crée un type TFileVersion :

Type
  TFileVersion = record
    Major, Minor, Release, Build : word;
  end;

cela permettra de stocker la version

creation des version :

function CreateFileVersion(const Major, Minor, Release, Build: word): TFileVersion;
begin
  result.Major := Major;
  result.Minor := Minor;
  result.Release := Release;
  result.Build := Build;
end;

lecture de la version :

function ReadVersion: TFileVersion;
var F: string;
begin
  F := ChangeFileExt(ParamStr(0), 'ini');
  if not FileExits(F) then
    assert('File not found '+F);

  with TIniFile.Create(F) do
  try
    result.Major := ReadInteger('version', 'maj');
    result.Minor := ReadInteger('version', 'min');
    result.Release:= ReadInteger('version', 'rel');
    result.Build := ReadInteger('version', 'bui');
  finally
    Free;
  end;
end;

enregistrement de la version :

procedure WriteFileVersion(const FileVersion: TFileVersion);
var F: string;
begin
  F := ChangeFileExt(ParamStr(0), 'ini');

  with TIniFile.Create(F) do
  try
    WriteInteger('version', 'maj', FileVersion.Major);
    WriteInteger('version', 'min', FileVersion.Minor);
    WriteInteger('version', 'rel', FileVersion.Release);
    WriteInteger('version', 'bui', FileVersion.Build);
  finally
    Free;
  end;
end;

affichage de la version :

function FileVersionToStr(const FV: TFileVersion): PChar;
begin
  result := format('%d.%d.%d.%d',[FV.Major, FV.Minor, FV.Release, FV.Build]);
end;


voila, cela te permettra de ne pas manipuler de chaines et ainsi d'eviter des erreurs.

---

Je veux bien, mais ça me dit pas pourquoi j'ai une erreur et qui plus est n'arrive que quand update.exe est lancé depuis delphi et non directement.

HA! voila le truc, l'erreur n'est la que quand on lance a partir de delphi.

alors comment lance tu ta DLL dans ton wrapper ?

avec LoadLibrary ou en statique :

interface

function GetVersion(...); stdcall;

implementation

const
  DLL = 'MaDLL.dll';

function GetVersion; external DLL name 'GetVersion';

end;

?

---

ah désolé j'avais pas vus que tu nous le précisé dans ton premier post.

mmm.

en fait, un conseil. quand tu fait une DLL, fait un wrapper qui vas avec, n'appel pas directement les fonctions dans l'unité du programme, ce sera plus propre.

FICHIER MaDLL.DPR :

library MaDLL;

uses
  SysUtils,
  StrUtils,
  Classes;

{$R *.res}

function GetStrPart(const Str, Delimiter: String; const WordIndex: cardinal = 1): String;
var I,P1,P2 : integer;
begin
  Result := '';
  if (posex(Delimiter,Str[1]) = 1) and (WordIndex <= 1) then exit;
  P1 := 1;
  for I := 1 to WordIndex-1 do begin
      P1 := posex(Delimiter, Str, P1);
      if P1 = 0 then exit
      else P1 := P1 + length(Delimiter);
  end;
  P2 := posex(Delimiter, Str, P1);
  if P2 = 0 then P2 := length(Str) + 1;
  Result := copy(Str, P1, P2 - P1);
end;

function GetVersion(const version: PChar; const Len: integer): LongWord; stdcall;
var S: string;
    Mj, Mn, Rl, Bd: byte;
begin
  SetString(S, Version, Len);
  Mj := StrToIntDef(GetStrPart(S, '.', 1), 0);
  Mn := StrToIntDef(GetStrPart(S, '.', 2), 0);
  Rl := StrToIntDef(GetStrPart(S, '.', 3), 0);
  Bd := StrToIntDef(GetStrPart(S, '.', 4), 0);

  result := (Mn shl 24) or (Mj shl 16) or (Bd shl 8) or Rl;
end;

exports
  GetVersion;

begin
end.

FICHIER MaDLL.PAS (wrapper)

unit MaDLL;

interface

// Wrapper

function GetVersion(const version: PChar; const Len: integer): LongWord; stdcall;

implementation

const
  DLL = 'MaDLL.dll';

function GetVersion; external DLL name 'GetVersion';

end.


FICHIER MAIN.PAS (projet TESTDLL.DPR)

unit Main;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm2 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

Uses MaDLL;


procedure TForm2.FormCreate(Sender: TObject);
var V : string;
    L : integer;
begin
  V := '1.12.3.4';
  L := Length(V);
  caption := format('%.8x',[GetVersion(PChar(V), L)]);
end;

end.


hop.

---

Si j'appelle l'unité, la DLL sert à rien si ?
Sinon, en fait j'ai demandé à mon frangin, en fait il semblerait que contrairement à ce que disent phidels et delphipage, par défaut c'est pas stdcall mais register, donc du coup ça foiré.
Après ajout du stdcall dans la DLL, plus de problème ;)

Je confirme: par défaut, la convention est register.
Et j'approuve f0xi: fais une unité dite "wrapper" qui contient toutes les déclarations des fonctions de ta dll. D'une part, ça t'évites de le faire dans chaque programme et en plus tu t'évites des erreurs.

@foxi: dis moi, t'a une de ces pèche en ce moment !!! T'es en vacances ou tu te dopes ?

Ressources Delphi, sources, tutoriaux, actu, ...: www.mx-dev.net [ Lien ]

"en fait il semblerait que contrairement à ce que disent phidels et delphipage, par défaut c'est pas stdcall mais register"

Tu as surrement du mal comprendre ce qu'ils ont dis. StdCall est la convention d'appel par defaut des librairies Win32. Mais effectivement Delphi est par defaut en Register (a ne pas utiliser quand on fait un DLL pouvant etre utilisée avec C, C++ ou VB).

En C et C++ par defaut c'est CDECL, en VB c'est surrement STDCALL.

" t'a une de ces pèche en ce moment !!! T'es en vacances ou tu te dopes"

Pour nous aussi c'est le J.O. il parrait.

---