Changes between Initial Version and Version 1 of CompteRendu/cr2005/cr19_04/AntResume


Ignore:
Timestamp:
Jun 21, 2006, 6:09:36 PM (18 years ago)
Author:
Le Meur
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • CompteRendu/cr2005/cr19_04/AntResume

    v1 v1  
     1= Ant versus Make =
     2
     3=== (Jean-Noël Albert / Avril 2005 / Groupe de développeurs du LAL) ===
     4
     5== présentation ==
     6
     7Make et Ant sont tous deux des systèmes pour la construction d'application.
     8
     9Make :
     10 * est un standard UNIX
     11 * est orienté “tâche à accomplir”
     12tandis que Ant :
     13 * vise la portabilité
     14 * est orienté “enchaînement de taches”
     15 * est extensible
     16 * est écrit en Java et donc très bien adapté aux développements Java
     17
     18== Make ==
     19''c'est l'histoire d'un make…''
     20
     21Make est devenu un standard au même titre que UNIX
     22 * il existe une implémentation de Make par variante de UNIX, globalement similaires, mais assez différentes dans les détails pour rendre difficile les portages ;
     23 * plus une variante GNU : GNU Make ou GMake
     24   * la plus riche en extensions ;
     25   * la plus utilisée par les développeurs ;
     26   * adoptée par Linux.
     27
     28== L'approche Make ==
     29=== Principe : on décrit le but à atteindre, et non pas la façon d'y parvenir. ===
     30Exemple : pour construire le programme ''hello'' à partir du source ''hello.c'', il suffit de lancer la commande :
     31
     32% '''make hello'''
     33
     34
     35Make procède automatiquement à la recherche des fichiers qui lui permettent d'atteindre le but demandé (la construction de ''hello''). Il trouve un fichier ''hello.c''. Il dispose d'une règle interne lui permettant de passer d'un fichier C à une application. Il lance la compilation et l'édition de liens C.
     36
     37Résultat :
     38
     39{{{
     40cc     hello.c   -o hello
     41}}}
     42Et le programme hello est construit. Ca marcherait aussi avec un fichier source en Fortran, en C++ etc.
     43
     44Si on relance la même commande :
     45
     46% '''make hello'''
     47{{{
     48make: `hello' is up to date.
     49}}}
     50
     51Il n'y a rien à faire, puisque l'application hello vient d'être compilée et que la source 'hello.c'' n'a pas changé.
     52Si on modifie le fichier source :
     53
     54% '''touch hello.c'''
     55
     56% '''make hello'''
     57
     58{{{
     59cc     hello.c   -o hello
     60}}}
     61
     62Make détecte que le fichier source est plus récent que l'application compilée et la reconstruit.
     63
     64Make se base sur la date des fichiers pour savoir quels fichiers reconstruire.
     65
     66Si l'application dépend de plusieurs sources, Make ne reconstruit que ce qui a changé. Il s'ensuit un _gain de temps_ (surtout avec C++ qui est long à compiler) ; et l'application est toujours en phase avec les développements.
     67
     68== Makefile ==
     69Pour des applications plus compliquées, on utilise un fichier de description nommé '''Makefile''' (''makefile'' est également accepté – et selon la mouture de Make, d'autres fichiers sont reconnus et traités ; par exemple GMake utilise de préférence le fichier GNUmakefile, si celui-ci existe dans le répertoire).
     70
     71Le fichier de description contient une liste de “buts à atteindre” (appelés le plus souvent “cible”) et les moyens d'y parvenir.
     72
     73Lorsqu'un fichier Makefile existe dans le répertoire, Make le lit et exécute le premier “objectif”. Pour exécuter un autre objectif, on l'indique sur la ligne de commandes de Make.
     74Exemple d'un fichier Makefile simple :
     75{{{
     76hello : hello.c
     77
     78# Supprime les fichiers compilés et les sauvegardes XEmacs
     79clean :
     80   rm hello hello.o *~
     81}}}
     82
     83Pour construire l'application :
     84
     85% '''make'''
     86{{{
     87cc    -c -o hello.o hello.c
     88cc   hello.o   -o hello
     89}}}
     90
     91Make exécute le premier objectif du fichier (hello).
     92
     93Un but peut dépendre d'étapes intermédiaires (par exemple pour la construction de librairies).
     94
     95Exemple très simplifié :
     96{{{
     97hello : hello.o
     98
     99hello.o : hello.c
     100}}}
     101
     102Un but peut ne correspondre à aucun fichier, comme "clean" dans l'exemple précédent. Dans ce cas, il sera toujours accompli.
     103
     104Exemple : suppression des fichiers compilés :
     105
     106% '''make clean'''
     107{{{
     108rm hello hello.o *~
     109}}}
     110
     111== Principaux inconvénients ==
     112
     113 * Lorsque les Makefiles deviennent compliqués, on ne sait pas toujours très bien quel va être le cheminement de Make, ni s'il va exécuter les étapes prévues, et dans quel ordre.
     114 * Pas très bien adapté à des projets comportant plusieurs répertoires – il faut souvent un fichier Makefile par répertoire, plus un fichier Makefile général pour reconstruire l'application pour chacun des répertoires.
     115 * Il faut souvent imposer à Make les opérations à réaliser, en fonction des saveurs de UNIX : options de compilations différentes d'une variante à l'autre, commandes différentes d'une plate-forme à l'autre, …
     116   * portage difficile - principales difficultés : les options de CC ;
     117   * GMake introduit des blocs if … else … pour tenir compte des plates-formes
     118     * ne simplifie pas la compréhension des fichiers Makefile ;
     119     * nécessite d'installer GMake (on peut aller le chercher sur le site GNU).
     120 * Portage difficile vers Windows (80-90 % des postes de travail)
     121   * principale difficulté : les noms de fichiers Windows sont incompatibles avec les noms de fichiers UNIX Exemple :
     122     * UNIX : /usr/bin/cc
     123     * Windows : C:\Windows\system32\cc.exe
     124   * une possibilité : '''Cygwin''' (portage des commandes UNIX sous Windows) - représente les fichiers Windows avec la syntaxe UNIX - utilise GMake
     125     * Exemple : /c/Windows/system32/cc.exe   (le ".exe" est alors optionnel)
     126     * problème : les applications natives de Windows (comme par exemple Java) ne reconnaissent pas les noms UNIX.
     127
     128== Ant ==
     129
     130La construction de l'application se fait en indiquant une succession d'opérations à réaliser.
     131
     132Ant utilise un fichier '''build.xml'''.
     133
     134Une tâche peut dépendre d'une ou de plusieurs autres tâches.
     135L'exécution d'une tâche peut dépendre de conditions, par exemple pour ne pas construire une partie du code qui dépend d'une librairie qui n'est pas installée (exemple : un interface d'accès au HPSS du CC IN2P3).
     136
     137Tout comme Make, Ant ne traite que les fichiers plus récents que les résultats à obtenir.
     138
     139Ant assure qu'une tache ne sera accomplie qu'une seule fois dans le processus de construction :
     140 * ceci évite des situations de bouclage apparaissant avec Make lorsqu'une cible intermédiaire est en prémisse de plusieurs autres cibles
     141   * cas typiques : génération de fichiers à partir de sources qui ne sont pas des fichiers (base de données, …)
     142
     143Plutôt que de laisser l'utilisateur indiquer les commandes à exécuter (rm, cc, …), Ant fournit un ensemble de taches permettant de réaliser les opérations escomptées :
     144 * compiler les fichiers sources
     145 * construire une librairie
     146 * construire la documentation
     147 * créer des répertoires
     148 * supprimer des fichiers de travail
     149 *    …
     150
     151Ant intègre la notion d'opérations récursives sur un ensemble de fichiers et de répertoires. Il vise la portabilité et tente de masquer les opérations sur les fichiers. Il est bien adapté à Java.
     152
     153== Java, Make & Ant ==
     154
     155Les projets Java sont naturellement organisés en packages, et les fichiers sources doivent être placés dans une hiérarchie de répertoires reproduisant la hiérarchie des packages.
     156
     157Le processus de compilation doit donc parcourir tous les répertoires - l'ordre n'est pas très important grâce au mécanisme de compilation incrémental de Java.
     158
     159Make ne pas très bien adapté à cette situation; il y aurait deux possibilités : tout recompiler à chaque fois (lourd) ou lancer Make sur chacun des répertoires (peu pratique).
     160
     161Mêmes difficultés pour construire la documentation (JavaDoc) : il faut passer en revue tous les répertoires.
     162
     163Ant permet de résoudre la plupart de ces difficultés en trois taches :
     164{{{
     165<javac srcdir="sources/" destdir="classes/" />
     166<jar destfile="lib/hello.jar" basedir="classes/" />
     167<javadoc packagenames="demo" sourcepath="sources/" destdir="docs/" />
     168}}}
     169
     170L'exemple complet :
     171{{{
     172<?xml version="1.0"?>
     173<project name="Hello" default="build" basedir=".">
     174
     175  <target name="build">
     176    <javac srcdir="sources/" destdir="classes/" />
     177    <jar destfile="lib/hello.jar" basedir="classes/" />
     178  </target>
     179
     180  <target name="doc" depends="build">
     181    <javadoc packagenames="demo"
     182             sourcepath="sources/"
     183             destdir="docs/" />
     184  </target>
     185
     186  <target name="clean">
     187    <delete>
     188      <fileset dir="." defaultexcludes="no">
     189        <include name="**/*~"/>   <!-- XEmacs -->
     190        <include name="**/*.class"/>   <!-- Classes Java -->
     191        <include name="lib/*.jar"/>   <!-- Library Java -->
     192        <include name="docs/**/*" />   <!-- Javadoc -->
     193      </fileset>
     194    </delete>
     195   </target>
     196
     197</project>
     198}}}
     199
     200
     201La construction de l'application :
     202
     203% '''ant'''
     204{{{
     205Buildfile: build.xml
     206
     207build:
     208    [javac] Compiling 1 source file to /albert/Test/classes
     209      [jar] Building jar: /albert/Test/lib/hello.jar
     210
     211BUILD SUCCESSFUL
     212Total time: 3 seconds
     213}}}
     214
     215L'élimination des fichiers intermédiaires (par exemple, après l'installation du projet)
     216
     217% ant '''clean'''
     218{{{
     219Buildfile: build.xml
     220
     221clean:
     222   [delete] Deleting 2 files from /albert/Test
     223
     224BUILD SUCCESSFUL
     225Total time: 1 second
     226}}}
     227
     228== Portabilité ==
     229Ant est écrit en Java, donc portable.
     230
     231Exemple : exécution du même script Ant sous Windows/XP et Cygwin :
     232
     233$ '''ant doc'''
     234{{{
     235Buildfile: build.xml
     236
     237build:
     238    [javac] Compiling 1 source file to D:\Projets\test\classes
     239      [jar] Building jar: D:\Projets\test\lib\hello.jar
     240doc:
     241  [javadoc] Generating Javadoc
     242  [javadoc] Javadoc execution
     243  [javadoc] Loading source files for package demo...
     244  [javadoc] Constructing Javadoc information...
     245  [javadoc] Standard Doclet version 1.5.0_01
     246  [javadoc] Building tree for all the packages and classes...
     247  [javadoc] Building index for all the packages and classes...
     248  [javadoc] Building index for all classes...
     249
     250BUILD SUCCESSFUL
     251Total time: 9 seconds
     252}}}
     253
     254
     255Bien qu'on soit dans une émulation de l'environnement UNIX, les fichiers sont indiqués à Java en utilisant la notation native (le Java de Windows ne reconnaît pas la notation UNIX des fichiers…).
     256
     257Autre exemple sous le shell Windows natif :
     258
     259D:\Projets\test> '''PATH D:\externals\Ant\apache-ant-1.6.2\bin;%PATH%'''
     260
     261D:\Projets\test> '''ant doc'''
     262{{{
     263Buildfile: build.xml
     264
     265build:
     266    [javac] Compiling 1 source file to D:\Projets\test\classes
     267      [jar] Building jar: D:\Projets\test\lib\hello.jar
     268  [javadoc] Generating Javadoc
     269  [javadoc] Javadoc execution
     270  [javadoc] Loading source files for package demo...
     271  [javadoc] Constructing Javadoc information...
     272  [javadoc] Standard Doclet version 1.5.0_01
     273  [javadoc] Building tree for all the packages and classes...
     274  [javadoc] Building index for all the packages and classes...
     275  [javadoc] Building index for all classes...
     276
     277BUILD SUCCESSFUL
     278Total time: 4 seconds
     279}}}
     280
     281== Extension ==
     282On peut ajouter des tâches en fournissant une archive Jar contenant les classes exécutant les nouvelles opérations et en définissant cette librairie dans le fichier '''build.xml'''.
     283
     284Il n'y a pas de reconstruction de Ant : le chargement des librairies Java est dynamique (-> à l'exécution).
     285
     286Cet aspect est utilisé par exemple pour le support de C++ et de Doxygen.
     287
     288Un exemple de fichier build.xml utilisant l'extension C++ :
     289{{{
     290<?xml version="1.0"?>
     291<project name="Ant++" default="build" basedir=".">
     292
     293<taskdef resource="net/sf/antcontrib/antcontrib.properties"/>
     294<taskdef resource="cpptasks.tasks"/>
     295<typedef resource="cpptasks.types"/>
     296
     297<target name="build">
     298    <cc link="executable" outfile="demo.exe">
     299   <fileset dir=".">
     300     <include name="*.cc"/>
     301   </fileset>
     302   <syslibset libs="c,stdc++"/>
     303    </cc>
     304</target>
     305
     306</project>
     307}}}
     308
     309Exemple Linux :
     310
     311% '''ant'''
     312{{{
     313Buildfile: build.xml
     314
     315build:
     316       [cc] 1 total files to be compiled.
     317       [cc] Starting link
     318
     319BUILD SUCCESSFUL
     320Total time: 2 seconds
     321}}}
     322
     323% '''./demo.exe'''
     324
     325{{{
     326Hello, world !
     327}}}
     328Sous Windows, on peut utiliser Cygwin pour avoir un compilateur C++.
     329
     330Le mécanisme pour écrire des tâches Ant est détaillé dans _Writing Your Own Task_.
     331
     332== Intégration ==
     333Ant est accepté par de nombreux IDE (''Integrated Development Environment'') : Eclipse, JBuilder, !VisualAge for Java, !WebSphere Studio.
     334
     335==  Liens ==
     336 * Ant :         http://ant.apache.org/
     337 * Documentation Ant : http://ant.apache.org/manual/index.html
     338 * C++ / Ant :      http://sourceforge.net/projects/ant-contrib/
     339         Note :  il faut prendre aussi la distribution cpptasks
     340 * Doxygen / Ant :   http://www.sourceforge.net/projects/ant-doxygen
     341 * Cygwin :      http://cygwin.com/
     342 * GNU :         http://www.gnu.org/