Je n'arrive pas à faire passer mon string par ma DLL

library MaDLL;

uses ShareMem,math;

{$R *.res}

{ ---------------------------------------------------------- }
function MaFonction(n: int64): string;
var s : string;
begin
  { Ici, les instructions qui vont construire la chaine de caractères
    en fonction du paramètre n du type int64.
    En effet, il s'agit d'un entier assez long (au moins 12 chiffres).
    Par exemple : le contenu de s est : }

    s := 'Ceci est un test de ce que pourrait être le contenu de la chaine';
    s := s + ' de caracteres que doit retourner au programme appellant ';
    s := s + '(en Panoramic), la fonction MaFonction. '  ;
    s := s + 'Cette chaine pourrait contenir plus de 255 caractères';
    MaFonction := s;
    result := s;

end;

{ ------------------------------------------------------------------ }
function TestMaFonction(var value: Extended; var Sortie : string): integer; stdcall;

begin
  sortie := MaFonction(Trunc(Value));
  result := 0;
end;

exports
    TestMaFonction;
end.

dim value,Sortie$, i%
width 0,1000
memo 1 :width 1, 980
dll_on "MaDLL.dll"
value = 1234567890987654321
sortie$ = string$(255," ")
i% = dll_call2("TestMaFonction", adr(Value), adr(Sortie$))
item_add 1,sortie$
dll_off

function MaFonction(chaine: pchar): integer; stdcall; export;
var
  MaChaine: string;
begin
  MaChaine:= pchar(pstring(chaine)^);
...

dim s$, res%
s$ = "Ma chaîne de caractères pour ma DLL"
res% = dll_call1("MaFoncton",adr(s$))

function MaFonctionBis(s: integer): integer; stdcall; export;
var
  txt: string;
begin
  txt := 'Mon résultat en chaîne de caractères à retourner à Panoramic';
  CopyTextToPanoramic(integer(@txt), 0, s);
  result := 0;
end;

  TextToPanoramic in 'TextToPanoramic.pas';

unit TextToPanoramic;
{
Cette unité contient la procédure
    CopyTextToPanoramic(source,offset,destination);
source et destination sont des pointeurs sur des strings Panoramic ou des PChar
en Delphi. offset est le décalage à partir duquel on écrit dans la destination
( 0 signifie depuis le début). La copie s'arrêtre automatiquement dès que la fin
d'un des strings est rencontré.
}

interface
procedure CopyTextToPanoramic(inp, offs, out:integer); stdcall;

implementation

procedure CopyTextToPanoramic(inp, offs, out:integer); stdcall;
var
    xout,yinp: pchar;
    n: integer;
