ABSTRACT: einfuehrung in "make". 

AUDIENCE: junior admin
SYSTEM:   any unix
SECTION:  basic unix commands
AUTHOR:   mond <fs@mond.at>
COPYRIGHT: GNU Free Documentation Licence http://www.gnu.org/licenses/fdl.txt

  wer schon mal selbst programme von source weg installiert hat kennt den
  "make" befehl schon. heute wollen wir lernen wir wir einfache makefiles
  selber erzeugen.

  wozu make? die befehle zum uebersetzen eines programmes koennten wir doch
  ebensogut in ein kleines shellscript schreiben dass wir anstarten wenn wir
  das programm compilieren wollen. der nachteil: bei grossen projekten
  wuerden wir dann immer alles uebersetzten auch wenn sich nur irgendwo eine
  zeile geaendert haben und man nur ein einziges file neu compilieren
  muesste. "make" ist dazu da genau dieses problem zu loesen. man kann make
  aber nicht nur zum aufruf eines compiliers verwenden sondern jeglichen
  befehl der outputfiles in abhaengigkeit von input files erzeugt und der
  aufgerufen soll wenn eines der input files sich geaendert hat. z.b:

  ein latex text besteht aus haupt.tex und inkludiert teil1.tex und
  teil2.tex wenn sich eines der beiden geaendert hat soll ein neues .dvi
  file erzeugt werden.

haupt.dvi: haupt.tex teil1.tex teil2.tex
	latex haupt.tex

  ^__ hier KEINE spaces sondern einen tabulator. 

  WICHTIG: die befehlszeile muss IMMER mit einem tabulator beginnen.

  obiges schreiben wir in ein file namens "Makefile". (man beachte das
  grosse M)
 
  obiges besagt dass das "target" haupt.dvi abhaengig ist von 3 .tex files
  darunter stehen ein oder mehrere befehle die mit einem TABULATOR
  eingerueckt sind die zum erzeugen dieses targets aufgerufen werden
  muessen.


  wenn wir nun

make

  aufrufen so wird latex haupt.tex augerufen um das haupt.dvi file zu
  erzeugen falls es nicht schon existiert und aelter ist als die 3 .tex
  files von denen es abhaengt.

  zum testen ob der latex befehl wirklich aufegrufen wird wenn sich eines
  der files aendert koennen wir es editiren oder wir aktualsieren die zeit des
  files mit einem "touch"

touch teil2.tex

  wir koennen nun auch z.b. den befehl zum erzeugen eines .ps files
  dazugeben:


ausgabe.ps: haupt.dvi
        dvips -ta4 haupt.dvi -oausgabe.ps

   wenn wir nun:

make ausgabe.ps

   aufrufen so ruft uns das Makefile den dvips befehl nur dann auf falls
   "haupt.dvi" neuer is als "ausgabe.ps"

   ein make ohne parameter versucht nur das erste target zu erzeugen. wir
   koennen daher z.b. eine zeile angeben:

all: ausgabe.ps

   unser Makefile sieht dann so aus:


----schnippp-----------------
all: ausgabe.ps

haupt.dvi: haupt.tex teil1.tex teil2.tex
        latex haupt.tex


ausgabe.ps: haupt.dvi
        dvips -ta4 haupt.dvi -oausgabe.ps
----schnappp-----------------


  rufen wir unser make jetzt mit:

make all

  oder ohne parameter auf so will make das ausgabe.ps erzeugen. existiert
  das dafuer notwendige haupt.dvi noch nicht oder ist nicht up-to-date so
  wird auch der latex befehl aufgerufen.

  manchmal will man alle files die aus anderen erzeugt werden koennen wieder
  loeschen. wir machen uns dazu ein target namens "clean":

clean:
        rm haupt.dvi ausgabe.ps

  wenn wir jezt

make clean

  aufrufen. wird der rm befehl ausgefuehrt. 

  GNU make kennt auch einige implizite targets. d.h. wenn ein file namens
  blabla.o irgendwo in der abhaengigkeitsliste auftaucht aber keine regel
  existiert wie ein blabla.o file erzeut werden soll, jedoch ein blabla.c
  file existiert so ruft make automatisch einen C compiler auf um aus dem
  blabla.c ein blabla.o file zu machen. welcher C compiler und mit welchen
  optionen er aufgerufen wird, das kann mit variablen gesteuert werden. wir
  schreiben z.b ins Makefile:

CC=gcc
CFLAGS="-Wall"

  obiges besagt dass der implizit aufgerufene compiler gcc sein soll und mit
  den flags "-Wall" augerufen werden soll.

  implizite rules die alle files mit bestimmten endungen betreffen kann man
  auch selbst erstellen. mehr dazu in der info page zu make.

  gibt es probleme beim compilieren von software die man irgendwo
  downgeloaded hat hilft es meist das Makefile etwas zu editieren und die
  richtigen compiler flags und include-pfade dort einzustellen.
  

EXERCISES:

  * schreibe und teste ein Makefile das ein file blibla.txt mit dem cat
    befehl aus bla.txt und bli.txt zusammenfuegt.
    cat bla.txt bli.txt > blibla.txt

    das cat soll bei einem "make" immer dann ausgefuehrt werden wenn eines
    der beiden files neuer ist als das blibla.txt

  * ergaenze das Makefile um ein target "all" und "clean" und um ein
    "install". das "install" soll das blibla.txt in ein andres verzeichniss
    kopieren.

  * schau dir Makefiles von echten programmen an. 


REFERENCES:

info make 

http://www.cs.bris.ac.uk/Teaching/Resources/General/make_intro.html

http://linux.oreillynet.com/lpt/a/linux/2002/01/31/make_intro.html