Italian community of Lazarus and Free Pascal

Il compilatore Free Pascal per Nintendo DS si appoggia su un toolkit esterno, il devkitARM, che mette a disposizione tools e librerie per programmare la console portatile. Il ciclo delle releases del Free Pascal però è notevolmente più lento di quanto non lo sia quello del devkitARM; non di rado ci si trova di fronte ad una nuova versione del toolkit a pochi giorni dal rilascio dell'ultima versione del Free Pascal.

Ovviamente ad ogni nuova versione vanno aggiornate le librerie e, in alcuni casi sporadici, dei dettagli nel compilatore; in mancanza di tali aggiornamenti (che, per inciso, richiedono una ricompilazione dell'intero toolchain del Free Pascal), ci si può trovare di fronte ad errori imprevisti o anche ad errori di compilazione. In questi casi torna utile sapere come scaricare e - soprattutto! - come ricompilare i sorgenti del Free Pascal per Nintendo DS. Si tratta di un'operazione abbastanza lunga, ma con un po' di pazienza si potrà avere sul proprio pc una versione nuova fiammante del compilatore. 

Prerequisiti

Come prima cosa occorre installare Tortoise SVN, che servirà per scaricare i sorgenti aggiornati dal repository SVN del freepascal. Ci servirà poi installare il devkitARM: scaricate l'ultima versione disponibile dell'updater (nel momento della stesura dell'articolo: devkitProUpdater-1.5.3.exe), avviatelo e seguite le indicazioni contenute nel video qui sotto.

Nel video indico alcune caratteristiche che al momento possiamo fare a meno di installare, come il supporto per il GBA, per la Wii e il Game Cube, ecc. Se non siete sicuri di cosa state facendo, non deselezionate niente e installate tutto così com'è impostato di default. Impiegherete un po' più di tempo, ma sarete sicuri di ottenere un toolkit funzionante.

Altra indicazione importantissima è quella di installare il devkit in una cartella che non contenga spazi, perché vengono utilizzati dei tools che, di fronte a percorsi con spazi, semplicemente non funzionano come dovrebbero. Quindi NON installate in una cartella sul desktop, mi raccomando!

Come ultimo passaggio, se non l'avete ancora fatto, installate una versione aggiornata del compilatore Free Pascal.

Recupero dei sorgenti

A questo punto tutto l'occorrente dovrebbe essere installato. Vediamo adesso come recuperare i sorgenti aggiornati di Free Pascal per Nintendo DS. Apriamo una finestra DOS, muoviamoci nella root del disco e creiamo una cartella che conterrà i sorgenti. In seguito muoviamoci all'interno della nuova cartella:

cd \ [invio]
md fpc_src [invio]
cd fpc_src [invio]

Ora è il momento di utilizzare TortoiseSVN per recuperare i sorgenti:

tortoiseproc.exe /command:export /path:"c:\fpc_src\" /notempfile [invio]

Premendo il tasto "Invio" si aprirà una finestra di dialogo; controllate se la directory di destinazione è esatta, quindi impostate l'URL del repository SVN da dove scaricare i sorgenti; premete il tasto "Ok" per far partire il download dei files. Questa operazione potrà richiedere tempo, a seconda della velocità della connessione a internet. 

In questo caso abbiamo deciso di scaricare i sorgenti dal ramo dei bug fixes della versione 2.6.0, situato in http://svn.freepascal.org/svn/fpc/branches/fixes_2_6/; in alcuni casi potrebbe essere conveniente scaricare una versione del ramo di sviluppo (trunk), situata in http://svn.freepascal.org/svn/fpc/trunk/, ad esempio per testare nuove caratteristiche del compilatore non ancora rilasciate, oppure per aggiornare soltanto la libreria libndsfpc, maggiormente soggetta a cambiamenti. Parleremo di quest'ultimo aspetto più avanti, quando tratteremo la ricompilazione delle librerie. Nel seguente video potete vedere tortoiseproc.exe in azione.

Iniziamo a compilare!

Dovrebbe ora essere tutto in ordine per cominciare a ricompilare i sorgenti di fpc. D'ora in avanti darò per assodato che i percorsi di installazione di quanto richiesto sopra siano questi:

• directory del devkitARM: c:\devkitPro
• directory di Free Pascal: c:\fpc
• directory dei sorgenti di Free Pascal: c:\fpc_src
• directory dove installare il nuovo compilatore: c:\fpc4nds
  

Un passo fondamentale per la riuscita del tutto è quello di aggiungere un paio di percorsi utili al path di ricerca. Da finestra di comando digitate:

set PATH=C:\devkitPro\devkitARM\bin;C:\fpc\bin\i386-win32;%PATH%  [invio]

E' chiaro che, qualora chiudiate la finestra della console di comando, queste modifiche alla variabile d'ambiente PATH andranno perse.

Compilazione del compilatore

Possiamo ora procedere con la compilazione del compilatore. Sempre da finestra di comando muoviamoci nella directory che contiene i sorgenti del compilatore:

cd c:\fpc_src\compiler  [invio]

Procediamo a ripulire la directory da eventuali precedenti tentativi di compilazione (nel caso di prima compilazione questo passaggio non serve, ma non fa mai male):

make clean [invio]

Al termine della pulizia, compiliamo il cross-compilatore, che girerà su i386-win32 ma produrrà binari per arm-nds:

make PPC_TARGET=arm [invio]

Al termine dovreste trovare nella directory un nuovo file chiamato ppcarm.exe, che altro non è che il cross-compilatore!

In questa fase è buona norma compilare anche alcuni tools e utilities che fanno da contorno al compilatore. Il primo, fpcmake, serve a creare dei makefile che utilizzeremo per ricompilare la RTL, la libreria e gli esempi. Muoviamoci nella sua cartella e compiliamolo:

cd C:\fpc_src\utils\fpcm  [invio]
make clean  [invio]
make  [invio]

Il secondo tool, fpcmkcfg, serve per creare i files di configurazione del compilatore. Può essere utile averlo a portata di mano, ma potete anche saltare questo passaggio. In ogni caso, come per l'altro tool:

cd C:\fpc_src\utils\fpcmkcfg  [invio]
make clean  [invio]
make  [invio]

Non ci rimane altro da fare che spostare i files appena creati nella nuova cartella di installazione. Creiamo la directory del cross-compilatore:

md C:\fpc4nds\bin\i386-win32  [invio]

Copiamo i files necessari:

copy /Y c:\fpc_src\compiler\ppcarm.exe c:\fpc4nds\bin\i386-win32\ppcrossarm.exe  [invio]
xcopy /Y c:\fpc_src\compiler\utils\*.exe c:\fpc4nds\bin\i386-win32\  [invio]
xcopy /Y c:\devkitPro\devkitARM\bin c:\fpc4nds\bin\i386-win32\  [invio]
copy /Y c:\fpc_src\utils\fpcm\fpcmake.exe c:\fpc4nds\bin\i386-win32\fpcmake.exe  [invio]
copy /Y c:\fpc_src\utils\fpcmkcfg\fpcmkcfg.exe c:\fpc4nds\bin\i386-win32\fpcmkcfg.exe  [invio]

Servirà anche di creare una cartella dove copiare i messaggi del compilatore:

md C:\fpc4nds\msg  [invio]
copy /Y c:\fpc_src\compiler\msg c:\fpc4nds\msg\  [invio]

Il compilatore ora è pronto per compilare la RTL e la libreria!

Compilazione della RTL

Spostiamoci nella directory "rtl\nds" dei sorgenti ed eseguiamo una pulizia:

cd C:\fpc_src\rtl\nds  [invio]
make clean  [invio]

Prima di provare a compilare dobbiamo ricreare il makefile, utilizzando il tool fpcmake.exe:

fpcmake -r -w -Tall  [invio]

Ora possiamo compilare la RTL. Il make in questo caso richiede alcuni parametri che eseguiranno la compilazione per nds invece che per win32:

make CPU_TARGET=arm OS_TARGET=nds PP="c:\fpc4nds\bin\i386-win32\ppcrossarm.exe" OPT="-Tnds -CX -XX -O2" BINUTILSPREFIX=arm-none-eabi- [invio]

Nel caso in cui tutto sia filato liscio non dovreste avere messaggi di errore. Creiamo adesso una directory nella cartella di installazione in cui copieremo la RTL:

md c:\fpc4nds\units\arm-nds
xcopy /Y c:\fpc_src\rtl\units\arm-nds c:\fpc4nds\units\arm-nds\rtl\  [invio]

L'ultimo passo è quello di creare un file Package.fpc, richiesto dal compilatore per trovare la RTL:

fpcmake -pv -Tnds  [invio]
copy /Y c:\fpc_src\rtl\nds\Package.fpc c:\fpc4nds\units\arm-nds\rtl\Package.fpc  [invio]

La RTL è pronta per essere utilizzata assieme al cross-compilatore per compilare la libreria.

Prima, però, è necessario creare un nuovo file di configurazione per il cross-compilatore, altrimenti non sarà in grado di trovare le librerie da linkare e la compilazione fallirà miseramente. Apriamo quindi un editor di testo (il notepad va benissimo) e scriviamo:

-Parm
-Tnds
-XParm-none-eabi-
# Percorsi da cambiare a seconda della vostra directory di installazione
-FuC:\fpc4nds\units\arm-nds\*
-FuC:\fpc4nds\units\arm-nds\rtl
-FuC:\fpc4nds\units\arm-nds\libndsfpc 
-FDC:\fpc4nds\bin\i386-win32
-Flc:\devkitPro\libnds\lib
#IFDEF __THUMB__
 # Controllare se la versione del devkitARM sia effettivamente la 4.7.1
 # altrimenti cambiare di conseguenza
 -Flc:\devkitPro\devkitARM\lib\gcc\arm-none-eabi\4.7.1\thumb
 -Flc:\devkitPro\devkitARM\arm-none-eabi\lib\thumb 
#ELSE
 # Controllare se la versione del devkitARM sia effettivamente la 4.7.1
 # altrimenti cambiare di conseguenza
 -Flc:\devkitPro\devkitARM\lib\gcc\arm-none-eabi\4.7.1
 -Flc:\devkitPro\devkitARM\arm-none-eabi\lib
#ENDIF

Salviamo il file nella directory del compilatore (nel nostro caso c:\fpc4nds\bin\i386-win32) chiamandolo "fpc.nds.cfg".

Piccola nota da prendere in considerazione: nel momento in cui sto scrivendo questo tutorial, la versione della libreria libgcc del devkitARM è effettivamente la 4.7.1; in ogni caso controllate sempre il percorso (c:\devkitPro\devkitARM\lib\gcc\arm-eabi\x.y.z) e cambiate i valori nel file fpc.nds.cfg in modo tale che siano uguali a quelli che avete nella vostra installazione del devkitARM.

Compilazione della libreria "libndsfpc"

Siamo giunti finalmente all'ultimo step che ci porterà ad avere un compilatore Free Pascal per Nintendo DS perfettamente funzionante! Ricompiliamo quindi la libreria libndsfpc. Spostiamoci nella directory dei sorgenti della libreria ed eseguiamo una pulizia approfondita:

cd C:\fpc_src\packages\libndsfpc  [invio]
make cleanall units  [invio]

Ricreiamo anche in questo caso il file makefile:

fpcmake -r -w -Tall  [invio]

Procediamo con la compilazione della libreria:

make PP=c:\fpc4nds\bin\i386-win32\ppcrossarm.exe OPT="@c:\fpc4nds\bin\i386-win32\fpc.nds.cfg -gl -g Ur -Si -CX -O2 -XX -XD" BINUTILSPREFIX=arm-none-eabi-  [invio]

Alla fine della procedura di compilazione, creiamo una directory nella cartella di installazione in cui copieremo la libreria:

md c:\fpc4nds\units\arm-nds\libndsfpc
xcopy /Y c:\fpc_src\packages\libndsfpc\units\arm-nds c:\fpc4nds\units\arm-nds\libndsfpc\  [invio]

L'ultimo passo è quello di creare un file Package.fpc, richiesto dal compilatore per trovare la libreria:

fpcmake -pv -Tnds  [invio]
copy /Y c:\fpc_src\packages\libndsfpc\Package.fpc c:\fpc4nds\units\arm-nds\libndsfpc\Package.fpc  [invio]

Complimenti! Siete riusciti nell'impresa di portare a termine la compilazione del cross-compilatore freepascal per Nintendo DS!

Compilazione degli esempi

Non ci resta che provare a compilare gli esempi per vederli girare su un emulatore. La procedura non si discosta molto da quelle viste più sopra, per cui non dovreste avere difficoltà nel ricompilare gli esempi. Spostiamoci nella directory degli esempi, ricreiamo i makefile ed eseguiamo la pulizia di rito:

cd C:\fpc_src\packages\libndsfpc\examples  [invio]
fpcmake -r -w -Tnds [invio]
make cleanall [invio]

Procediamo ora con la ricompilazione degli esempi:

make CPU_TARGET=arm OS_TARGET=nds PP="c:\fpc4nds\bin\i386-win32\ppcrossarm.exe" OPT="@c:\fpc4nds\bin\i386-win32\fpc.nds.cfg -gl -g -CX -O2" BINUTILSPREFIX=arm-none-eabi-[invio]

Dopo una lunga compilazione dovreste avere in ogni cartella degli esempi un file .nds che rappresenta la rom da caricare nell'emulatore.

Aggiornare la libreria libndsfpc

La libreria libndsfpc altro non è che una traduzione dal c al Pascal della libreria libnds, che viene distribuita assieme al devkitARM. Come abbiamo già accennato, spesso ci si viene a trovare in una situazione paradossale: scarichiamo l'ultima versione del freepascal per NDS, magari uscita da pochi giorni, convinti di avere il toolchain più aggiornato, e invece ci troviamo di fronte ad una libreria libndsfpc che è diventata obsoleta in quanto, nel frattempo, la libreria libnds del devkitARM è stata aggiornata 2 volte nel giro di tre giorni! Ok, questo è un caso limite (ma vi assicuro che è successo!); il punto della questione è che spesso ci dovremo armare di santa pazienza, scaricare la libreria libndsfpc e ricompilarla per renderla compatibile con l'ultima versione di libnds. Mi raccomando, però: datemi il tempo di aggiornare i sorgenti! In genere, dopo un rilascio di libnds, nel giro di un paio di giorni libndsfpc viene aggiornata e i sorgenti vengono uploadati nel ramo di sviluppo del compilatore freepascal. 

Qui vedremo come aggiornare soltanto la libreria. Vi riporto tutti i passaggi in un unico blocco, tanto sono operazioni che già avete compiuto in precedenza.

tortoiseproc.exe /command:export /path:"c:\fpc_src\packages\" /notempfile [invio]
cd C:\fpc_src\packages\libndsfpc  [invio]
make cleanall units  [invio]
fpcmake -r -w -Tall  [invio]
make PP=c:\fpc4nds\bin\i386-win32\ppcrossarm.exe OPT="@c:\fpc4nds\bin\i386-win32\fpc.nds.cfg -gl -g -Ur -Si -CX -O2 -XX -XD" BINUTILSPREFIX=arm-none-eabi-  [invio]
xcopy /Y c:\fpc_src\packages\libndsfpc\units\arm-nds c:\fpc4nds\units\arm-nds\libndsfpc\  [invio]
fpcmake -pv -Tnds  [invio]
copy /Y c:\fpc_src\packages\libndsfpc\Package.fpc c:\fpc4nds\units\arm-nds\libndsfpc\Package.fpc  [invio]

In questo caso scaricheremo i sorgenti dall'URL http://svn.freepascal.org/svn/fpc/trunk/packages/libndsfpc/, che andremo a copiare nel campo apposito nella finestra di dialogo di tortoiseproc.exe.

Oppure...

...oppure si può utilizzare un altro metodo, molto più semplice, che però funzionerà soltanto sui sorgenti del ramo trunk (http://svn.freepascal.org/svn/fpc/trunk/). Dopo avere recuperato i sorgenti e installato i binari richiesti (vedi il paragrafo "Prerequisiti"), installiamo anche la nuova versione 2.6.0 del Free Pascal, ad esempio nella directory c:\lazarus\fpc\2.6.0. Questo passo è necessario in quanto questa procedura semplificata non compila alcuni tools necessari.

Muoviamoci quindi nella directory principale dei sorgenti:

cd c:\fpc_src  [invio]

make clean buildbase installbase CROSSINSTALL=1 OS_TARGET=nds CPU_TARGET=arm BINUTILSPREFIX=arm-none-eabi- INSTALL_PREFIX=C:\lazarus\fpc\2.6.0 RELEASE=1   [invio]

La macro INSTALL_PREFIX servirà ad indicare la directory dove i files verranno installati. Occorre poi copiare i binari del devkitARM nella directory dei binari del Free Pascal:

xcopy /Y c:\devkitPro\devkitARM\bin c:\lazarus\fpc\2.6.0\bin\i386-win32  [invio]

cd c:\fpc_src\packages\libndsfpc  [invio]

set FPCDIR=c:\lazarus\fpc\2.6.0  [invio]

fppkg -g --cpu=arm --os=nds --compiler=ppcrossarm.exe --options="-XParm-none-eabi-" install  [invio]

Anche in questo caso, il file di configurazione del compilatore Free Pascal va salvato col nome "fpc.nds.cfg" (vedere paragrafo "Compilazione della RTL").

Salviamo, chiudiamo e il gioco è fatto: il compilatore è pronto all'uso!

Per commenti e chiarimenti: http://www.lazaruspascal.it/index.php?topic=78.0