<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-pascal
  published:     2023-12-01
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Jouer avec Docker et Pascal

> Peut-on exécuter aujourd'hui du code Pascal vieux de 30 ans ? Oui ! Ce guide vous montre comment utiliser Docker et le Free Pascal Compiler (FPC) pour compiler et exécuter vos anciens programmes Turbo Pascal.

---
![Jouer avec Docker et Pascal](/img/v2/experiments.webp)

**TL;DR**

Cet article ressuscite du code source Turbo Pascal vieux de 30 ans (récupéré dans la vieille archive SWAG) en utilisant l'image Docker `signumtemporis/fpc` pour compiler des fichiers `.pas` en exécutables Windows, sans aucune installation locale. Au programme : un « Hello World » et une vieille fonction de conversion d'un octet en binaire écrite en 1992.

Que de bons souvenirs... Pendant mes études (en 1991-1993), j'étais un grand fan de Turbo Pascal 7.0. C'est le premier langage que j'ai vraiment appris, et je l'adorais. Je passais des dizaines d'heures derrière mon ordinateur à écrire tout et n'importe quoi.

Si vous vous souvenez encore de cette époque, Turbo Pascal 7.0 servait à créer des exécutables pour MS-DOS.

L'idée de cet article m'est venue après celui écrit sur le [langage assembleur](/blog/docker-assembly) : est-il possible, en 2023, de faire tourner du code Pascal écrit 30 ans plus tôt ?

![Turbo Pascal](./images/turbo_pascal.webp)

La première chose à faire était de retrouver du vieux code source et, pour ça, je suis retourné voir le **S**ource**w**are **A**rchive **G**roup, plus connu sous le nom de **SWAG**.

La requête paramétrée suivante retrouve du code que j'ai publié il y a 30 ans : <https://www.google.com/search?q=avonture+site%3Ahttp%3A%2F%2Fwww.retroarchive.org>. Par nostalgie, j'ai aussi recopié ces sources ici : <https://github.com/cavo789/swag>.

## Hello world {#hello-world}

Lancez `mkdir C:\tmp\pascal && cd C:\tmp\pascal` dans une console MS-DOS pour créer un dossier appelé `pascal` et vous y placer.

Créez un nouveau fichier appelé `Hello.pas` avec ce contenu :

**Hello.pas**

```pas
begin
    writeln('Hello world! I''m a Turbo Pascal source code');
end.
```

Comme vous le savez, Pascal est un langage compilé et doit donc être compilé en `.exe`. La commande ci-dessous s'en charge :

```bash
$ docker run -it --rm -v %CD%:/app -w /app signumtemporis/fpc:cross.x86_64-win64.slim Hello.pas
Free Pascal Compiler version 3.2.2 [2021/12/10] for x86_64
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win64 for x64
Compiling Hello.pas
Linking Hello.exe
2 lines compiled, 0.1 sec, 32432 bytes code, 1508 bytes data
```

Notre exécutable a été créé. Il est temps de le lancer avec `Hello.exe` :

```bash
$ Hello.exe
Hello world! I'm a Turbo Pascal source code
```

Voilà, nous avons créé avec succès notre premier code Pascal en 2023.

*Ce blog possède une petite collection d'articles du type « faire tourner le langage X sans l'installer » : [Java](/blog/docker-java), [Python](/blog/docker-python) et [PHP](/blog/docker-php-run-script-or-website).*

> **Rappel sur la CLI Docker:**
>
> Pour rappel, les commandes `docker run` utilisées sont (presque toujours les mêmes) :
>
> * `-it` pour démarrer Docker en mode interactif, ce qui permet au script exécuté dans le container de vous poser des questions par exemple,
> * `--rm` pour demander à Docker de tuer et supprimer le container dès que le script a été exécuté (sinon vous vous retrouverez avec une tonne de containers Docker arrêtés mais pas supprimés ; vous pouvez le vérifier en n'utilisant pas le flag `--rm` puis en lançant `docker container list` dans la console),
> * `-v %CD%:/app` pour partager votre dossier courant avec un dossier appelé `/app` dans le container Docker,
> * `-w /app` pour dire à Docker que le répertoire courant, dans le container, sera le dossier `/app`,
> * puis `signumtemporis/fpc:cross.x86_64-win64.slim` qui est le nom de l'image Docker à utiliser et, enfin,
> * `Hello.pas` c'est-à-dire notre fichier source (l'image fpc ne semble pas demander de préciser l'exécutable `fpc` ; juste le fichier source).

## Convertir un nombre en octet {#convert-a-number-to-a-byte}

Essayons quelque chose d'*un peu plus complexe* qu'un simple *Hello world* : une fonction de conversion pour déterminer la représentation binaire d'un nombre positif *(soyez indulgent, c'était un devoir scolaire 😄)*.

J'ai écrit cette fonction en 1992 (publiée dans le *SWAG* en 1997) : <https://github.com/cavo789/swag/blob/master/Byte2Bin/files/source.pas>

Créez le fichier `Byte2Bin.pas` sur votre disque avec ce contenu :

**Byte2Bin.pas**

```pas
Function Byte2Bin (Chiffre : Byte) : String;

Var I, Temp : Byte;
    St      : String;

Begin

   St := '';

   For I := 7 Downto 0 do Begin
       Temp := (Chiffre and (1 shl I));
       If (Temp = 0) then St := St + '0' Else St := St + '1';
   End;

   Byte2Bin := St;

End;

begin
    WriteLn( Byte2Bin(197) );
end.
```

> **SHL pour Shift left one position:**
>
> L'instruction `shl` décale le nombre d'un octet vers la gauche.

Et compilez-le :

```bash
$ docker run -it --rm -v %CD%:/workspace signumtemporis/fpc:cross.x86_64-win64.slim Byte2Bin.pas

Free Pascal Compiler version 3.2.2 [2021/12/10] for x86_64
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win64 for x64
Compiling Byte2Bin.pas
Linking Byte2Bin.exe
20 lines compiled, 0.1 sec, 32656 bytes code, 1508 bytes data
```

Comme vous pouvez le voir dans le code source, l'idée était d'afficher la représentation binaire de `197` et, oui !, c'est bien `11000101`. Toujours en 2023.

```bash
$ Byte2Bin.exe
11000101
```

OK, l'intérêt de faire tourner du code TP7 en 2023 est minime et inutile, mais c'est bien amusant de voir que ça marche encore.

Même idée, autre langage : j'ai aussi joué avec [Python](/blog/docker-python) et [Java](/blog/docker-java) en utilisant exactement la même approche Docker « zéro installation locale ».