begin
    xout := pchar(pstring(out)^);
    yinp := pchar(pstring(inp)^);
    if offs>0 then begin
        for n:=1 to offs do begin
            inc(xout);
            if (xout^ = #0) then exit  { sortir si l'offset va à la fin}
        end
    end;
    while (xout^ <> #0) and (yinp^ <> #0) do begin
        xout^ := yinp^;
        inc(xout);
        inc(yinp);
    end;
end;


end.

dim s$,res%
s$ = string$(255," ")
res% = dll_call1("MaFonctionBis",adr(s$)
message "Le résultat est: "+s$

library Chiffres2Lettres;

 { cette DLL transforme un nombre en chiffres en un nombre en lettres
  de 0 à 99 999 999 999 999 999,99
  c-a-d de zero à
  quatre-vingt dix-neuf billiards
  neuf cent quatre-vingt dix-neuf billions
  neuf cent quatre-vingt dix-neuf milliards
  neuf cent quatre-vingt dix-neuf millions
  neuf cent quatre-vingt dix-neuf mille
  neuf cent quatre-vingt dix-neuf
  virgule quatre-vingt dix-neuf }

uses  Math; //necessaire pour les fonctions mathématiques log10, power etc..
{ =============================================================================}
function NombreEnLettres(nombre: int64): string; export;
var d, n2 : int64;
    s : string[1];
const
  Chiffres : array[0..19] of string =
    ('' , 'un' , 'deux' , 'trois' , 'quatre' , 'cinq' , 'six' , 'sept' ,
    'huit' , 'neuf' , 'dix' , 'onze' , 'douze' , 'treize' ,
    'quatorze' , 'quinze' , 'seize' ,'dix-sept' , 'dix-huit' , 'dix-neuf');
  Dizaines : array[2..9] of string =
    ('vingt' , 'trente' , 'quarante' , 'cinquante' , 'soixante' , '' ,
    'quatre-vingt' , '');
  PuissancesMille : array[1..6] of string =
    ('mille', 'million', 'milliard', 'billion', 'billiard', 'trillion'); // etc...
begin
  CASE nombre of
    0..19:  result := Chiffres[nombre];  // fin
    20..69,80..89:
      if ((nombre mod 10 = 1) and (nombre <> 81)) then
      result := Dizaines[nombre div 10] + ' et ' + NombreEnLettres(nombre mod 10)
      else  //  on dit trente et un mais quatre-vingt un !
      result := Dizaines[nombre div 10] + ' ' + NombreEnLettres(nombre mod 10);
    70..79,90..99:
      if (nombre = 71) then  //  71 = 'soixante' et onze !
      result := Dizaines[nombre div 10 -1] + ' et ' + NombreEnLettres(nombre mod 10 +10)
      else
      result := Dizaines[nombre div 10 -1] + ' ' + NombreEnLettres(nombre mod 10 +10);
    100..999:
        if (nombre div 100 =1) then  // on ne dit pas un cent !
          result := 'cent' + ' '+ NombreEnLettres(nombre mod 100)
        else
        begin
          if (nombre mod 100)=0 then s := 's' else s := '';
        result := Chiffres[nombre div 100]+' '+'cent' + s + ' '+ NombreEnLettres(nombre mod 100);
        end;
    else
    begin
    { ex: 10^6 = 1M <=> exp (6 x ln(10) = 1M <=> 6 x ln(10) = ln (1M)
      <=> 6 = ln(1M) / ln(10) = Log10 (1M) }
      d := trunc(log10(nombre)) div 3;  // arrondir puiss. 10
      n2 := trunc(power(10 , d * 3)); // vers groupe puissances de 1000 +proche
      if (trunc(log10(nombre))=3) and (trunc(nombre/1000)=1) then  // on ne dit pas un mille  !
        result := PuissancesMille[d] + ' ' + NombreEnLettres(nombre mod n2)
      else
      begin
        if d=1 then s := '' else s := 's';  // s au pluriel sauf mille !
        result := NombreEnLettres(nombre div n2) + ' ' + PuissancesMille[d]
          + s + ' ' + NombreEnLettres(nombre mod n2);
      end;
    end;
  END; { case }
  if result = '' then result := 'zero';
end;
{ =============================================================================}
function NbEnLettres(var montant: Extended; var somme : string): integer; stdcall; export;
begin
  somme := NombreEnLettres(Trunc(montant));
  somme := somme + ' virgule ' + NombreEnLettres(round(100 * frac(montant)));
  result := 0;
end;
{ =============================================================================}
  exports NombreEnLettres, NbEnLettres;
end.
 

dim montant,Somme$, i%
width 0, 1000
dll_on "Chiffres2Lettres.dll"
montant = 123456789.12
' somme$ = string$(255," ")
i% = dll_call2("NbEnLettres", adr(montant), adr(Somme$))
print Somme$
dll_off

function NombreEnLettres(nombre: int64): string; export;

function NbEnLettres(var montant: Extended; var somme : string): integer; stdcall; export;

library Chiffres2Lettres;

 { cette DLL transforme un nombre en chiffres en un nombre en lettres
  de 0 à 99 999 999 999 999 999,99
  c-a-d de zero à
  quatre-vingt dix-neuf billiards
  neuf cent quatre-vingt dix-neuf billions
  neuf cent quatre-vingt dix-neuf milliards
  neuf cent quatre-vingt dix-neuf millions
  neuf cent quatre-vingt dix-neuf mille
  neuf cent quatre-vingt dix-neuf
  virgule quatre-vingt dix-neuf }

uses
  Math, SysUtils,
  TextToPanoramic in 'TextToPanoramic.pas';

//necessaire pour les fonctions mathématiques log10, power etc..
{ =============================================================================}
function NombreEnLettres(nombre, txt: integer): integer, stdcall; export;
var
    sresult: string;

begin
  if nombre>0 then sresult := IntToStr(nombre);
  if sresult = '' then sresult := 'zero';
  CopyTextToPanoramic(integer(@sresult), 0, txt);
  retulr := 0;
end;
{ =============================================================================}
  exports NombreEnLettres;
end.
 

dim valeur, res%
valeur = 4*atn(1) : ' pi
res% = dll_call1("MaFonction",adr(valeur))