Welche zeigerbezogenen Dinge funktionieren in den mobilen Compilern von Delphi XE8 nicht?

Question

Embarcadero DocWiki Seite LLVM-based Delphi Compilers listet mehrere Sprachänderungen in Delphi XE8. Eine der Aufzählungszeichen lautet:

Die Verwendung von Zeigern wird von LLVM-basierten Delphi-Compilern nicht unterstützt.

Was genau bedeutet das in der Praxis? Welche Zeiger-bezogenen Dinge, die früher in Delphi XE7 funktionierten, funktionieren in Delphi XE8 nicht mehr? Ich kann keine ausführliche Erklärung dazu auf der Embarcadero-Website finden. Die Seite Migrating Delphi Code to Mobile from Desktop, die mehr Informationen enthalten soll, erwähnt zum Beispiel nicht das Wort "Zeiger".

Answer 1

Die Verwendung von Zeigern wird von LLVM-basierten Delphi-Compilern nicht unterstützt.

Das muss ein Fehler in der Dokumentation sein. Sehen Sie sich die RTL an. Es ist dick mit der Verwendung von Zeigern.

Zum Beispiel, wie etwa CompareMem. Es ist wie folgt definiert:

function CompareMem(P1, P2: Pointer; Length: Integer): Boolean; 

Und die Umsetzung läuft wie folgt aus:

function CompareMem(P1, P2: Pointer; Length: Integer): Boolean; 
{$IF defined(POSIX)} 
begin 
    if Length <= 0 then 
    Result := True 
    else 
    Result := memcmp(P1^, P2^, Length) = 0; 
end; 
{$ELSEIF defined(PUREPASCAL)} 
.... 
{$ENDIF !PUREPASCAL} 

Der POSIX-Code wird durch die mobilen Ziele verwendet.

Oder wie wäre es TObject, die wie folgt aussieht:

type 
    TObject = class 
    public 
    constructor Create; 
    procedure Free; 
    procedure DisposeOf; {$IFNDEF AUTOREFCOUNT} inline; {$ENDIF} 
    class function InitInstance(Instance: Pointer): TObject {$IFDEF AUTOREFCOUNT} unsafe {$ENDIF}; 
    procedure CleanupInstance; 
    function ClassType: TClass; inline; 
    class function ClassName: string; 
    class function ClassNameIs(const Name: string): Boolean; 
    class function ClassParent: TClass; 
    class function ClassInfo: Pointer; inline; 
    class function InstanceSize: Integer; inline; 
    class function InheritsFrom(AClass: TClass): Boolean; 
    class function MethodAddress(const Name: _ShortStr): Pointer; overload; 
    class function MethodAddress(const Name: string): Pointer; overload; 
    class function MethodName(Address: Pointer): string; 
    class function QualifiedClassName: string; 
    function FieldAddress(const Name: _ShortStr): Pointer; overload; 
    function FieldAddress(const Name: string): Pointer; overload; 
    function GetInterface(const IID: TGUID; out Obj): Boolean; 
    class function GetInterfaceEntry(const IID: TGUID): PInterfaceEntry; 
    class function GetInterfaceTable: PInterfaceTable; 
    class function UnitName: string; 
    class function UnitScope: string; 
{$IFDEF AUTOREFCOUNT} 
    function __ObjAddRef: Integer; virtual; 
    function __ObjRelease: Integer; virtual; 
{$ENDIF} 
    function Equals(Obj: TObject): Boolean; virtual; 
    function GetHashCode: Integer; virtual; 
    function ToString: string; virtual; 
    function SafeCallException(ExceptObject: TObject; 
     ExceptAddr: Pointer): HResult; virtual; 
    procedure AfterConstruction; virtual; 
    procedure BeforeDestruction; virtual; 
    procedure Dispatch(var Message); virtual; 
    procedure DefaultHandler(var Message); virtual; 
    class function NewInstance: TObject {$IFDEF AUTOREFCOUNT} unsafe {$ENDIF}; virtual; 
    procedure FreeInstance; virtual; 
{$IFDEF AUTOREFCOUNT} 
    protected 
{$ENDIF} 
    destructor Destroy; virtual; 

{$IFDEF CPP_ABI_SUPPORT} 
    procedure CPP_ABI_1; virtual; 
    procedure CPP_ABI_2; virtual; 
    procedure CPP_ABI_3; virtual; 
{$ENDIF !CPP_ABI_SUPPORT} 

    protected 
    function GetDisposed: Boolean; inline; 
    procedure CheckDisposed; {$IFNDEF AUTOREFCOUNT} inline; {$ENDIF} 

{$IFDEF AUTOREFCOUNT} 
    private const 
    objDestroyingFlag = Integer($80000000); 
    objDisposedFlag = Integer($40000000); 
    protected 
    [Volatile] FRefCount: Integer; 
    class procedure __MarkDestroying(const Obj); static; inline; 
    class function __SetDisposed(const Obj): Boolean; static; inline; 
    public 
    property RefCount: Integer read FRefCount; 
{$ENDIF} 
    property Disposed: Boolean read GetDisposed; 
    end; 

Es ist ziemlich klar, dass Zeiger hier verwendet werden, auf mobilen Plattformen.

Haben Sie einen Lesevorgang des Embarcadero White Paper zum Thema: The Delphi Language for Mobile Development. Wiederum behandelt es die Verwendung von Zeigern bei mehreren Gelegenheiten und es ist klar, dass sie unterstützt werden. Nun, es ist auch wahr, dass die Verwendung von Zeigern nicht empfohlen wird und wenn Zeiger leicht vermieden werden können, werden Sie dazu ermutigt. Aber das ist ziemlich anders als zu behaupten, dass Zeiger nicht von den Compilern unterstützt werden.

Es zumindest scheint zu sein, leicht ironisch, dass Embarcadero FUD ihrer eigenen Produkte verbreiten.