abwärtskompatibler unit zugriff

[KodeZwerg]

Hallo, in einer unit überschreibe ich den Aufruf einer anderen methode

Ich muss also den genutzten "uses" namen wissen um das original aufzurufen.

Wie realisiere ich das?

Hier mein Problem als Quelltext:
(stellt euch vor "foobar" gibt es tatsächlich auch in sysutils für dieses beispiel)

Delphi-Quellcode:

// so funktioniert es gut Beispiel:
{$IF CompilerVersion >= 23}
  {$DEFINE NameSpace}
{$ENDIF}

uses
  {$IF DEFINED(NameSpace)}System.SysUtils;{$ELSE}SysUtils;{$ENDIF}

function Foobar: Boolean;
begin
  {$IF DEFINED(NameSpace)}
    System.SysUtils.Foobar;
  {$ELSE}
    SysUtils.Foobar;
  {$ENDIF}
end;

Delphi-Quellcode:

// in diese, fall scheitert es
{$IF CompilerVersion >= 23}
  {$DEFINE NameSpace}
{$ENDIF}

uses
  SysUtils;

function Foobar: Boolean;
begin
  {$IF DEFINED(NameSpace)}
    // der name kann nicht aufgelöst werden
    System.SysUtils.Foobar;
  {$ELSE}
    SysUtils.Foobar;
  {$ENDIF}
end;

Kann ich testen/herausfunden wie der programmierer die uses klausel angewandt hat?

[himitsu]

Ich bin ja schreibfaul und finde es mit ELSE einfach unleserlich sinnlos zu lang. Und das DEFINED() lenkt auch nochmal vom Eigentlichen ab.

Delphi-Quellcode:

uses {$IFDEF NameSpace}System.{$ENDIF}SysUtils;

{$IFDEF NameSpace}System.{$ENDIF}SysUtils.Foobar;

Es wäre zu praktisch, wenn Delphi endlich mal (einfache/kurze) Makros lernen würde, aber der Hersteller weigert sich vehement.
Mein Vorschlag wäre ja sowas wie

Delphi-Quellcode:

{$IF CompilerVersion >= 23}
  {$MACRO NSSystem 'SysUtils.'}  // oder   {$DEFINEMACRO NSSystem 'SysUtils.'}
{$ENDIF}

uses {$NSSystem}SysUtils;  // oder {$M NSSystem} oder {$MACRO NSSystem}

[dummzeuch]

Eigentlich sollte SysUtils alleine schon ausreichen, denn üblicherweise werden doch die Unit Scope Names von der IDE passend gesetzt.

Nervig wird es nur, wenn die IDE an den Uses-Listen herumfummelt.

Hilfreich sind auch die Unit Aliases, wenn sich die Namen von Units geändert haben, z.B. ActionList=ActnList (das dann für ältere Delphis verwenden, die ActionList noch nicht kannten). Dasselbe gilt, wenn irgendwelche Funktionen in andere Units verschoben werden.

Ich versuche in meinen Programmen (und insbesonder GExperts) in der Regel ohne solche IFDEF-Orgien auszukommen, weil es der Lesbarkeit sehr schnell abträglich wird.

[KodeZwerg]

An himitsu, der Quelltext muss Delphi und FPC standhalten.

Ich habe halt das Problem das manche Nutzer "uses SysUtils" verwenden und mein "Qual"-Text dann händisch bearbeitet werden muss.

Das würde ich halt gerne elegant lösen nur weiß ich noch nicht wie. Das mit dem Makro ist neuland für mich, ich werde es testen.

[KodeZwerg]

Zitat:

Zitat von dummzeuch (Beitrag 1500629)

Eigentlich sollte SysUtils alleine schon ausreichen

Das bestreite ich ja auch nicht.

Mein problem ist halt das je nach dem wie die uses aussieht muss auch mein $define inhalt aussehen.
Ich habe keinen einfluß auf den uses part nur auf meinen quelltext.

Ein nachvollziehbares Beispiel:

Delphi-Quellcode:

program Test;

{$IF CompilerVersion >= 23}
  {$DEFINE NameSpace}
{$ENDIF}

uses
//  {$IF DEFINED(NameSpace)}System.SysUtils;{$ELSE}SysUtils;{$ENDIF}
 SysUtils;

procedure Sleep(const Value: Int64);
begin
  {$IF DEFINED(NameSpace)}
    System.SysUtils.Sleep(Value);
  {$ELSE}
    SysUtils.Sleep(Value);
  {$ENDIF}
