\documentclass[hyperref={bookmarks=true}]{beamer}

\usepackage{beamerthemesplit}
\usepackage{ngerman}
\usepackage[latin1]{inputenc}
\usepackage{eurosym}
\usepackage{graphicx}
\useoutertheme{jhd}
\usecolortheme{jhd}

\title{Programme bauen mit MAKE}
\author{Jan Hendrik Dithmar}
\date{10.11.2005}

\begin{document}

\newcommand{\bild}[2]{
	\begin{figure}[htpb]
		\centering
			\includegraphics[width=#1cm]{#2}
	\end{figure}
	}

\newcommand{\Link}[2]{
	\textcolor{blue}{\href{#1}{#2}}
}

\frame{\titlepage}

\section{Einführung}
\frame
{
	\frametitle{Einführung}
	Ziel des automatischen Programmbauens ist es, aus einer Menge von Quellkomponenten alle abgeleiteten Komponenten zu erzeugen, die Bestandteil des fertigen Softwareprodukts sind. \\[0.5cm]
	
	Bisherige Arbeitsweise: Arbeiten mit einem Shell-Skript \\[0.5cm]
	
	Nachteil: es wird bei jedem Start des Skriptes alles neu gebaut!
}

\section{Das Softwarewerkzeug MAKE}
\frame
{
	\frametitle{Das Softwarewerkzeug MAKE}
	
	Vorteile und Arbeitsweise:
	\begin{itemize}
		\item hat sich eine Komponente geändert, müssen alle von ihr abgeleiteten Komponenten neu gebaut werden
		\item es werden existierende abgeleitete Dateien so weit wie möglich weiterverwendet
		\item es wird das Änderungsdatum von Komponenten verwendet, um Änderungen zu erkennen
		\item Grundlage von MAKE ist ein Makefile
		\item Makefile: eine Systembeschreibung, die die Komponenten des Systems sowie deren Abhängigkeiten und Konstruktionsschritte aufzählt
	\end{itemize}
}

\section{Aufbau einer Makefile}
\frame
{
	\frametitle{Aufbau einer Makefile}
	
	Ein Makefile ist wie folgt aufgebaut: \\[0.5cm]
	
	$ziel_1 \; ziel_2 \; \ldots \; ziel_n: \; quelle_1 \; quelle_2 \; \ldots \; quelle_m$ \\
	$\quad \quad \quad \quad kommando_1$ \\
	$\quad \quad \quad \quad kommando_2$ \\
	$\quad \quad \quad \quad \ldots$
}

\section{Beispiel 1: einfache Makefile}
\begin{frame}[fragile]
	\frametitle{Beispiel 1: einfache Makefile}
	
	\begin{verbatim}
	rechner: add.o sub.o
	    cc -o rechner add.o sub.o
		
	add.o: add.cpp
	    cc -c -o add.o add.cpp
		
	sub.o: sub.cpp
	    cc -c -o sub.o sub.cpp
	\end{verbatim}
	
	\textbf{Achtung:} Kommandos müssen mit Tabulatorzeichen eingerückt sein!
\end{frame}

\section{Variablen in MAKE}
\begin{frame}[fragile]
	\frametitle{Variablen in MAKE}

	MAKE unterstützt Variablen: \\
	\begin{center}
		\textit{variable = wert} \\
	\end{center}
	
	Jedes Aufrufen von \verb!$(variable)! oder \verb!${variable}! wird dann automatisch durch den jeweiligen \textit{wert} ersetzt.
\end{frame}

\section{Beispiel 2: Variablen in Makefiles}
\begin{frame}[fragile]
	\frametitle{Beispiel 2: Variablen in Makefiles}
	
	\begin{verbatim}
	CC = cc
	OBJECTS = add.o sub.o
	
	rechner: $(OBJECTS)
	    $(CC) -o rechner $(OBJECTS)
		
	add.o: add.cpp
	    $(CC) -c -o add.o add.cpp
		
	sub.o: sub.cpp
	    $(CC) -c -o sub.o sub.cpp
	\end{verbatim}
	Mit dem Aufruf \\
	\texttt{\$} \textbf{make CC=gcc rechner} \\
	wird anstelle von \texttt{cc} der Compiler \texttt{gcc} verwendet.
\end{frame}

\section{Implizite Regeln in MAKE}
\begin{frame}[fragile]
	\frametitle{Implizite Regeln in MAKE}
	
	Eine implizite Regel erfordert implizie Variablen:
	\begin{itemize}
		\item \verb!$@! repräsentiert das aktuelle Ziel
		\item \verb!$<! repräsentiert die erste Quelle
	\end{itemize}
	Beispiel: \\
	\begin{verbatim}
	.cpp.o:
	    $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<
	\end{verbatim}
	Die Variablen \texttt{CFLAGS} und \texttt{CPPFLAGS} werden zusätzlich zur Steuerung des C-Compilers und C-Präprozessors eingesetzt. \\
	Die obige Regel ist in MAKE bereits mit geeigneten Werten für die benutzen Variablen vordefiniert.
\end{frame}

\section{Beispiel 3: Implizite Regeln in Makefiles}
\begin{frame}[fragile]
	\frametitle{Beispiel 3: Implizite Regeln in Makefiles}
	
	Um das Projekt \texttt{rechner} zu bauen reicht daher folgende Makefile völlig aus:
	\begin{verbatim}
	CC = cc
	OBJECTS = add.o sub.o
	
	rechner: $(OBJECTS)
	    $(CC) -o rechner $(OBJECTS)
	\end{verbatim}
	Die Regel für \texttt{add} und \texttt{sub} braucht man auf Grund der \texttt{.cpp.o}-Regel nicht mehr explizit anzugeben.
\end{frame}

\section{Andere Anwendungsgebiete von MAKE}
\frame
{
	\frametitle{Andere Anwendungsgebiete von MAKE}
	
	\begin{itemize}
		\item MAKE kann auch mit Hilfe der Definition des Pseudoziels \texttt{install} zum Installieren von Software benutzt werden
		\item MAKE kann über einen rekursiven Aufruf nicht nur zum Bauen eines Systems, sondern auch zum Bauen eines Subsystems verwendet werden
	\end{itemize}
}

\section{Automatische Bestimmung von Abhängigkeiten}
\begin{frame}[fragile]
	\frametitle{Automatische Bestimmung von Abhängigkeiten}
	
	Der UNIX C-Compiler stellt ein automatisches Verfahren zur Bestimmung von Abhängigkeiten zur Verfügung: \\
	\texttt{\$} \textbf{cc -M add.cpp} \\
	\texttt{add.o: add.cpp} \\
	\texttt{add.o: ./calc.h} \\
	\texttt{\$ \_} \\
	Diese Eigenschaft kann in einem Makefile genutzt werden:
	\begin{verbatim}
	depend::
	    (for file in $(SOURCES); do \
	        $(CC) -M $$file; \
	    done) > Makedeps
	include Makedeps
	\end{verbatim}
	\texttt{include Makedeps} wird beim Einlesen des Makefiles durch den Inhalt von \texttt{Makedeps} ersetzt, womit die bestimmten Abhängigkeiten Bestandteil des Makefiles werden.
\end{frame}

\section{MAKE im Internet}
\frame
{
	\frametitle{MAKE im Internet}
	
	\begin{itemize}
		\item \Link{http://www.gnu.org/software/make/make.html}{http://www.gnu.org/software/make/make.html}
		\item \Link{http://www.gnu.org/software/make/manual/make.html}{http://www.gnu.org/software/make/manual/make.html}
		\item \Link{http://de.wikipedia.org/wiki/Make}{http://de.wikipedia.org/wiki/Make}
		\item \Link{http://en.wikipedia.org/wiki/Make}{http://en.wikipedia.org/wiki/Make}
	\end{itemize}
}

\end{document}