Un ordinateur n'est somme toute qu'une machine sans intelligence qui obéit aux instructions qu'on lui donne. Ces instructions sont codées dans un langage propre au microprocesseur (et donc différent selon les microprocesseurs), appelé langage machine. Le langage machine est donc une suite d'instructions, directement compréhensibles par le microprocesseur mais pas par nous autres humains, c'est pourquoi il en existe une représentation textuelle équivalente, l'assembleur. Chaque ligne d'assembleur est traduisible en exactement une instruction en langage machine. Voici un exemple d'instructions en assembleur (pour le microprocesseur Motorola 68020) :
movw #0x2700,sr lea 0x70000,a7 movl #0,a0 movc a0,vbr
L'assembleur peut être directement traduit en langage machine au moyen d'un programme appelé assembleur. Il faut donc faire attention à ne pas confondre l'assembleur (le langage textuel équivalent au langage machine) et l'assembleur (le programme de traduction de l'assembleur en langage machine). Le contexte aide généralement à faire la distinction.
Tous les programmes exécutés par un ordinateur sont en langage machine, puisqu'il s'agit du seul langage compréhensible par le microprocesseur. Cela ne signifie pourtant pas qu'ils ont été écrits en assembleur puis traduits en langage machine. En effet, l'assembleur (et le langage machine, puisque ces deux langages sont équivalents) ne contient que très peu d'instructions et chacune de ces instructions est très simple (déplacement de zones mémoire, opération arithmétique, comparaison, branchement à une instruction particulière du programme...). Cette simplicité est un avantage pour le microprocesseur, puisqu'il n'a pas besoin de savoir faire grand chose, mais un inconvénient pour le programmeur, puisqu'il doit décomposer tout ce qu'il veut faire pour aboutir à une suite d'instructions simples directement codables en assembleur.
C'est pourquoi on a conçu des langages de programmation de plus haut niveau, plus proches des concepts manipulés par les programmeurs. Pratiquement, tout le monde utilise ces langages de programmation et on n'utilise plus l'assembleur que dans les cas où il est absolument indispensable (principalement pour l'accès direct au microprocesseur).
Parmi les langages de programmation de haut niveau (qu'on appellera simplement par la suite « langages de programmation »), on peut distinguer deux grandes familles :
Un programme écrit dans un langage compilé est composé à la base d'un fichier texte, qu'on appelle le fichier source. Selon leur taille, il peut être pratique de séparer le source en plusieurs fichiers mais ce n'est en rien une obligation.
Le fichier source n'est, bien entendu, pas exécutable par l'ordinateur. C'est pourquoi il faut le transformer en langage machine au moyen d'un certain nombre d'étapes.
L'ensemble de ces quatre phases est appelé (à tort) compilation et est effectué par un programme, appelé (également à tort) compilateur, qui déclenche tour à tour ces quatre phases, chacune effectuée par un programme spécialisé.
Les plus connus des langages compilés sont : C, C++, Cobol, Fortran et Pascal. C et C++ sont des langages très utilisés. UNIX est lui-même entièrement écrit en C (à l'exception de quelques petites parties, qui manipulent directement les données du microprocesseur et qui ont donc besoin d'être écrites directement en assembleur).
Un fichier source écrit dans un langage interprété est destiné à être lu par un programme spécial appelé interpréteur, qui exécutera pas à pas chaque instruction qu'il contient. Contrairement à un programme compilé, un programme interprété n'est donc pas transformé en langage machine et, en conséquence, il a toujours besoin de l'interpréteur pour fonctionner.
Les plus connus des langages interprétés sont : Basic, Java, Perl et Tcl.
On peut distinguer deux catégories d'interpréteurs :
Les systèmes UNIX sont généralement fournis avec tous les outils
permettant de programmer en C, puisque le C est le langage
maternel d'UNIX. En particulier, beaucoup de systèmes fournissent
un compilateur C ainsi qu'un utilitaire particulièrement pratique
appelé make. L'éditeur de texte Emacs, s'il n'est
pas standard comme vi, est pourtant très répandu.
Plus qu'un éditeur de texte, il s'agit en fait d'un environnement
de programmation complet.
make
Généralement, pour des raisons pratiques, un programme compilé
est composé de plusieurs fichiers sources. La compilation d'un
tel ensemble de fichiers nécessite l'enchaînement de plusieurs
programmes dans un ordre bien précis. Lors de l'écriture puis de
la mise au point du programme, il va donc falloir répéter
l'exécution de ces programmes pour chaque compilation, ce qui
peut se révéler particulièrement pénible. Le but de
make est d'automatiser l'enchaînement de ces
programmes au moyen d'indications contenues dans un fichier
Makefile.
Sans trop rentrer dans le détail, regardons un exemple très
simple de fichier Makefile :
programme : programme.c
gcc -o programme programme.c
La première ligne de ce fichier indique que la cible
appelée programme (c'est le nom de l'exécutable en
langage machine que nous voulons obtenir) dépend du fichier
programme.c. Il peut, bien entendu, y avoir
plusieurs dépendances. Dans ce cas, il suffit
simplement d'indiquer la liste des fichiers dont la cible dépend,
chaque nom de fichier étant séparé du suivant par une espace.
La deuxième ligne (qui doit obligatoirement commencer par une
tabulation) indique la commande à exécuter pour obtenir la cible
(ici, programme) à partir des dépendances (ici, le
seul fichier programme.c), il s'agit en fait de la
commande de compilation.
L'aspect pratique de make vient du fait qu'il
s'appuie sur les dates de dernière modification des différents
fichiers pour savoir si une nouvelle compilation est nécessaire.
Ainsi, lorsqu'on tape
make
make va aller lire le fichier Makefile
pour savoir ce qu'il a à faire. Puis, pour la première cible
rencontrée, il va vérifier sa date de dernière modification ainsi
que celles de ses dépendances. Si l'une quelconque des
dépendances est plus récente que la cible, ce qui indique qu'elle
a été modifiée depuis la dernière compilation, make
va exécuter la commande de la deuxième ligne pour lancer la
compilation.
Le principe de fonctionnement de make, s'appuyant
sur les dates de dernière modification de la cible par rapport à
ses dépendances, permet de l'utiliser dans de nombreuses
situations, qui n'ont pas nécessairement à voir avec la
programmation, où un fichier est obtenu à partir de plusieurs
autres.
Il peut être souhaitable d'installer un logiciel sur une machine, que ce soit pour bénéficier d'un nouveau logiciel ou d'une version plus récente d'un logiciel dont on dispose déjà.
Pour cela, deux solutions existent :
Mais, quel que soit votre choix, il faut tout d'abord vous procurer le logiciel.
Il existe principalement deux façons de se procurer un logiciel :
Divers CD-ROM Linux sont disponibles dans le commerce, correspondant à une distribution particulière (Red Hat, S.u.S.E.) ou à un ensemble de distributions et de ressources (InfoMagic).
Télécharger un logiciel sur l'Internet nécessite de savoir à quel endroit on peut le trouver, ce qui peut s'avérer problématique. Fort heureusement, il existe des sites miroirs, qui regroupent un grand nombre de logiciels. Ces logiciels sont recopiés à partir de leurs sites de distribution officiels respectifs et sont généralement mis à jour très rapidement lors de la sortie de nouvelles versions. Ces sites miroirs sont comme une caverne d'Ali Baba où l'on peut trouver quasiment tout ce que l'on souhaite. Parmi les plus connus, on peut citer :
Les deux distributions Linux les plus répandues, Red Hat et Debian, disposent chacune d'un format permettant d'installer facilement un logiciel déjà compilé et prêt à l'emploi. Il s'agit du format RPM pour la distribution Red Hat et du format DEB pour la distribution Debian. Ces deux formats sont malheureusement incompatibles et, lors de l'installation d'un logiciel, il convient d'utiliser le format correspondant à la distribution qu'on possède.
Dans la plupart des cas, un logiciel sous forme source se
présente comme un fichier dont l'extension est
.tar.gz, par exemple
logiciel-1.0.tar.gz. Cela signifie que
l'arborescence des fichiers sources a tout d'abord été archivée
en un seul fichier (extension .tar) grâce à l'outil
standard tar (tape archiver) et que ce
fichier a été comprimé (extension .gz) grâce à
l'outil GNU gzip.
Pour retrouver l'arborescence source originelle afin de la
compiler, il suffit d'effectuer l'opération inverse, qui se fait
aisément grâce à la commande tar :
tar xvfz logiciel-1.0.tar.gz
La signification des quatre options de tar est la
suivante :
x (extract)
tar que l'on
souhaite extraire l'archive, c'est-à-dire retrouver
l'arborescence originelle à partir du fichier
.tar. Pour information, l'option inverse,
permettant de créer une archive, est c.
v (verbose)
tar qu'il doit
afficher les noms des fichiers qu'il extrait au fur et
à mesure. Cela permet de suivre la progression de
l'extraction.
f (file)
tar qu'il doit
rechercher l'archive dans le fichier dont le nom suit
les options et non pas sur le lecteur de bandes
magnétiques par défaut.
z (gzip)
tar qu'avant
d'extraire l'archive, il doit décomprimer le fichier au
moyen de la commande gzip.
On dispose alors d'un répertoire logiciel-1.0 qui
contient la distribution source du logiciel. Pour continuer, il
faut se placer dans ce répertoire :
cd logiciel-1.0
La façon de compiler le logiciel est généralement expliquée dans
un fichier nommé INSTALL, situé à la racine de
l'arborescence source. En cas d'absence de ce fichier, les
instructions risquent d'être dans le fichier README.
Ceci dit, la façon de compiler les logiciels tend à s'harmoniser
et une méthode domine. Elle utilise un shell script appelé
configure, qui va déterminer le système
d'exploitation sur lequel il est exécuté, l'environnement de
compilation, détecter la présence ou l'absence de certaines
bibliothèques, de certaines fonctions, etc. En effet, les
systèmes UNIX sont somme toute très ressemblants du point de vue
de la compatibilité des sources si bien qu'un logiciel conçu pour
un UNIX particulier peut généralement être porté sans grand
effort sur un autre UNIX. Cependant, certains aspects mineurs
diffèrent d'un UNIX à un autre et configure permet
au logiciel de pouvoir s'adapter à la version d'UNIX sur lequel
il est compilé, pour peu que son concepteur l'ait prévu.
Le lancement de configure s'effectue grâce à la
commande :
./configure
Au fur et à mesure de son exécution, configure
affiche ce qu'il teste et les résultats qu'il obtient. Ses
recherches peuvent durer de quelques secondes à plusieurs minutes
selon le nombre et la complexité de ses tests. Au bout du compte,
configure va générer un certain nombre de fichiers,
dont un Makefile qui servira à compiler le logiciel
au moyen de make :
make
La compilation d'un logiciel utilisant configure
s'effectue donc grâce aux commandes :
./configure make
Une autre façon de compiler un logiciel utilise la commande
xmkmf. Les seuls logiciels à utiliser cette méthode
sont les logiciels sous X. À partir d'un fichier
Imakefile et de la connaissance qu'il a du système,
xmkmf va créer un fichier Makefile qui
servira à compiler le logiciel.
La compilation d'un logiciel utilisant xmkmf
s'effectue donc grâce aux commandes :
xmkmf make
Enfin, certains logiciels sont uniquement fournis avec un fichier
Makefile correspondant aus systèmes sur lesquel ils
ont été portés. Du fait de sa notoriété, Linux en fait partie
dans la plupart des cas mais il n'est pas impossible que le
Makefile, voire que certains sources C, aient à être
modifiés manuellement.
Compiler un logiciel n'exige aucun privilège particulier et peut donc se faire sous l'identité d'un utilisateur normal. Mais l'installation nécessite de créer des fichiers dans des répertoires système et doit donc se faire sous l'identité du super-utilisateur :
su
Une fois le logiciel compilé, l'installation s'effectue quasiment toujours grâce à la commande :
make install
Pour installer les pages de manuel des logiciels compilés avec
xmkmf, il faut également appeler :
make install.man
WWWOFFLE - Sat, 12 May 2001 13:22:24 CEST (depuis 53 minutes) - [Effacer|Actualiser:Options|Suivi|Index] - WWWOFFLE