execrom_executeur_roms.conv (7797B)
1 titre:execrom(8) : l’exécuteur de ROMs 2 auteur:~ldp 3 date_pub:23fe 4 type:article 5 description:Défense et illustration d’execrom(8), qui permet de lancer des programmes interprétés avec la même facilité que des programmes compilés dans le format natif du système d’exploitation. 6 uuid:973a9308-49e2-4752-8e86-42ea27dbb366 7 8 Sous les systèmes d’exploitation de type Unix, il est possible de lancer des programmes textes interprétés comme s’ils étaient des exécutables natifs. Il suffit pour ce faire de placer en tête du fichier une ligne començant par « #! » et se terminant par le chemin absolu vers le programme capable de l’interpréter. Un argument peut aussi être donné. Par exemple, un fichier possédant les permissions appropriées et contenant le programme suivant est exécuté par le programme /bin/sh et affiche « Salut! ». 9 10 ``` 11 $ cat exemple.sh 12 #!/bin/sh 13 14 echo "Salut!" 15 ``` 16 17 ``` 18 $ ./exemple.sh 19 Salut! 20 ``` 21 22 Cette fonctionalité est très utile et polyvalente. Elle n’est malheureusement pas compatible avec tous les fichiers qu’on voudrait pouvoir exécuter de cette manière: l’interpréteur doit traiter cette première ligne comme un commentaire, l’ignorer, et certains types de fichier contenant des programmes en format texte ou en format binaire ne le permettent pas. 23 24 Mon objectif en concevant execrom(8) était de rendre possible l’exécution de ROMs compatibles avec le CPU fictif Uxn sans avoir à en spécifier explicitement l’interpréteur ni avoir à donner le chemin vers la ROM à interpréter. Bref, je voulais pouvoir les lancer à la manière des autres programmes du système. La solution que je propose ici est plus générable. Elle est capable de préparer l’interprétation de n’importe quel fichier avec presque n’importe quel interpréteur, pourvu que l’interpréteur approprié se trouve dans le chemin (PATH) et qu’il soit programmé pour interpréter le programme donné comme premier argument. 25 26 => https://wiki.xxiivv.com/site/uxn.html Uxn (en anglais) 27 28 ## Principe 29 30 Le fonctionnement d’execrom(8) repose sur le fait qu’il est possible d’invoquer un même programme par différents noms, et que le nom d’invocation est accessible au programme invoqué. Selon une convention presque unanime, le premier élement de la liste d’arguments donnés à un programme correspond au nom d’invocation. Dans l’interpréteur de commandes, il est contenu dans la variable $0. 31 32 Dans l’exemple qui suit, le fichier illustration.sh contient un programme interprété qui affiche son nom d’invocation. 33 34 ``` 35 $ cat illustration.sh 36 #!/bin/sh 37 38 echo "Mon nom est $0" 39 ``` 40 41 N’oublions pas d’autoriser l’exécution du programme. 42 43 ``` 44 $ chmod +x illustration.sh 45 ``` 46 47 Si le programme est invoqué par « ./illustration.sh », $0 contient « ./illustration.sh »; s’il est invoqué par « ././illustration.sh », $0 contient « ././illustration.sh », etc. 48 49 ``` 50 $ ./illustration.sh 51 Mon nom est ./illustration.sh 52 $ ././illustration.sh 53 Mon nom est ././illustration.sh 54 ``` 55 56 On peut invoquer le programme avec un nom complètement différent grâce aux liens symboliques. En créant un tel lien nommé « autre_nom.sh » vers « illustration.sh », on peut exécuter le même programme sous cet autre nom. 57 58 ``` 59 $ ln -s illustration.sh autre_nom.sh 60 $ ./autre_nom.sh 61 Mon nom est ./autre_nom.sh 62 ``` 63 64 Cette donnée permet à un programme de prendre des décisions informées par son nom d’invocation. 65 66 L’idée est donc la suivante. Les fichiers à interpréter sont placés dans un ou plusieurs dossiers répertoriés par la variable EXECROM_CHEM et dont la structure est analogue à celle de PATH. Le nom de ces fichiers a la forme « nom.interpréteur », où le préfixe « nom » correspond au nom du programme à interpréter et où le suffixe « interpréteur » est le nom de l’exécutable destiné à interpréter le programme. À son lancement, execrom(8) prend connaissance de son nom d’invocation et parcourt les dossiers répertoriés dans EXECROM_CHEM à la recherche d’un fichier dont le préfixe soit conforme au nom d’invocation. S’il le trouve, il exécute l’interpréteur désigné par le suffixe, en lui donnant sa liste d’arguments en argument. 67 68 L’idée est probablement plus facile à saisir avec un exemple. 69 70 ## Exemple 71 72 J’illustrerai l’utilisation d’execrom(8) avec drifblim et left, deux programmes écrits pour la machine virtuelle Varvara. Je supposerai que leurs ROMs se trouvent dans le dossier ~/uxn. 73 74 => https://wiki.xxiivv.com/site/uxn.html Varvara (en anglais) 75 => https://wiki.xxiivv.com/site/drifblim.html drifblim (en anglais) 76 => https://wiki.xxiivv.com/site/left.html left (en anglais) 77 78 drifblim est un assembleur uxntal interprétable par la machine virtuelle en mode texte uxncli(1). La commande ci-dessous assemble prog.tal dans prog.rom. 79 80 ``` 81 $ uxncli ~/uxn/drifblim prog.tal prog.rom 82 ``` 83 84 left est un éditeur de texte en mode graphique. Il doit donc être interprété par uxnemu(1). La commande suivante ouvre le fichier doc.txt avec l’éditeur. 85 86 ``` 87 $ uxnemu ~/uxn/left doc.txt 88 ``` 89 90 Je trouve que ces longues commandes rendent l’utilisation des ROMs pour Uxn peu conviviale. Mais grâce à execrom(8), il est possible d’exécuter les ROMs directement. 91 92 ``` 93 $ drifblim prog.tal prog 94 $ left doc.txt 95 ``` 96 97 Pour ce faire, il faut régler la variable d’environnement EXECROM_CHEM pour qu’elle contienne le chemin vers le dossier où se trouvent les ROMs, ici, ~/uxn. 98 99 ``` 100 $ export EXECROM_CHEM="$HOME/uxn:$EXECROM_CHEM" 101 ``` 102 103 Il faut aussi modifier le nom de chaque ROM pour que son préfixe et son suffixe correspondent à son nom d’invocation et au nom du programme destiné à l’interpréter, respectivement. Le résultat devrait être le suivant. 104 105 ``` 106 $ ls ~/uxn 107 drifblim.uxncli 108 left.uxnemu 109 ``` 110 111 Enfin, un lien symbolique accessible par PATH et pointant vers l’exécutable d’execrom(8) doit être créé pour chaque ROM. Ici, je prends pour acquis qu’execrom(8) est installé dans /usr/local/libexec/execrom. 112 113 ``` 114 $ ln -s /usr/local/libexec/execrom ~/.local/bin/driftblim 115 $ ln -s /usr/local/libexec/execrom ~/.local/bin/left 116 ``` 117 118 Voilà! 119 120 ## Conclusion 121 122 Je suis pour l’instant très content de mon outil. Il est très discret une fois installé et rend l’utilisation des ROMs Uxn bien plus conviviales. Malheureusement, il n’est pas dépourvu d’inconvénients; j’en ai identifié deux. 123 124 D’abord, cette méthode est moins simple à mettre en place qu’on ne pourrait l’espérer. Pour rendre exécutables des programmes sh, Perl, Python, Lua… compatibles avec la syntaxe, il suffit d’une ligne commençant par « #! » et d’un « chmod +x ». La méthode execrom(8) impose d’installer un outil supplémentaire, de régler la variable d’environnement EXECROM_CHEM pour qu’elle contienne le ou les dossiers appropriés, de donner un nom spécial aux ROMs dans une convention inusitée et de créer un lien symbolique vers l’exécutable de l’utilitaire. Ces manipulations rendent cette méthode un peu plus fragile. Je n’ai pourtant pas trouvé mieux. 125 126 Aussi, ce mécanisme n’est pas compatible avec les interpréteurs qui s’attendent à recevoir en argument plus qu’un le chemin vers un programme. Par exemple, pour être interprété, un programme awk(1) doit être donné en argument à l’option -f. Or execrom(8) n’a accès qu’au nom de l’interpréteur approprié, et non aussi aux options requises. 127 128 ``` 129 $ awk -f programme.awk 130 ``` 131 132 Il n’y a pas de solution universelle. 133 134 ## Voir aussi 135 136 => https://asteride.xyz/publications/execrom/execrom.tgz Télécharger execrom(8) 137 => https://git.asteride.xyz/execrom/file/LISEZ-MOI.txt.html Dépôt git du programme