Abkürzungen für RTL-Funktionen möglich?

[Amateurprofi]

@Harry Stahl:

Mir fällt nur eine Lösung ein, nicht ganz was du willst aber ...

Erstelle eine Unit, die du in allen Units unter Uses aufführst und schreibe in diese Unit Prozeduren/Funktionen mit den Namen, die Dir gefallen.

Und diese Funktionen rufen dann die Routinen mit den Dir zu langen Namen auf.

Ich hab mal etwas ähnliches gemacht, allerdings mit einer anderen Zielsetzung.

Bei mir war das die Prozedur ShowMessage.
Ich nutze die oft (so wie vermutlich jeder), um irgendwelche Rechenergebnisse, auszugeben.
Irgendwann war ich es leid immer zu schreiben
ShowMessage(IntToStr(A)+', '+IntToStr(B)+', '+IntToStr(C));
oder
ShowMessage(IntToStr(A)#13+IntToStr(B)+#13+IntToStr(C));
Also schuf ich solch eine Unit die u.A. zwei Prozeduren enthielt konnte dann schreiben

Mess([A,B,C]); oder
Mess([A,B,C], #13); oder auch
Mess(IntToStr(A)+' '+IntToStr(B)+' '+IntToStr(C));

Delphi-Quellcode:

interface

uses
   Vcl.Dialogs;

PROCEDURE Mess(const Args:array of const; const Delimiter:String=', '); overload;
PROCEDURE Mess(const S:String); overload;

implementation

PROCEDURE Mess(const Args:array of const; const Delimiter:String=', ');
var I:Integer; S:String;
begin
   for I:=0 to High(Args) do
      with Args[I] do begin
         case VType of
            vtInteger   :  S:=S+IntToStr(VInteger);
            vtBoolean   :  S:=S+BoolToStr(VBoolean);
            vtChar      :  S:=S+VChar;
            vtExtended  :  S:=S+FloatToStr(VExtended^);
            vtString    :  S:=S+VString^;
            vtPointer   :  S:=S+IntToHex(NativeInt(VPointer),SizeOf(Pointer)*2);
            vtPChar     :  S:=S+VPChar;
            vtObject    :  S:=S+VObject.ClassName;
            vtClass     :  S:=S+VClass.ClassName;
            vtWideChar  :  S:=S+VWideChar;
            vtPWideChar :  S:=S+VPWideChar;
            vtAnsiString:  S:=S+string(VAnsiString);
            vtCurrency  :  S:=S+CurrToStr(VCurrency^);
            vtVariant   :  S:=S+string(VVariant^);
            vtInterface :  S:=S+String(VInterface);
            vtInt64     :  S:=S+IntToStr(VInt64^);
            else           Continue;
         end;
         S:=S+delimiter;
      end;
   if S<>'' then SetLength(S,Length(S)-Length(Delimiter));
   ShowMessage(S);
end;

PROCEDURE Mess(const S:String);
begin
   ShowMessage(S);
end;

end.

[Harry Stahl]

@KodeZwerg und @AmateurProfi: Danke für Eure Antworten. Aber ich würde hier keine Lösungen haben wollen, die

A. Das Programm verlangsamen (Funktion ruft zusätzliche Funktion auf).
B. Das Programm größer machen.

Auch wenn beides im Einzelfall vielleicht nicht sonderlich ins Gewicht fallen würde.

Wenn es so etwas gegeben hätte, wie

Delphi-Quellcode:

Makro
  EFN = ExtractFilename;

Dann wäre das evtl. von Interesse gewesen, aber so etwas gibt's wohl nicht in Pascal/Delphi. Der Compiler hätte dann alle Stellen, wo EFN steht, durch ExtractFileName ersetzt. Dann gäbe es die oben beschriebenen Nachteile nicht.

[p80286]

Dein Vorhaben riecht doch sehr nach Präprozessor, gut, zu einer IDE-Integration kann ich nichts sagen, aber hier gibt es bestimm den einen oder anderen, der weiß wie man so etwas realisieren kann.

Gruß
K-H

[Harry Stahl]

Nachtrag: Hatte irgendwie dunkel in Erinnerung, dass unter C sowas ähnliches möglich ist (ich programmiere allerdings nicht in C, kann es gerade halbwegs lesen).

Hier mal ein Beispiel aus der BCC-Hilfe:

Code:

#define ERRMSG(x, str) printf("Fehler: %d \n%s", x, str) 

/*Im Code kann man dann den Aufruf machen, wie */
/*wird erweitert zu:  printf("Fehler: %d \n%s", 2, "Drücken Sie Eingabe, dann ESC"); */ 

ERRMSG(2, "Drücken Sie Eingabe, dann ESC");

Im übertragenen Sinne müsste da dann also sowas wie

Code:

#define EFN (x, str) ExtractFileName (x, str)

möglich sein.

[Harry Stahl]

C++ scheint da schon mehr drauf zu haben, da gibt es ne Menge Präprozessor-Direktiven, u.a. habe ich auch gefunden:

#pragma alias "aliasName" = "substituteName"

(teilt dem Linker mit, dass zwei Bezeichnernamen äquivalent sind)

[KodeZwerg]

Dann gäbe es da noch

Delphi-Quellcode:

const
  EFN: function(const FileName: string): string = SysUtils.ExtractFileName;

Volltreffer? ;-D

[himitsu]

Nunja, neben den Interface-Implementationen gibt es nocheine Stelle, wo man sowas auch mit normalen Funktionen machen kann, und zwar beim Import von DLL-Funktionen.

Delphi-Quellcode:

unit himi.ist.manchmal.ein.bissl.irre;

interface

uses System.SysUtils;

function ITPD(const S: string): string;
  external 'NameDeinerAnwendung.exe' name 'IncludeTrailingPathDelimiter';  // nicht vergessen diese Zeile anzupassen

implementation

exports IncludeTrailingPathDelimiter(const S: string);

end.

[Harry Stahl]

Suuuperr!!!

KodeZwerg, Du bist ein Genie!

Hier muss ich noch ein "System" davor setzen, so dass es compiliert:

Delphi-Quellcode:

const
  EFN: function(const FileName: string): string = System.SysUtils.ExtractFileName;

Keine Geschwindigkeitsverluste da und auch der Code wird nicht größer, am Ende der gleiche Ablauf auch in CPU-Ansicht (siehe Anlage), der Verlauf ist absolut gleich, "call ExtractFilename" ist mit der SpeicherAdresse von "call dword ptr [$005e199c]" identisch. Auch die Codevervollständigung funktioniert mit der "Alias-" Definition.

Gibt es noch eine allgemeine Bezeichnung für diese Art der Definition?

Jedenfalls dank an alle, die konstruktiv bei der Lösung mitgewirkt haben, es zeigt sich mal wieder, dass man sich nicht entmutigen lassen darf und einfach weiter der Sache nachgehen sollte, ganz egal was andere einem unterstellen wollen...

[KodeZwerg]

Ich nenne es Alias per Definition, aber fühl Dich frei das selbst zu Entscheiden hehe

[himitsu]

Zitat von Harry Stahl:

C++ scheint da schon mehr drauf zu haben, da gibt es ne Menge Präprozessor-Direktiven, u.a. habe ich auch gefunden:

In C++ hast du auch noch Makros, wo du seit Jahrzehnten alles kannst machen, wovon die Generics nur träumen können.

Code:

#define ITPD(s) IncludeTrailingPathDelimiter(s)

Zitat:

Delphi-Quellcode:

const
   EFN: function(const FileName: string): string = System.SysUtils.ExtractFileName;

Normaler Weise sind typisierte Konstanten eigentlich schreibgeschützte Variablen ... also ich hätte da jetzt nicht erwartet, dass es hier nicht so ist.