Interface-Unterstützung

[stahli]

Danke für den Tipp.
Ich habe allerdings einen eigenen Parser aus einem anderen Projekt und kann den hier verwenden.

Ein Teil der Interface-Aufbereitung geht schon:

Delphi-Quellcode:

...
type

  IsoNameObj = interface;

  iMyBaseIntf = Interface
    prop BaseProp:integer;
  end;

  IMyIntf = interface(IMyBaseIntf)
    procedure DoA;
    prop A:string c s;
    prop B:string ro;
    prop C:string wo c s;
    prop D:string sg;
    prop E:string ss c;
    function GetA:Integer;
  end;

  IMyIntf2 = interface(IMyBaseIntf)
    prop X:string c s;
    prop Y:string ro;
    function GetX:Integer;
  end;

  IMyIntf3 = interface
    procedure DoZ;
    prop Z:string c;
    function GetZ:Integer;
  end;

  TsoNotifyEvent = procedure(const Sender: IInterface) of object;

  IsoSystem = interface;
  IsoProject = interface;
  IsoPropertyDef = interface;
  IsoMethodeDef = interface;
  IsoClass = interface
...

wird zu:

Delphi-Quellcode:

...
type

  IsoNameObj = interface;

  iMyBaseIntf = Interface
        function _get_BaseProp: integer;
        procedure _set_BaseProp(aValue: integer);
        property BaseProp: integer read _get_BaseProp write _set_BaseProp;
  end;

  IMyIntf = interface(IMyBaseIntf)
    procedure DoA;
        function _get_A: string; stdcall;
        procedure _set_A(const aValue: string); stdcall;
        property A: string read _get_A write _set_A;
        function _get_B: string;
        property B: string read _get_B;
        procedure _set_C(const aValue: string); stdcall;
        property C: string write _set_C;
        function _get_D: string; stdcall;
        procedure _set_D(aValue: string);
        property D: string read _get_D write _set_D;
        function _get_E: string;
        procedure _set_E(const aValue: string); stdcall;
        property E: string read _get_E write _set_E;
    function GetA:Integer;
  end;

  IMyIntf2 = interface(IMyBaseIntf)
        function _get_X: string; stdcall;
        procedure _set_X(const aValue: string); stdcall;
        property X: string read _get_X write _set_X;
        function _get_Y: string;
        property Y: string read _get_Y;
    function GetX:Integer;
  end;

  IMyIntf3 = interface
    procedure DoZ;
        function _get_Z: string;
        procedure _set_Z(const aValue: string);
        property Z: string read _get_Z write _set_Z;
    function GetZ:Integer;
  end;

  TsoNotifyEvent = procedure(const Sender: IInterface) of object;

  IsoSystem = interface;
  IsoProject = interface;
  IsoPropertyDef = interface;
  IsoMethodeDef = interface;
  IsoClass = interface;
...

Der Parser erkennt Interfacedeklarationen und kann auch Forward-Deklarationen unterscheiden.
Nur die richtigen Interfaces scant und optimiert er.

Die generierten Zeilen habe ich hier mal eingerückt.

Jetzt will ich noch regeln, dass Typänderungen von Propertys automatisch in vorhanden Gettern und Settern angepasst werden.
Namensänderungen von Membern können dann nicht automatisch bearbeitet werden (das wäre höchstens möglich für Getter und Setter von Propertys, aber das wäre den Aufwand wohl nicht wert).

Die Interface-Member werden als Objekte gespeichert und an die Klassen übergeben.
Dort wird dann noch geprüft, ob die dortigen Member korrekt sind. Sonst wird die Klasse angepasst und ggf. Propertys und Methoden erzeugt.

Anschließend wird die Unit sortiert.