end;

begin
  WriteLn('Sleeping');
  Sleep(100);
  WriteLn('Awake');
  ReadLn;
end.

[KodeZwerg]

Ich habe gefunden was ich benötige indem ich in der RTTI.pas gesucht habe und dies dabei rausgekommen ist.
Auch habe ich beim Testen festgestellt (wie dummzeuch schrieb) das intern anscheinend immer der volle Name genutzt wird.

Vielleicht kann es ja jemand woanders gebrauchen. (es wird keine unit im uses benötigt für diese routine)

Delphi-Quellcode:

programm Test;

uses
  System.SysUtils; // nur eingebunden für das Beispiel,
                   // die methode UnitExists() benötigt nichts.

function UnitExists(const UnitName: String): Boolean;
  function LowerCase(const S: string): string;
  var
    I, Len: Integer;
    DstP, SrcP: PChar;
    Ch: Char;
  begin
    Len := Length(S);
    SetLength(Result, Len);
    if Len > 0 then
    begin
      DstP := PChar(Pointer(Result));
      SrcP := PChar(Pointer(S));
      for I := Len downto 1 do
        begin
          Ch := SrcP^;
          case Ch of
            'A'..'Z': Ch := Char(Word(Ch) or $0020);
          end;
          DstP^ := Ch;
          Inc(DstP);
          Inc(SrcP);
        end;
    end;
  end;

  procedure PeekData(var P: PByte; var Data; Len: Integer);
  begin
    Move(P^, Data, Len);
  end;

  procedure ReadData(var P: PByte; var Data; Len: Integer);
  begin
    PeekData(P, Data, Len);
    Inc(P, Len);
 end;

  function ReadU8(var P: PByte): Byte;
  begin
    ReadData(P, Result, SizeOf(Result));
  end;

  function _UTF8ToString(P: pointer): string;
  var
    Len: Byte;
    Buf: Array of Byte;
  begin
    Result := '';
    Len := PByte(P)^;
    if Len <> 0 then
      begin
        SetLength(Buf, Len+1);
        Move(PByte(P)^, Buf[0], Len+1);
        Result := UTF8ToString(Buf);
      end;
  end;

  function ReadShortString(var P: PByte): string;
  var
    len: Integer;
  begin
    Result := _UTF8ToString(P);
    len := ReadU8(P);
    Inc(P, len);
  end;

  function IsLoaded(const UnitName: String): Boolean;
  var
    p: PByte;
    i: Integer;
    s: String;
  begin
    Result := False;
    if (UnitName = '') then
      Exit;
    s := LowerCase(UnitName);
    p := Pointer(System.LibModuleList.TypeInfo.UnitNames);
    for i := 0 to System.LibModuleList.TypeInfo.UnitCount - 1 do
      if (s = LowerCase(ReadShortString(p))) then
        begin
          Result := True;
          Break;
        end;
  end;

begin // UnitExists()
  Result := IsLoaded(UnitName);
end;  // UnitExists()


// und so überlade ich es nun
// damit bekomme ich keinen "Kann Name nicht auflösen" Fehler obwohl nun beides als ausführbarer Kode enthalten ist.
procedure Sleep(const MSec: DWORD);
begin
  if UnitExists('System.SysUtils') then
    System.SysUtils.Sleep(MSec)
    else
    SysUtils.Sleep(MSec);
end;

begin
  Sleep(150);
end.

[Frickler]

Und das geht sowohl in Delphi als auch in Lazarus?

[TigerLilly]

Ääääh. Du hattest doch ein Compile-Problem. Das ist Laufzeit. Was übersehe ich? :shock:

[KodeZwerg]

Zitat:

Zitat von Frickler (Beitrag 1500698)

Und das geht sowohl in Delphi als auch in Lazarus?

Es ist komisch, es funktioniert nur wenn ich es in der .dpr anwende, in units bekomme ich wieder den Fehler, naja, ich bin wieder am weiterforschen :)

Es würde bei FPC nicht zum tragen kommen da FPC (noch) keine Prefixe hat. Angewandt bei mir wird es nur wenn Delphi der Motor ist. " {$IF NOT DEFINED(FPC)} "

[KodeZwerg]

Zitat:

Zitat von TigerLilly (Beitrag 1500700)

Ääääh. Du hattest doch ein Compile-Problem. Das ist Laufzeit. Was übersehe ich? :shock:

Ja, es lässt mich nicht kompilieren. Du hast nichts übersehen aber ich wahrscheinlich einen Denkfehler