source: trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Makefile @ 88

Last change on this file since 88 was 88, checked in by rosiere, 16 years ago

Almost complete design
with Test and test platform

  • Property svn:keywords set to Id
File size: 19.7 KB
RevLine 
[2]1#-------------------------------------------------------------------------------
2# Filename:    Makefile
3# Description: LaTeX compilation flow
4#-------------------------------------------------------------------------------
5
[17]6include ${MORPHEO_TOPLEVEL}/Makefile.tools
[2]7#--------------------------------------------------------------------------------
8# User-defined options :
9#--------------------------------------------------------------------------------
10
[23]11TYPE_DOC                = ("doc" "ppt" "poster")
[2]12
13DEFAULT_LANG            = fr
14FILE_SOURCE_SED         = file_source.sed
15FILE_SOURCE_STY         = file_source.sty
16FILE_SOURCE_TEX         = file_source.tex
17
18#--------------------------------------------------------------------------------
19# Directory
20#--------------------------------------------------------------------------------
[45]21VERSION                 = "1.3" # 2007/07/18
[2]22
23DIR_DOCUMENTATION       = ..
24DIR_INCLUDE             = Include
[51]25DIR_PACKAGE             = Info
[2]26DIR_DOCUMENTS           = Documents
[51]27DIR_LANGUAGE            = Info
[45]28DIR_TYPE                = Info
[2]29DIR_GRAPH               = Graph
30DIR_SCHEMA              = Schema
31DIR_SCHEMA_EPS          = Schema_eps
[42]32DIR_SCHEMA_PNG          = Schema_png
[2]33DIR_TEX                 = Source
34
35#--------------------------------------------------------------------------------
[23]36# Directory
37#--------------------------------------------------------------------------------
[68]38ENV_LATEX               = export TEXINPUTS=$(DIR_INCLUDE):$$TEXINPUTS
[23]39LATEX_WITH_ENV          = $(ENV_LATEX); $(LATEX)
40
[52]41
42
[23]43#--------------------------------------------------------------------------------
[2]44# File
45#--------------------------------------------------------------------------------
46
[51]47ALL_FILES               = $(wildcard $(DIR_TYPE)/*.type)
[2]48
49TEX_FILES               = $(wildcard $(DIR_TEX)/*.tex)
50FILES                   = $(patsubst $(DIR_TEX)/%.tex,%    ,$(TEX_FILES))
51DVI_FILES               = $(patsubst $(DIR_TEX)/%.tex,%.dvi,$(TEX_FILES))
52PS_FILES                = $(patsubst $(DIR_TEX)/%.tex,%.ps ,$(TEX_FILES))
53PDF_FILES               = $(patsubst $(DIR_TEX)/%.tex,%.pdf,$(TEX_FILES))
[44]54PNG_FILES               = $(patsubst $(DIR_GRAPH)/%.p,$(DIR_SCHEMA_PNG)/%.png,$(wildcard $(DIR_GRAPH)/*.p))             \
55                          $(patsubst $(DIR_SCHEMA)/%.fig,$(DIR_SCHEMA_PNG)/%.png,$(wildcard $(DIR_SCHEMA)/*.fig))       \
56                          $(patsubst $(DIR_SCHEMA)/%.eps,$(DIR_SCHEMA_PNG)/%.png,$(wildcard $(DIR_SCHEMA)/*.eps))
[2]57
58#--------------------------------------------------------------------------------
59# The reset of this file shall not be editted
60#--------------------------------------------------------------------------------
61.PHONY                  : all clean view help doc doc_all new delete
[44]62.SECONDARY              : $(DVI_FILES) $(PS_FILES) $(PDF_FILES) $(PNG_FILES) $(DIR_SCHEMA_EPS) $(DIR_SCHEMA_PNG)
63.PRECIOUS               : %.pdf %.ps %.dvi $(DIR_SCHEMA_PNG)/%.png $(DIR_SCHEMA_EPS)/%.eps
[2]64
65all                     : help
66
[45]67doc                     : $(PNG_FILES) $(DIR_TEX)
[48]68                        @\
[2]69                        for file in $(ALL_FILES); do                                                            \
[51]70                                file=`$(BASENAME) $$file .type`;                                                \
71                                type=`$(CAT) $(DIR_TYPE)/$$file.type`;                                          \
[2]72                                                                                                                \
[51]73                                for lang in `$(CAT) $(DIR_LANGUAGE)/$$file.lang`; do                                    \
[2]74                                        if $(TEST) ! -f "$(DIR_TEX)/$$file-$$lang.tex"; then                    \
75                                                $(ECHO) "s/@LANG/$$lang/"                     >  $$$$;          \
76                                                $(ECHO) "s/@FILE/$$file/"                     >> $$$$;          \
[51]77                                                $(ECHO) "s/@DIRPACKAGE/$(DIR_PACKAGE)/"       >> $$$$;          \
[2]78                                                $(ECHO) "s/@DIRDOC/$(DIR_DOCUMENTS)\/$$file/" >> $$$$;          \
79                                                $(ECHO) "s/@DIRSCHEMA/$(DIR_SCHEMA_EPS)/"     >> $$$$;          \
80                                                $(CAT) $(DIR_INCLUDE)/$$type-$(FILE_SOURCE_SED) | $(SED) -f $$$$ > $(DIR_TEX)/$$file-$$lang.tex; \
81                                                $(RM)   $$$$;                                                   \
82                                        fi;                                                                     \
83                                done;                                                                           \
[45]84                        done;                                                                                   \
85                        $(MAKE) doc_all;
[2]86
87doc_all                 : $(PDF_FILES)
88
89#--------------------------------------------------------------------------------
90# Generation of the formatted text:
91# regular flow tex -> dvi -> ps -> pdf.
92#--------------------------------------------------------------------------------
93%.pdf                   : %.ps
[45]94                        @\
[57]95                        $(ECHO) "Génération du fichier $*.pdf";         \
96                        $(PS2PDF) $< $@;                                \
[45]97                        $(CP) $@ $(DIR_DOCUMENTATION);
[2]98
99%.ps                    : %.dvi
[45]100                        @\
[57]101                        $(ECHO) "Génération du fichier $*.ps";          \
[45]102                        $(DVIPS) -o $@ $<;
[2]103
[53]104%.dvi                   : $(DIR_TEX)/%.tex
[45]105                        @\
[57]106                        $(ECHO) "Génération du fichier $*.dvi";         \
107                        $(LATEX_WITH_ENV) $<;                           \
[63]108                        if $(TEST) $$? -eq 0; then                      \
[57]109                                $(LATEX_WITH_ENV) $< > /dev/null;       \
110                                citation=`$(GREP) "citation" $*.aux`;   \
111                                if $(TEST) -n "$$citation" ; then       \
112                                        $(BIBTEX) $* ;                  \
113                                fi;                                     \
114                                $(LATEX_WITH_ENV) $< > /dev/null;       \
115                                $(LATEX_WITH_ENV) $< > /dev/null;       \
116                        fi;
[2]117
[63]118
[2]119#--------------------------------------------------------------------------------
120# New - Delete - Rename
121#--------------------------------------------------------------------------------
122new                     :
123                        @                                                                                       \
124                        $(ECHO) "";                                                                             \
125                        $(ECHO) "Choose a type of a document    : (0 is default)";                              \
126                        CPT=0;                                                                                  \
127                        declare -a type_doc=$(TYPE_DOC);                                                        \
128                        for type in $${type_doc[@]}; do                                                         \
129                                $(ECHO) "$$CPT) $$type";                                                        \
130                                CPT=$$(($$CPT+1));                                                              \
131                        done;                                                                                   \
132                        declare -i NUM_TYPE;                                                                    \
[78]133                        read NUM_TYPE;                                                                          \
[2]134                                                                                                                \
135                        if $(TEST) "$$NUM_TYPE" -ge "$$CPT"; then                                               \
136                                NUM_TYPE=0;                                                                     \
137                        fi;                                                                                     \
138                        declare    TYPE=$${type_doc[$$NUM_TYPE]};                                               \
139                                                                                                                \
140                        declare    FILENAME;                                                                    \
141                        $(ECHO) "";                                                                             \
142                        $(ECHO) "Give the name of the documents :";                                             \
[78]143                        read FILENAME;                                                                          \
[2]144                                                                                                                \
[51]145                        if $(TEST) -z "$$FILENAME" -o -d "$(DIR_TYPE)/$$FILENAME.type";                         \
[2]146                        then                                                                                    \
147                                $(ECHO) "Invalid name : string is empty, or filename is already used";          \
[78]148                                exit;                                                                           \
[2]149                        fi;                                                                                     \
150                                                                                                                \
[51]151                        $(ECHO) "Create file      : $(DIR_LANGUAGE)/$$FILENAME.lang";                           \
[2]152                        $(ECHO) "                   (Default language : $(DEFAULT_LANG))";                      \
[51]153                        $(ECHO) "$(DEFAULT_LANG)" > $(DIR_LANGUAGE)/$$FILENAME.lang;                            \
[2]154                                                                                                                \
[51]155                        $(ECHO) "Create file      : $(DIR_TYPE)/$$FILENAME.type";                               \
156                        $(ECHO) $$TYPE > $(DIR_TYPE)/$$FILENAME.type;                                           \
[2]157                                                                                                                \
158                        $(ECHO) "Create file      : $(DIR_PACKAGE)/$$FILENAME.sty";                             \
159                        $(CP) $(DIR_INCLUDE)/$$TYPE-$(FILE_SOURCE_STY) $(DIR_PACKAGE)/$$FILENAME.sty;           \
160                                                                                                                \
161                        $(ECHO) "Create file      : $(DIR_PACKAGE)/$$FILENAME.tex";                             \
162                        $(CP) $(DIR_INCLUDE)/$$TYPE-$(FILE_SOURCE_TEX) $(DIR_PACKAGE)/$$FILENAME.tex;           \
163                                                                                                                \
164                        $(ECHO) "Create directory : $(DIR_DOCUMENTS)/$$FILENAME";                               \
165                        $(ECHO) "Create directory : $(DIR_DOCUMENTS)/$$FILENAME/common";                        \
166                        $(ECHO) "Create directory : $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG)";               \
167                        $(MKDIR) $(DIR_DOCUMENTS)/$$FILENAME/common;                                            \
168                        $(MKDIR) $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG);                                   \
169                                                                                                                \
170                        $(ECHO) "Create file      : $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG)/root.tex";      \
171                        $(TOUCH) $(DIR_DOCUMENTS)/$$FILENAME/$(DEFAULT_LANG)/root.tex
172
173delete                  :
174                        @                                                                                       \
175                        declare -a FILES;                                                                       \
176                        declare -i CPT;                                                                         \
177                        declare -i NUM_FILE;                                                                    \
178                        declare -i NUM_FILE_CONFIRM;                                                            \
179                                                                                                                \
180                        $(ECHO) "";                                                                             \
181                        $(ECHO) "Choose a document  : (0 by default)";                                          \
182                        $(ECHO) "0) ( none )";                                                                  \
183                                                                                                                \
184                        CPT=1;                                                                                  \
185                        for files in $(ALL_FILES); do                                                           \
[51]186                                files=`$(BASENAME) $$files .type`;                                              \
[2]187                                $(ECHO) "$$CPT) $$files";                                                       \
188                                FILES[$$CPT]=$$files;                                                           \
189                                CPT=$$(($$CPT+1));                                                              \
190                        done;                                                                                   \
[78]191                        read NUM_FILE;                                                                          \
[2]192                                                                                                                \
193                        if $(TEST) "$$NUM_FILE" -ge "$$CPT"; then                                               \
194                                NUM_FILE=0;                                                                     \
195                        fi;                                                                                     \
196                                                                                                                \
197                        $(ECHO) "Please reenter the document id to confirm the delete";                         \
[78]198                        read NUM_FILE_CONFIRM;                                                                  \
[2]199                                                                                                                \
200                        if $(TEST) "$$NUM_FILE" -eq "0" -o "$$NUM_FILE" -ne "$$NUM_FILE_CONFIRM"; then          \
201                                $(ECHO) "Delete cancelled";                                                     \
[68]202                                exit;                                                                           \
[2]203                        fi;                                                                                     \
204                                                                                                                \
205                        declare    FILENAME;                                                                    \
206                        FILENAME=$${FILES[$$NUM_FILE]};                                                         \
207                                                                                                                \
[51]208                        $(ECHO) "Delete file      : $(DIR_TYPE)/$$FILENAME.type";                               \
209                        $(RM) $(DIR_TYPE)/$$FILENAME.type;                                                      \
[2]210                                                                                                                \
[51]211                        $(ECHO) "Delete file      : $(DIR_LANGUAGE)/$$FILENAME.lang";                           \
212                        $(RM) $(DIR_LANGUAGE)/$$FILENAME.lang;                                                  \
[2]213                                                                                                                \
214                        $(ECHO) "Delete file      : $(DIR_PACKAGE)/$$FILENAME.sty";                             \
215                        $(RM) $(DIR_PACKAGE)/$$FILENAME.sty;                                                    \
216                                                                                                                \
217                        $(ECHO) "Delete file      : $(DIR_PACKAGE)/$$FILENAME.tex";                             \
218                        $(RM) $(DIR_PACKAGE)/$$FILENAME.tex;                                                    \
219                                                                                                                \
220                        $(ECHO) "Delete directory : $(DIR_DOCUMENTS)/$$FILENAME";                               \
[88]221                        $(RM) $(DIR_DOCUMENTS)/$$FILENAME;                                                     
[2]222
223rename                  :
224                        @                                                                                       \
225                        declare -a FILES;                                                                       \
226                        declare -i CPT;                                                                         \
227                        declare -i NUM_FILE;                                                                    \
228                                                                                                                \
229                        $(ECHO) "";                                                                             \
230                        $(ECHO) "Choose a document  : (0 by default)";                                          \
231                        $(ECHO) "0) ( none )";                                                                  \
232                                                                                                                \
233                        CPT=1;                                                                                  \
234                        for files in $(ALL_FILES); do                                                           \
[51]235                                files=`$(BASENAME) $$files .type`;                                              \
[2]236                                $(ECHO) "$$CPT) $$files";                                                       \
237                                FILES[$$CPT]=$$files;                                                           \
238                                CPT=$$(($$CPT+1));                                                              \
239                        done;                                                                                   \
[78]240                        read NUM_FILE;                                                                          \
[2]241                                                                                                                \
242                        if $(TEST) "$$NUM_FILE" -ge "$$CPT"; then                                               \
243                                NUM_FILE=0;                                                                     \
244                        fi;                                                                                     \
245                                                                                                                \
246                        if $(TEST) "$$NUM_FILE" -eq "0"; then                                                   \
247                                $(ECHO) "Rename cancelled";                                                     \
[68]248                                exit;                                                                           \
[2]249                        fi;                                                                                     \
250                                                                                                                \
251                        declare    FILENAME_SRC;                                                                \
252                        declare    FILENAME_DEST;                                                               \
253                        FILENAME_SRC=$${FILES[$$NUM_FILE]};                                                     \
254                                                                                                                \
255                        $(ECHO) "Give the new name of the documents :";                                         \
[78]256                        read FILENAME_DEST;                                                                     \
[2]257                                                                                                                \
[51]258                        if $(TEST) -z "$$FILENAME_DEST" -o -d "$(DIR_TYPE)/$$FILENAME_DEST.type";               \
[2]259                        then                                                                                    \
260                                $(ECHO) "Invalid name : string is empty, or filename is already used";          \
[68]261                                exit;                                                                           \
[2]262                        fi;                                                                                     \
263                                                                                                                \
[51]264                        $(ECHO) "Rename file      : $(DIR_LANGUAGE)/$$FILENAME_SRC.lang";                       \
265                        $(MV) $(DIR_LANGUAGE)/$$FILENAME_SRC.lang $(DIR_LANGUAGE)/$$FILENAME_DEST.lang;         \
[2]266                                                                                                                \
[51]267                        $(ECHO) "Rename file      : $(DIR_TYPE)/$$FILENAME_SRC.type";                           \
268                        $(MV) $(DIR_TYPE)/$$FILENAME_SRC.type     $(DIR_TYPE)/$$FILENAME_DEST.type;             \
[2]269                                                                                                                \
270                        $(ECHO) "Rename file      : $(DIR_PACKAGE)/$$FILENAME_SRC.sty";                         \
[51]271                        $(MV) $(DIR_PACKAGE)/$$FILENAME_SRC.sty   $(DIR_PACKAGE)/$$FILENAME_DEST.sty;           \
[2]272                                                                                                                \
[78]273                        $(ECHO) "Rename file      : $(DIR_PACKAGE)/$$FILENAME_SRC.tex";                         \
274                        $(MV) $(DIR_PACKAGE)/$$FILENAME_SRC.tex   $(DIR_PACKAGE)/$$FILENAME_DEST.tex;           \
275                                                                                                                \
[2]276                        $(ECHO) "Rename directory : $(DIR_DOCUMENTS)/$$FILENAME_SRC";                           \
[88]277                        $(MV) $(DIR_DOCUMENTS)/$$FILENAME_SRC     $(DIR_DOCUMENTS)/$$FILENAME_DEST;             
[2]278
[52]279
280
[2]281#--------------------------------------------------------------------------------
282# View
283#--------------------------------------------------------------------------------
284view                    : doc
[84]285                        @\
[2]286                        declare    SELECT_FILE;                                                                 \
287                        declare    SELECT_LANG;                                                                 \
288                        declare    SELECT_FORMAT;                                                               \
289                        declare    SELECT_VIEWER;                                                               \
290                                                                                                                \
291                                                                                                                \
292                        $(ECHO) "";                                                                             \
293                        $(ECHO) "Choose a document  : (0 by default)";                                          \
294                                                                                                                \
295                        declare -i CPT;                                                                         \
296                        declare -i NUM_FILE;                                                                    \
297                        declare -a FILES;                                                                       \
298                                                                                                                \
299                        CPT=0;                                                                                  \
300                        for files in $(ALL_FILES); do                                                           \
[51]301                                files=`$(BASENAME) $$files .type`;                                              \
302                                type=`$(CAT) $(DIR_TYPE)/$$files.type`;                                         \
[2]303                                $(ECHO) "$$CPT) $$type - $$files";                                              \
304                                FILES[$$CPT]=$$files;                                                           \
305                                CPT=$$(($$CPT+1));                                                              \
306                        done;                                                                                   \
[78]307                        read NUM_FILE;                                                                          \
[2]308                                                                                                                \
309                        if $(TEST) "$$NUM_FILE" -ge "$$CPT"; then                                               \
310                                NUM_FILE=0;                                                                     \
311                        fi;                                                                                     \
312                                                                                                                \
313                        SELECT_FILE=$${FILES[$$NUM_FILE]};                                                      \
314                        $(ECHO) "Document selected  : $$SELECT_FILE";                                           \
315                        $(ECHO) "";                                                                             \
316                                                                                                                \
317                                                                                                                \
318                                                                                                                \
319                        $(ECHO) "Choose a language  : (0 by default)";                                          \
320                                                                                                                \
321                        declare -i NUM_LANG;                                                                    \
322                        declare -a LANG;                                                                        \
323                                                                                                                \
324                        CPT=0;                                                                                  \
[51]325                        for lang in `$(CAT) $(DIR_LANGUAGE)/$$SELECT_FILE.lang`; do                             \
[2]326                                $(ECHO) "$$CPT) $$lang";                                                        \
327                                LANG[$$CPT]=$$lang;                                                             \
328                                CPT=$$(($$CPT+1));                                                              \
329                        done;                                                                                   \
[78]330                        read NUM_LANG;                                                                          \
[2]331                                                                                                                \
332                        if $(TEST) "$$NUM_LANG" -ge "$$CPT"; then                                               \
333                                NUM_LANG=0;                                                                     \
334                        fi;                                                                                     \
335                                                                                                                \
336                        SELECT_LANG=$${LANG[$$NUM_LANG]};                                                       \
337                        $(ECHO) "Language selected  : $$SELECT_LANG";                                           \
338                        $(ECHO) "";                                                                             \
339                                                                                                                \
340                                                                                                                \
341                                                                                                                \
342                        $(ECHO) "Choose a format    : (0 by default)";                                          \
343                                                                                                                \
344                        declare -i NUM_FORMAT;                                                                  \
345                        declare -a FORMAT;                                                                      \
346                        declare -a VIEWER;                                                                      \
347                                                                                                                \
[57]348                        FORMAT=("pdf"           "pdf"        "ps"        "dvi");                                \
349                        VIEWER=("$(VIEWPDF_FS)" "$(VIEWPDF)" "$(VIEWPS)" "$(VIEWDVI)");                         \
[2]350                                                                                                                \
351                        CPT=0;                                                                                  \
352                        while [ $$CPT -lt $${#FORMAT[*]} ]; do                                                  \
[17]353                            $(ECHO) "$$CPT) $${FORMAT[$$CPT]} ($${VIEWER[$$CPT]})";                             \
[2]354                            CPT=$$(($$CPT+1));                                                                  \
355                        done;                                                                                   \
[78]356                        read NUM_FORMAT;                                                                        \
[2]357                                                                                                                \
358                        if $(TEST) "$$NUM_FORMAT" -ge "$$CPT"; then                                             \
359                                NUM_FORMAT=0;                                                                   \
360                        fi;                                                                                     \
361                                                                                                                \
362                        SELECT_FORMAT=$${FORMAT[$$NUM_FORMAT]};                                                 \
363                        SELECT_VIEWER=$${VIEWER[$$NUM_FORMAT]};                                                 \
364                        $(ECHO) "Format selected    : $$SELECT_FORMAT";                                         \
365                        $(ECHO) "";                                                                             \
366                                                                                                                \
367                        $$SELECT_VIEWER "$$SELECT_FILE-$$SELECT_LANG.$$SELECT_FORMAT" &                         \
368                                                                                                                \
369                        $(ECHO) "";
370
371#--------------------------------------------------------------------------------
372# The figures directory
373#--------------------------------------------------------------------------------
374$(DIR_SCHEMA_EPS)       :
[45]375                        @\
[57]376                        $(ECHO) "Make directory       : $@";            \
[45]377                        $(MKDIR) $@;
[2]378
[42]379$(DIR_SCHEMA_PNG)       :
[45]380                        @\
[57]381                        $(ECHO) "Make directory       : $@";            \
[45]382                        $(MKDIR) $@;
[3]383
[2]384$(DIR_TEX)              :
[45]385                        @\
[57]386                        $(ECHO) "Make directory       : $@";            \
[45]387                        $(MKDIR) $@;
[2]388
[44]389$(DIR_SCHEMA_PNG)/%.png : $(DIR_SCHEMA_EPS)/%.eps $(DIR_SCHEMA_PNG)
[45]390                        @\
[57]391                        $(ECHO) "Generate   files     : $*.png";        \
[45]392                        $(EPS2PNG) $< $@;
[44]393
[45]394$(DIR_SCHEMA_EPS)/%.eps : $(DIR_SCHEMA)/%.eps $(DIR_SCHEMA_EPS)
395                        @\
[57]396                        $(ECHO) "Generate   files     : $*.eps";        \
[45]397                        $(CP) $(DIR_SCHEMA)/$*.eps $(DIR_SCHEMA_EPS);
[2]398
[45]399$(DIR_SCHEMA_EPS)/%.eps : $(DIR_SCHEMA)/%.fig $(DIR_SCHEMA_EPS)
400                        @\
[57]401                        $(ECHO) "Generate   files     : $*.eps";        \
[45]402                        $(FIG2EPS) $< $@;
[2]403
[45]404$(DIR_SCHEMA_EPS)/%.eps : $(DIR_GRAPH)/%.p    $(DIR_SCHEMA_EPS)
405                        @\
[57]406                        $(ECHO) "Generate   files     : $*.eps";        \
[78]407                        cd $(DIR_GRAPH); $(GNUPLOT) $*.p;
[2]408
409#--------------------------------------------------------------------------------
410# Cleaning
411#--------------------------------------------------------------------------------
412
413clean                   :
[45]414                        @\
415                        $(ECHO) "Delete     temporary files              "$(PWD);                               \
416                        $(RM) $(DIR_SCHEMA_EPS) $(DIR_SCHEMA_PNG)  $(DIR_TEX) $(DIR_PACKAGE)/*.aux;             \
417                        $(RM) $(DVI_FILES) $(PS_FILES) $(PDF_FILES);                                            \
[75]418                        $(RM) a0header.ps;                                                                      \
[45]419                        $(MAKE) clean_rec DIR_CLEAN=;
[2]420
421#Clean recursive
422clean_rec               :
[45]423                        @\
424                        $(ECHO) "Delete     temporary files in directory $(DIR_CLEAN)";                         \
425                        $(RM)   $(DIR_CLEAN)/*~                 \
[17]426                                $(DIR_CLEAN)/*.bak              \
[2]427                                $(DIR_CLEAN)/*.aux              \
428                                $(DIR_CLEAN)/*.bbl              \
429                                $(DIR_CLEAN)/*.blg              \
430                                $(DIR_CLEAN)/*.bmt              \
431                                $(DIR_CLEAN)/*.log              \
432                                $(DIR_CLEAN)/*.mtc*             \
433                                $(DIR_CLEAN)/*.toc              \
434                                $(DIR_CLEAN)/*.idx              \
435                                $(DIR_CLEAN)/*.ilg              \
436                                $(DIR_CLEAN)/*.ind              \
437                                $(DIR_CLEAN)/*.out              \
438                                $(DIR_CLEAN)/*.nav              \
439                                $(DIR_CLEAN)/*.snm              \
[75]440                                $(DIR_CLEAN)/*.maf              \
[45]441                                $(DIR_CLEAN)/missfont.log;      \
442                        for files in `$(LS) $(DIR_CLEAN)`; do                                                   \
[2]443                                if $(TEST) -d $(DIR_CLEAN)/$$files;                                             \
444                                then                                                                            \
445                                        $(MAKE) clean_rec DIR_CLEAN=$(DIR_CLEAN)/$$files;                       \
446                                fi;                                                                             \
447                        done;
448
449clean_all               : clean
[45]450                        @\
451                        $(ECHO) "Delete     temporary files (all)";                                             \
452                        $(RM) $(DIR_DOCUMENTATION)/*.pdf;
[2]453
454#--------------------------------------------------------------------------------
455# Help
456#--------------------------------------------------------------------------------
457
458help                    :
[45]459                        @\
460                        $(ECHO) "Environnement to generate documents and presentations";                        \
461                        $(ECHO) "Version         : $(VERSION)";                                                 \
462                        $(ECHO) "";                                                                             \
463                        $(ECHO) "List of rules   :";                                                            \
464                        $(ECHO) " * all          : Cf rules \"help\"";                                          \
465                        $(ECHO) " * clean        : Erase generate files";                                       \
466                        $(ECHO) " * clean_all    : Erase all generate files";                                   \
467                        $(ECHO) " * delete       : Erase all file and directory of a document";                 \
468                        $(ECHO) " * doc          : Generate all documents";                                     \
469                        $(ECHO) " * help         : Print this message";                                         \
470                        $(ECHO) " * new          : Create all file and directy for a new document";             \
471                        $(ECHO) " * rename       : Rename a document";                                          \
472                        $(ECHO) " * view         : List all document to view";                                  \
473                        $(ECHO) "";                                                                 
Note: See TracBrowser for help on using the repository browser.