Object Pascal- oder RIDL-Syntax verwenden

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Den Typbibliothekseditor verwenden


Auf der Seite Code des Typbibliothekseditors werden die Typinformationen im RIDL-Format (Restricted Interface Definition Language) angezeigt. Dieses Format ähnelt der IDL-Syntax von Microsoft. RIDL unterstützt aber nur einen Teil der IDL. Wie überall in Delphi-Anwendungen wird auch bei Bezeichnern in Typbibliotheken zwischen Groß- und Kleinschreibung nicht unterschieden. Bezeichner können bis zu 255 Zeichen lang sein und sollten aus Portabilitätsgründen mit einem Buchstaben oder einem Unterstrich (_) beginnen.

Attributspezifikationen

In einer RIDL-Datei deklarierte Typen können Attribute enthalten. Attributspezifikationen werden in eckige Klammern eingefügt und durch Kommas getrennt. Jede Attributspezifikation besteht aus einem Attributnamen, gefolgt von einem Wert (sofern erforderlich).

Die folgende Tabelle listet die Attributnamen und die entsprechenden Werte auf:

Attributsyntax

Attributname Beispiel Betrifft

aggregatable

[aggregatable]

Typinformation

appobject

[appobject]

CoClass-Typinformation

bindable

[bindable]

Member (ausgenommen CoClass-Member)

control

[control]

Typbibliothek, Typinformation

custom

[custom '{7B5687A1-F4E9-11D1-92A8-00C04F8C8FC4}' 0]

Alles

default

[default]

CoClass-Member

defaultbind

[defaultbind]

Member (ausgenommen CoClass-Member)

defaultcollection

[defaultcollection]

Member (ausgenommen CoClass-Member)

dispid

[dispid]

Member (ausgenommen CoClass-Member)

displaybind

[displaybind]

Member (ausgenommen CoClass-Member)

dllname

[dllname 'Helper.dll']

Modul-Typinformation

dual

[dual]

Interface-Typinformation

helpfile

[helpfile 'c:\help\myhelp.chm'] [helpfile 'c:\help\myhelp.hlp']

Typbibliothek

helpstringdll

[helpstringdll 'c:\help\myhelp.dll']

Typbibliothek

helpcontext

[helpcontext 2005]

Alles (ausgenommen CoClass-Member und Parameter)

helpstring

[helpstring 'Gehaltslisten-Interface']

Alles (ausgenommen CoClass-Member und Parameter)

helpstringcontext

[helpstringcontext $17]

Alles (ausgenommen CoClass-Member und Parameter)

hidden

[hidden]

Alles (ausgenommen Parameter)

lcid

[lcid $324]

Typbibliothek

licensed

[licensed]

Typbibliothek, CoClass-Typinformation

nonbrowsable

[nonbrowsable]

Member (ausgenommen CoClass-Member)

nonextensible

[nonextensible]

Interface-Typinformation

oleautomation

[oleautomation]

Interface-Typinformation

predeclid

[predeclid]

Typinformation

propget

[propget]

Member (ausgenommen CoClass-Member)

propput

[propput]

Member (ausgenommen CoClass-Member)

propputref

[propputref]

Member (ausgenommen CoClass-Member)

public

[public]

Alias-Typinformation

readonly

[readonly]

Member (ausgenommen CoClass-Member)

replaceable

[replaceable]

Alles (ausgenommen CoClass-Member und Parameter)

requestedit

[requestedit]

Member (ausgenommen CoClass-Member)

restricted

[restricted]

Alles (ausgenommen Parameter)

source

[source]

Alle Member

uidefault

[uidefault]

Member (ausgenommen CoClass-Member)

usesgetlasterror

[usesgetlasterror]

Member (ausgenommen CoClass-Member)

uuid

[uuid '{7B5687A1-F4E9-11D1-92A8-00C04F8C8FC4}' ]

Typbibliothek, Typinformation (erforderlich)

vararg

[vararg]

Member (ausgenommen CoClass-Member)

version

[version 1.1]

Typbibliothek, Typinformation

Interface-Syntax

Die Delphi-Syntax für die Definition von Interface-Typinformationen sieht wie folgt aus:

InterfaceName = interface[(BasisInterface)] [Attribute] 
Funktionsliste 
[EigenschaftsMethodenListe] 
end;

Beispielsweise deklariert der folgende Quelltextausschnitt ein Interface mit zwei Methoden und einer Eigenschaft:

Interface1 = interface (IDispatch) 
  [uuid '{7B5687A1-F4E9-11D1-92A8-00C04F8C8FC4}', version 1.0] 
  function Calculate(optional seed:Integer=0): Integer; 
  procedure Reset; 
  procedure PutRange(Range: Integer) [propput, dispid $00000005]; stdcall; 
  function GetRange: Integer;[propget, dispid $00000005]; stdcall; 
end;

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{5FD36EEF-70E5-11D1-AA62-00C04FB16F42}',version 1.0] 
interface Interface1 :IDispatch 
{ 
  long Calculate([in, optional, defaultvalue(0)] long seed); 
  void Reset(void); 
  [propput, id(0x00000005)] void _stdcall PutRange([in] long Value); 
  [propput, id(0x00000005)] void _stdcall getRange([out, retval] long *Value); 
};

