=========================
Compiling Perl on Android
=========================
:CreationDate: 2012-09-01 09:19:00
:Id: SW/perl-on-android
:tags: - software
- perl
.. admonition:: use Termux
In the years since this page was written, a much better alternative
has emerged: `Termux <https://termux.com/>`_. It gives you a Debian
chroot, with Perl, Rakudo, Python, Ruby, EMACS…
At `YAPC::EU 2012`_, I only had my Asus TF101, and I wanted to play
with some of the modules that the speakers were talking about.
The Google-provided "Perl for Android" (part of the `Android Scripting
Environment`_) is nearly useless, since you don't get the whole Perl
core, the CPAN shell does not work, and you don't have a compiler for
XS modules.
Another option would be to cross-compile from a normal computer, but
apart from the fact that I did not another computer with me, you still
would not be able to install XS modules directly from the
cross-compiled Perl.
So I did what any self-respecting programmer would do: tried to build
my own. I haven't yet managed to completely build the Perl
distribution, but I have come some way, and I thought that it would be
nice to write things down.
Prerequisites
=============
First of all, you need root access on your device: we have to create
filesystems, change owners and permissions, mount images.
Then, you need quite some RAM, storage, and processor. I wouldn't try
it on a phone or a low-powered tablet.
Finally, you need ``busybox``: the bare-bones command line tools
shipped with most Android images are so limited that not even the very
conservative Perl ``Configure`` can use them. You'll want to execute
this (or something similar) to get ``busybox`` binaries in preference
to the built-in ones::
export PATH=/system/xbin:$PATH
Preparations
============
We need a native compiler. I found a well-built ``gcc`` on a wiki
about ``R``:
http://rwiki.sciviews.org/doku.php?id=getting-started:installation:android
Get the two ``gcc`` tarballs.
We're going to build a filesystem image, mount it via the loopback
device, and install everything there: this way, the image can be moved
between devices (we'll make sure everything is as relocatable as
possible). I stored everything under ``/data/media/native`` (I created
that directory). ``/data/media`` is, on my device, the actual store
that is exposed (via a sort of bind-mount) as ``/sdcard``, with the
difference that the latter has ``noexec``, the former doesn't.
We want a rather large image, let's say 3 GB. I tried to make a sparse
file with ``dd if=/dev/zero of=native.e2.diskimg bs=1024 seek=3000000
count=1`` but it failed. I ended up creating two smaller files and
concatenating them. Then::
# cd /data/media/native
# mke2fs -f native.e2.diskimg
# cat > /data/media/native/start <<EOF
#!/xbin/ash
export PATH=/system/xbin:$PATH
BASE="$(dirname "$(readlink -f "$0")")"
DEST=/Removable
if [[ -d $DEST/fs/bin ]]; then
true
else
mkdir -p $DEST/fs
mount -o loop -t ext2 $BASE/native.e2.diskimg $DEST/fs
fi
echo PATH=\"$DEST/fs/bin:/system/xbin:$PATH\"
echo LD_LIBRARY_PATH=\"$DEST/fs/lib\"
EOF
# cat > /data/media/native/stop <<EOF
#!/xbin/ash
export PATH=/system/xbin:$PATH
BASE="$(dirname "$(readlink -f "$0")")"
DEST=/Removable
if [[ -d $DEST/fs/bin ]]; then
umount $DEST/fs
else
true
fi
EOF
# chmod +x start stop
Let's mount the (still empty) image (as a normal user, not ``root``)::
$ eval $(su -c /data/media/native/start)
and fill it up::
# cd /Removable/fs
# bzcat2 $wherever/android_gcc_r2a.tar.bz2|tar xvf -
# bzcat2 $wherever/android_gcc_supplement.tar.bz2|tar xvf -
(my ``tar`` does not understand ``bzip``-ed archives, so I had to
decompress them separately)
We need some temporary directories::
# mkdir -p /Removable/fs/tmp
# chown root:root /Removable/fs/tmp
# chmod 1777 /Removable/fs/tmp
My shell (the built-in ``/bin/sh``) needs a temporary space under
``/sqlite_stmt_journals`` for its "here-docs", but my image did not
mount it, so I had to do it manually::
# mkdir /sqlite_stmt_journals
# mount -t tmpfs none /sqlite_stmt_journals
My installation also lacked a ``true`` binary, which is needed by lots
of makefiles. I created it this way::
# cat > /Removable/bin/true <<EOF
#!/bin/sh
EOF
# chmod +x /Removable/bin/true
Building ``perl``
=================
From here on, we can run as a normal user.
Get a ``perl`` source tarball, and expand it::
$ cd /Removable/fs/tmp
$ tar zxf $perl_tarball
$ cd perl-*
We're now ready to build::
$ BASE=/Removable/fs ./Configure -de -Dprefix=$BASE \
-Duserelocatableinc -Dcc=gcc -Dlibpth=$BASE/lib
At the end of the configuration (which should run without errors),
you'll still not be able to just run ``make``: we have to edit a few
files.
First, in ``perl.h``, just before ``# endif /* !USE_LOCALE_NUMERIC
*/``, add this line::
#define IN_LOCALE_COMPILETIME 0
In the source file for ``Cwd``, we have to tell it to look for the
``pwd`` binary all over the ``$PATH``, or at least in
``/system/xbin/pwd``, otherwise it won't find it, and return empty
strings.
In the source file for ``Errno``, we have to add
``/Removable/fs/include`` to the list of places where it looks for
``errno.h``. It should probably ask the compiler for the search list,
but different compilers do it differently, and it's a mess anyway.
Now, running ``make`` should build ``miniperl``, some core libraries,
``perl``, some more libraries, and fail as soon as ``XSLoader`` is
needed. I'm still investigating this.
Future work
===========
- get to the end of the build
- package the image and make it available
- submit patches to reduce the need to muck about with paths and
headers
*UPDATE*
========
Other people have been working on this, putting in way more effort, and
getting better results: the master branch of perl now can be compiled
(natively or cross) on Android:
https://github.com/Perl/perl5/commit/b373396993794bd428d71821e0a3f89d22a2ccb0
.. _`YAPC::EU 2012`: http://act.yapc.eu/ye2012/
.. _`Android Scripting Environment`: http://code.google.com/p/android-scripting/
