PalmOS port

│ English (en) │ español (es) │ português (pt) │

Currently, the PalmOS port is a retro, "just for fun" port of the compiler and runtime libraries, based on an earlier, incomplete effort from over a decade ago. The port was originally started by Mazen Neifer. Peter Vreman ported PalmOS API headers. m68k port and 3.1.x+ compiler support and maintenance by Károly Balogh. The PalmOS port is a crosscompiler-only target.

Status

• The 3.1.x compiler has compiler support (very experimental) for PalmOS.
• m68k CPU is supported, including syscall generation support. Only small code is supported at the moment.
• ARM CPU is not yet supported
• Base RTL units are buildable but functionality is minimal.
• There's a palmunits package, basic functionality was tested successfully.
• Resource compilation is broken at the moment.

CPU Defaults

The m68k PalmOS port defaults to 68000 CPU subarchitecture and no FPU. Note that by default, the PalmOS port doesn't include the RTL's SoftFPU. For floating point calculations, one can use the OS supplied floating point unit helper API, or recompile the RTL with the SoftFPU included, using argument -CfSOFT.

Identification

To identify PalmOS exclusively during compile-time, use {$IFDEF PALMOS}.

SysCalls

It's not required to use inline assembly to do system calls. Any trap function can be defined the following way:

function MemPtrNew(size: UInt32): MemPtr; syscall $A013;

Note the syscall modifier in the function declaration. The argument to the syscall modifier is the trap number to call. The arguments to a syscall function are always passed on the stack and they're word (2 byte) aligned. Optionally, the numerical trap ID (here shown in hexadecimal) can be defined by a constant. For further examples, see the file rtl/palmos/palmos.inc in the RTL source or the palmunits package.

Building Tutorial

During the tutorial some paths will be supposed to demonstrate the build process. Just substitute those paths with the ones on your system.

Cross binutils

The older version of GNU binutils included in prc-tools is difficult to build on modern systems, like macOS/Darwin 10.12 or any 64-bit Linux. It is recommended to use the prc-tools-remix repository instead. This supports both m68k and ARM prc tools, and it is fixed to build and work on current systems. It also provides up to date installation instructions, see there.

Cross compiler

We will suppose that your are using debian linux installation (sid) and fpc compiler is already installed and correctly configured. Under debian linux (sid) you may install the fp-compiler package ("apt-get install fp-compiler")

Now you need to build fpc cross compiler for ARM processor. To do that you need latest fpc 2.1.x sources in addition to your working installation of fpc 2.0.2 or 2.0 already mentioned. Get the latest 2.1.x source repository from Subversion: http://www.freepascal.org/develop.html#svn

Environment

We will suppose your Free Pascal 2.1.x source code is located here: ${FPC_SRC}

PATH="/bin:/usr/bin:/usr/bin/X11:/usr/local/bin:${FPC_SRC}/compiler"

The Build process

In order to build the cross compiler it is necessary to have a correct PATH environment variable. Please ensure that your path is correct:

make all CPU_TARGET=arm OS_TARGET=palmos

On the end of the compile you should not see any errors.

You should have a ppccrossarm in ${FPC_SRC}/compiler and some .o and .ppu files in ${FPC_SRC}/rtl/units/arm-palmos

Now copy those files to your Free Pascal installation. The cross compiler ppccrossarm should go to /usr/local/bin/arm-palmos and the units to /usr/local/lib/fpc/units/arm-palmos

Configuration file

Now you need to edit your FPC configuration file ${HOME}/.fpc.cfg in order to use ppccrossarm.exe easy and add the following lines to it:

#IFDEF FPC_CROSSCOMPILING
-Tpalmos
-Fu${FPC_SRC}/rtl/units/arm-palmos
-XParm-palmos-
#ENDIF

Compiling a Test Project

You compiled the compiler! Now, what can I do with it? This is a tutorial to create a hello world like software with your new compiler.

Installing and Configuring the Emulator

First of all, you need to install the Palm Device Emulator. This is a windows binary, but works well with WINE on a Debian Linux (sid) box. TODO

Compiling

A example file to compile:

program test;

{$apptype console}

var
  Str: string;
begin
  WriteLn('Software Developed with:');
  WriteLn('The Free Pascal Compiler');
  WriteLn('');
  WriteLn('Please, enter your name:');
  ReadLn(Str);
  WriteLn('Your name is: ' + Str);
end.

Sample command line to compile test.pas:

ppcrossarm test.pas

You should get test.prc executable file. Copy it to your Palm device and run it.

Debugging PalmOS applications

This section is not yet available

Building FPC libraries

If you want to build libraries available with FPC, for example you want to build FCL then execute the commands above.

*
cd ${FPC_SRC}/fpc
make OS_TARGET=palmos CPU_TARGET=arm PP=ppcrossarm fcl

You will get FCL units in ${FPC_SRC}/fpc/fcl/units/arm-palmos.

Documentation

PalmOS port notes

• PalmOS does not have support for console applications by default. But you can install console support by yourself. Please note that FPC creates GUI applications for PalmOS target by default. To create console application you should use -WC compiler switch or put {$APPTYPE CONSOLE} directive to source code.

Links

• Buildfaq is a general FAQ about how to build and configure FPC.

Here are some links related to ARM CPU Architecture

• ARM Core Developers Forum Not that much active though.
• GCC ARM Improvement Project
• ARM ASSEMBLER Good information and codes related to arm assembly language.
• GNU ARM toolchain for Cygwin, Linux and MacOS
• ARM Instruction Sets & Programs Very good and consice information about arm architecture
• The ARM Instruction Set Another fine power point file about arm

Contacts

Mazen NEIFER