Changes between Version 1 and Version 2 of AntResume


Ignore:
Timestamp:
Jun 21, 2006, 11:40:40 AM (18 years ago)
Author:
Le Meur
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • AntResume

    v1 v2  
    11= Ant versus Make =
    22
    3 ---+++(Jean-Noël Albert / Avril 2005 / Groupe de développeurs du LAL)
    4 ---+++présentation
     3=== (Jean-Noël Albert / Avril 2005 / Groupe de développeurs du LAL) ===
     4
     5== présentation ==
    56
    67Make et Ant sont tous deux des systèmes pour la construction d'application.
    78
    89Make :
    9    * est un standard UNIX
    10    * est orienté “tâche à accomplir”
     10 * est un standard UNIX
     11 * est orienté “tâche à accomplir”
    1112tandis que Ant :
    12    * vise la portabilité
    13    * est orienté “enchaînement de taches”
    14    * est extensible
    15    * est écrit en Java et donc très bien adapté aux développements Java
    16 ---+++ Make
    17 _c'est l'histoire d'un make…_
     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…''
    1820
    1921Make est devenu un standard au même titre que UNIX
    20    * 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 ;
    21    * plus une variante GNU : GNU Make ou GMake
    22       * la plus riche en extensions ;
    23       * la plus utilisée par les développeurs ;
    24       * adoptée par Linux.
    25 ---+++ L'approche Make
    26 ---++++ Principe : on décrit le but à atteindre, et non pas la façon d'y parvenir.
    27 Exemple : pour construire le programme _hello_ à partir du source _hello.c_, il suffit de lancer la commande :
    28 
    29 % *make hello*
    30 
    31 
    32 Make 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.
     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.
    3336
    3437Résultat :
    35 <verbatim>
     38
     39{{{
    3640cc     hello.c   -o hello
    37 </verbatim>
     41}}}
    3842Et le programme hello est construit. Ca marcherait aussi avec un fichier source en Fortran, en C++ etc.
    3943
    4044Si on relance la même commande :
    4145
    42 % *make hello*
    43 <verbatim>
     46% '''make hello'''
     47{{{
    4448make: `hello' is up to date.
    45 </verbatim>
    46 
    47 Il n'y a rien à faire, puisque l'application hello vient d'être compilée et que la source _hello.c_ n'a pas changé.
     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é.
    4852Si on modifie le fichier source :
    4953
    50 % *touch hello.c*
    51 
    52 % *make hello*
    53 
    54 <verbatim>
     54% '''touch hello.c'''
     55
     56% '''make hello'''
     57
     58{{{
    5559cc     hello.c   -o hello
    56 </verbatim>
     60}}}
    5761
    5862Make détecte que le fichier source est plus récent que l'application compilée et la reconstruit.
    … …  
    6266Si 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.
    6367
    64 ---+++ Makefile
    65 Pour 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).
     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).
    6670
    6771Le fichier de description contient une liste de “buts à atteindre” (appelés le plus souvent “cible”) et les moyens d'y parvenir.
    … …  
    6973Lorsqu'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.
    7074Exemple d'un fichier Makefile simple :
    71 <verbatim>
     75{{{
    7276hello : hello.c
    7377
    … …  
    7579clean :
    7680   rm hello hello.o *~
    77 </verbatim>
     81}}}
    7882
    7983Pour construire l'application :
    8084
    81 % *make*
    82 <verbatim>
     85% '''make'''
     86{{{
    8387cc    -c -o hello.o hello.c
    8488cc   hello.o   -o hello
    85 </verbatim>
     89}}}
    8690
    8791Make exécute le premier objectif du fichier (hello).
    … …  
    9094
    9195Exemple très simplifié :
    92 <verbatim>
     96{{{
    9397hello : hello.o
    9498
    9599hello.o : hello.c
    96 </verbatim>
     100}}}
    97101
    98102Un but peut ne correspondre à aucun fichier, comme "clean" dans l'exemple précédent. Dans ce cas, il sera toujours accompli.
    … …  
    100104Exemple : suppression des fichiers compilés :
    101105
    102 % *make clean*
    103 <verbatim>
     106% '''make clean'''
     107{{{
    104108rm hello hello.o *~
    105 </verbatim>
    106 ---+++ Principaux inconvénients
    107    * 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.
    108    * 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.
    109    * 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, …
    110       * portage difficile - principales difficultés : les options de CC ;
    111       * GMake introduit des blocs if … else … pour tenir compte des plates-formes
    112          * ne simplifie pas la compréhension des fichiers Makefile ;
    113          * nécessite d'installer GMake (on peut aller le chercher sur le site GNU).
    114    * Portage difficile vers Windows (80-90 % des postes de travail)
    115       * principale difficulté : les noms de fichiers Windows sont incompatibles avec les noms de fichiers UNIX ;
    116 Exemple :
    117          * UNIX : /usr/bin/cc
    118          * Windows : C:\Windows\system32\cc.exe
    119       * une possibilité : *Cygwin* (portage des commandes UNIX sous Windows) - représente les fichiers Windows avec la syntaxe UNIX - utilise GMake
    120          * Exemple : /c/Windows/system32/cc.exe   (le ".exe" est alors optionnel)
    121          * problème : les applications natives de Windows (comme par exemple Java) ne reconnaissent pas les noms UNIX.
    122 ---+++ Ant
     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
    123130La construction de l'application se fait en indiquant une succession d'opérations à réaliser.
    124131
    125 Ant utilise un fichier *build.xml*.
     132Ant utilise un fichier '''build.xml'''.
    126133
    127134Une tâche peut dépendre d'une ou de plusieurs autres tâches.
    … …  
    131138
    132139Ant assure qu'une tache ne sera accomplie qu'une seule fois dans le processus de construction :
    133    * ceci évite des situations de bouclage apparaissant avec Make lorsqu'une cible intermédiaire est en prémisse de plusieurs autres cibles
    134       * cas typiques : génération de fichiers à partir de sources qui ne sont pas des fichiers (base de données, …)
     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, …)
    135142
    136143Plutô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 :
    137    * compiler les fichiers sources
    138    * construire une librairie
    139    * construire la documentation
    140    * créer des répertoires
    141    * supprimer des fichiers de travail
    142    *    …
     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
    143151Ant 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.
    144 ---+++ Java, Make & Ant
     152
     153== Java, Make & Ant ==
     154
    145155Les 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.
    146156
    … …  
    152162
    153163Ant permet de résoudre la plupart de ces difficultés en trois taches :
    154 <verbatim>
     164{{{
    155165<javac srcdir="sources/" destdir="classes/" />
    156166<jar destfile="lib/hello.jar" basedir="classes/" />
    157167<javadoc packagenames="demo" sourcepath="sources/" destdir="docs/" />
    158 </verbatim>
     168}}}
    159169
    160170L'exemple complet :
    161 <verbatim>
     171{{{
    162172<?xml version="1.0"?>
    163173<project name="Hello" default="build" basedir=".">
    … …  
    186196
    187197</project>
    188 </verbatim>
     198}}}
    189199
    190200
    191201La construction de l'application :
    192202
    193 % *ant*
    194 <verbatim>
     203% '''ant'''
     204{{{
    195205Buildfile: build.xml
    196206
    … …  
    201211BUILD SUCCESSFUL
    202212Total time: 3 seconds
    203 </verbatim>
     213}}}
    204214
    205215L'élimination des fichiers intermédiaires (par exemple, après l'installation du projet)
    206216
    207 % ant *clean*
    208 <verbatim>
     217% ant '''clean'''
     218{{{
    209219Buildfile: build.xml
    210220
    … …  
    214224BUILD SUCCESSFUL
    215225Total time: 1 second
    216 </verbatim>
    217 
    218 ---+++ Portabilité
     226}}}
     227
     228== Portabilité ==
    219229Ant est écrit en Java, donc portable.
    220230
    221231Exemple : exécution du même script Ant sous Windows/XP et Cygwin :
    222232
    223 $ *ant doc*
    224 <verbatim>
     233$ '''ant doc'''
     234{{{
    225235Buildfile: build.xml
    226236
    … …  
    240250BUILD SUCCESSFUL
    241251Total time: 9 seconds
    242 </verbatim>
     252}}}
    243253
    244254