Migrating Delphi Code to Mobile from Desktop

Go Up to Delphi Considerations for Multi-Device Applications

This topic describes how to migrate existing Delphi code to use the Delphi mobile compilers:

• DCCIOSARM64.EXE, the Delphi Compiler for the 64-bit iOS Device
• DCCAARM.EXE, the Delphi Compiler for Android,
• DCCAARM64.EXE, the Delphi Compiler for Android 64-bit

Update Array Types

Update all array declarations to be dynamic. Use either of the following:

var x: array of Integer;

x: TArray<Integer>;

There are cases when a structure (a record) must be passed through to an external function, and the structure contains an array declared with a specific length. This is especially true for character arrays declared "in-place" within the structure. In this case, and only this case, is the following allowed:

type
   rec = record
    Flags: Integer;
    Chars: array[MAX_PATH] of Char;
  end;

In cases where an external function takes an array directly, use a dynamic array instead. For UTF8 character arrays:

• To convert from UTF8, use TBytes along with System.SysUtils.TEncoding.GetString(Bytes).
• To convert to UTF8, use TBytes along with System.SysUtils.TEncoding.GetBytes(S).

Use a Function Call in a try-except Block to Prevent Uncaught Hardware Exceptions

With the compiler for iOS devices, except blocks can catch a hardware exception only if the try block contains a method or function call. This is a difference related to the LLVM backend of the compiler, which cannot return if no method/function is called in the try block.

For example, this is how to structure a try-except block that can catch a hardware exception:

var
  P: ^Integer = nil;

procedure G1;
begin
  P^ := 42;
end;

begin
  try
    G1;
  except
    writeln('Catch:G1 - pass');
  end;
end.

Even if a source code block looks like it contains a function call, that may not be the case if the function is inlined. This is because by the time LLVM generates machine instructions, the inlining process has already occurred, and there is no longer a function call within the try block.

Use Atomic Instrinsics Instead of Assembly Language

The Delphi mobile compilers do not support a built-in assembler. You can use the new atomic intrinsic functions if you need to atomically exchange, compare-and-exchange, increment, and decrement memory values.

Atomic operations are used to implement multi-threaded locking primitives and provide the primitives necessary for implementing so-called "lock-free" structures. The kinds of operations needed are implemented as standard functions or "intrinsic" functions.

In a multi-platform application, atomic intrinsics can be used inside {$IFDEF} depending on the target platform.

Atomic Intrinsic Functions

Following are the atomic intrinsic functions supported by the Delphi mobile compilers:

• System.AtomicExchange
• System.AtomicIncrement
• System.AtomicCmpExchange
• System.AtomicDecrement

See Also

• iOS Mobile Application Development

• DCCIOSARM64.EXE, the Delphi Compiler for the 64-bit iOS Device
• DCCAARM.EXE, the Delphi Compiler for Android
• DCCAARM64.EXE, the Delphi Compiler for Android 64-bit
• Mobile Tutorials: Mobile Application Development (iOS and Android)
• Mobile Code Snippets
• System.SysUtils.TStringHelper
• System.SysUtils.TStringBuilder
• Zero-based strings (Delphi compiler directive)
• Migrating C++ Code to Mobile from Desktop