Syntax von Dispatch-Interfaces

Die Delphi-Syntax für die Definition von Dispatch-Interface-Typinformationen sieht wie folgt aus:

DispatchInterfaceName = dispinterface [Attribute] 
Funktionsliste 
[Eigenschaftsliste] 
end;

Beispielsweise deklariert der folgende Quelltextausschnitt ein Dispatch-Interface mit den gleichen Methoden und der gleichen Eigenschaft wie das vorherige Interface:

MyDispObj = dispinterface 
[uuid '{5FD36EEF-70E5-11D1-AA62-00C04FB16F42}', 
  version 1.0, 
  helpstring 'dispatch interface for MyObj' 
  function Calculate(seed:Integer): Integer [dispid 1]; 
  procedure Reset [dispid 2]; 
  property Range: Integer [dispid 3]; 
end;

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{5FD36EEF-70E5-11D1-AA62-00C04FB16F42}', 
  version 1.0, 
  helpstring "dispatch interface for MyObj" 
dispinterface Interface1 
{ 
  methods: 
    [id(1)] int Calculate([in] int seed); 
    [id(2)] void Reset(void); 
  properties: 
    [id(3)] int Value; 
};

CoClass-Syntax

Die Delphi-Syntax für die Deklaration von CoClass-Typinformationen sieht wie folgt aus:

Klassenname = CoClass(InterfaceName[InterfaceAttribute], ...); [Attribute];

Zur Veranschaulichung wird im Folgenden eine CoClass für das Interface IMyInt und das Dispatch-Interface DMyInt deklariert:

myapp = coclass(IMyInt [source], DMyInt); 
[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
  version 1.0, 
  helpstring 'A class', 
  appobject]

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
  version 1.0, 
  helpstring "A class", 
  appobject] 
coclass myapp 
{ 
  methods: 
  [source] interface IMyInt); 
  dispinterface DMyInt; 
};

Enum-Syntax

Die Delphi-Syntax für die Deklaration von Enum-Typinformationen sieht wie folgt aus:

EnumName = ([Attribute] AufzaehlungsListe);

Der folgende Quelltextausschnitt deklariert beispielsweise einen Aufzählungstyp mit drei Werten:

location = ([uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
         helpstring 'location of booth'] 
  Inside = 1 [helpstring 'Inside the pavillion']; 
  Outside = 2 [helpstring 'Outside the pavillion']; 
  Offsite = 3 [helpstring 'Not near the pavillion'];);

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
        helpstring "location of booth"] 
typedef enum 
{ 
  [helpstring "Inside the pavillion"] Inside = 1, 
  [helpstring "Outside the pavillion"] Outside = 2, 
  [helpstring "Not near the pavillion"] Offsite = 3 
} location;

Alias-Syntax

Die Delphi-Syntax für die Deklaration von Alias-Typinformationen sieht wie folgt aus:

AliasName = BasisTyp[Attribute];

Das folgende Beispiel deklariert DWORD als einen Alias für Integer:

DWORD = Integer [uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}'];

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}'] typedef long DWORD;

Record-Syntax

Die Delphi-Syntax für die Deklaration von Record-Typinformationen sieht wie folgt aus:

RecordName = record [Attribute] Feldliste end;

Das folgende Beispiel deklariert einen Record:

Tasks = record [uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
                helpstring 'Task description'] 
  ID: Integer; 
  StartDate: TDate; 
  EndDate: TDate; 
  Ownername: WideString; 
  Subtasks: safearray of Integer; 
end;

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
        helpstring "Task description"] 
typedef struct 
{ 
  long ID; 
  DATE StartDate; 
  DATE EndDate; 
  BSTR Ownername; 
  SAFEARRAY (int) Subtasks; 
} Tasks;

Union-Syntax

Die Delphi-Syntax für die Deklaration von Union-Typinformationen sieht wie folgt aus:

UnionName = record [Attribute] 
case Integer of 
  0: Feld1; 
  1: Feld2; 
  ... 
end;

Das folgende Beispiel deklariert eine Union:

MyUnion = record [uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
                  helpstring "item description"] 
case Integer of 
  0: (Name: WideString); 
  1: (ID: Integer); 
  3: (Value: Double); 
end;

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
        helpstring "item description"] 
typedef union 
{ 
  BSTR Name; 
  long ID; 
  double Value; 
  } MyUnion;

Modul-Syntax

Die Delphi-Syntax für die Deklaration von Modul-Typinformationen sieht wie folgt aus:

ModuleName = module Konstanten Einsprungspunkte end;

Im folgenden Quelltextausschnitt wird eine Typinformation für ein Modul deklariert:

MyModule = module [uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
                   dllname 'circle.dll'] 
   PI: Double = 3.14159; 
   function area(radius: Double): Double [ entry 1 ]; stdcall; 
   function circumference(radius: Double): Double [ entry 2 ]; stdcall; 
end;

Die äquivalente Syntax in Microsoft IDL lautet:

[uuid '{2MD36ABF-90E3-11D1-AA75-02C04FB73F42}', 
        dllname("circle.dll")] 
module MyModule 
{ 
  double PI = 3.14159; 
  [entry(1)] double _stdcall area([in] double radius); 
  [entry(2)] double _stdcall circumference([in] double radius); 
};

Themen

Siehe auch