ар пьвз жч р ×

 FREIBURG
ALBERT-LUDWIGS-UNIVERSITAT

INSTITUT FUR INFORMATIK
Lehrstuhl fur Mustererkennung und Bildverarbeitung
Prof. Dr.-Ing. Hans Burkhardt
Georges-Kohler-Allee
Geb.052, Zi 01-029
D-79110 Freiburg
Tel. 0761 - 203 - 8260
Kurzdokumentationen der Tools zum Softwarepraktikum SS 2001
30. April 2001
Inhaltsverzeihnis
1 Einleitung
3
2
3
g++
- GNU C++ Compiler
2.1 Kurzbeshreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.2 Wihtigste Anwendungsvarianten . . . . . . . . . . . . . . . . . . . . . . .
4
2.2.1 Programme, die nur die Standard-Bibliothek verwenden . . . . . . .
4
2.2.2 Einbinden von zusatzlihen Bibliotheken . . . . . . . . . . . . . . .
4
2.2.3 Erzeugen von eigenen Bibliotheken . . . . . . . . . . . . . . . . . .
5
2.2.4 Weitere Optionen fur den g++ . . . . . . . . . . . . . . . . . . . . .
6
2.2.5 Sonstige Utilities . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.3 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
3 GNU make
7
3.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
3.2 Ein einfahes Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8
3.3 Makefiles fur Fortgeshrittene . . . . . . . . . . . . . . . . . . . . . . . .
9
3.4 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1
4 Emas
11
4.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.2 Erste Shritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.3 Dokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.4 Konguration von Emas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
4.5 Nutzlihes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5 GDB
13
5.1 Kurzbeshreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.2 Wihtigste Anwendungsvarianten . . . . . . . . . . . . . . . . . . . . . . . 13
5.2.1 Starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.2.2 Kontrolle des Programmablaufs . . . . . . . . . . . . . . . . . . . . 14
5.2.3 Speiherkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2.4 Untersuhung von Programmabsturzen . . . . . . . . . . . . . . . . 15
5.3 GDB unter Emas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.4 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6 CVS
16
6.1 Was ist CVS? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
6.2 Arbeiten mit CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2.1 Vorbereitungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2.2 Arbeiten mit einem CVS-Repository . . . . . . . . . . . . . . . . . 18
6.2.3 CVS und Emas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.2.4 CVS Home . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.3 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7 Doxygen
25
7.1 Kurzbeshreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2 Wihtigste Anwendungsvarianten . . . . . . . . . . . . . . . . . . . . . . . 25
7.2.1 Setup und einfaher Aufruf . . . . . . . . . . . . . . . . . . . . . . . 25
7.2.2 Kommentieren der Souren . . . . . . . . . . . . . . . . . . . . . . . 26
7.2.3 Weitere Funktionalitat . . . . . . . . . . . . . . . . . . . . . . . . . 28
7.3 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2
1 Einleitung
Wihtiges Lernziel des Softwarepraktikums ist Vertrautheit mit einigen Arten von Tools,
die bei der Softwareentwiklung zum Einsatz kommen. In dieser Sammlung sollen einige
Vertreter der wihtigsten dieser Werkzeuge kurz vorgestellt und die wesentlihen Anwendungsmoglihkeiten dargestellt werden. Referenzen auf ausfuhrlihere Anleitungen sind
am Shlu der jeweiligen Abshnitte angegeben.
2
g++
- GNU C++ Compiler
2.1 Kurzbeshreibung
Der g++ wird benotigt, um aus den C++ Quelldateien ausfuhrbare Programme zu erzeugen, oder um eigene Bibliotheken zu erstellen. Intern lauft die Compilierung eines
Programms in vier Shritten ab, wovon man als Benutzer aber ubliherweise maximal
zwei zu Gesiht bekommt. Diese Shritte sind:
1. "preproessing\ Im ersten Shritt werden die Praprozessor-Befehle1 interpretiert.
Auerdem entfernt der Praprozessor Kommentare aus dem Soureode. Das Ergebnis ist ein vorverarbeiteter C++-Soure-Code.

2. "ompilation\ Die eigentlihe Ubersetzung
des vorverarbeiteten C++-Soure-Codes
in Assembler. Das Ergebnis ein Assembler-Soure-File, in dem die AssemblerBefehle im Klartext notiert sind.

3. "assembly\ Ubersetzung
des Assembler-Soure-Files in Mashinen-Code. Das Ergebnis ist ein Objet-File, in dem sowohl der Mashinenode, als auh ein SymbolTable, also eine Tabelle, die im wesentlihen die Namen der enthaltenen Funktionen
und ihrer Startadressen im Mashinenode enthalt. 2
4. "linking\ Zusammenhangen von mehreren Objet-Files, Anhangen eines Run"
time\-Kopfes und der Standard-Bibliotheken, so da ein ausfuhrbares Programm
entsteht.
1 Die
bekanntesten Praprozessor-Befehle sind #inlude (um andere Dateien, ubliherweise HeaderDateien, an dieser Stelle einzufugen), #define (zum Denieren von Makros), sowie #if, #ifdef, #ifndef,
#else und #endif (f
ur die bedingte Compilierung, z.B. Debugging-Code ein und auszushalten, oder um
den Soure-Code auf mehreren Arhitekturen ompilierbar zu mahen.)
2 Wihtig: Da bei C++ (im Gegensatz zu reinem C) mehrere Funktionen mit dem gleihen Namen,
aber vershiedenen Parametern erlaubt sind, untershieden sih diese Symbol-Namen, je nahdem, ob das
Programm mit einem C oder C++ Compiler ubersetzt wurde. Um eine mit einem reinen C-Compiler
ubersetzte Funktion (z.B. aus einer C-Bibliothek) von C++ aus aufzurufen, ist es daher notig, den Funktionsprototyp innerhalb eines extern "C" f ... g Blok zu denieren. Bei den Standard-Bibliotheken
ist dieser Blok immer shon im Header-File vorhanden.
3
2.2 Wihtigste Anwendungsvarianten
2.2.1 Programme, die nur die Standard-Bibliothek verwenden

Zum Ubersetzen
eines C++ Programms, da nur aus einem Soure-File besteht und das
nur die Standard-Bibliotheken benutzt, reiht ein einfahes
g++ example. -o example
Dabei werden alle vier oben beshriebenen Shritte ausgefuhrt und es ensteht das ausfuhrbare
Programm example\. Ist der Soureode uber mehrere Files verteilt (was auh shon bei
"
kleineren Projekten unbedingt anzuraten ist) kann man diese mit
g++ example. lasses1. lasses2. -o example

ubersetzen. Das wird ziemlih shnell sehr zeitaufwendig, da bei jeder kleinen Anderung

alle drei Soure-Codes neu ubersetzt werden mussen. Es ist besser, das Ubersetzen und
das Zusammenlinken zwei Shritten auszufuhren. Um den g++ anzuweisen, nur die ersten
drei Shritte der Compilierung auszufuhren, mu man die Option -\ ubergeben:
"
g++
g++
g++
g++
- example. -o example.o
- lasses1. -o lasses1.o
- lasses2. -o lasses2.o
example.o lasses1.o lasses2.o -o example

Wenn nun z.B. eine Anderung
in lasses1. vorgenommen wurde, so brauht nur der 2.
und der 4. Befehl wiederholt zu werden. Die Entsheidung, welhe Teile neukompiliert
werden mussen, kann einfah anhand des jeweiligen Dateidatums gefallt werden. Ein
Programm, das einem diese Arbeit abnimmt gibt es naturlih auh (siehe make\ in
"
Kapitel 3). Wihtig: Ein Soure-Code mu naturlih auh dann neu kompiliert werden,
wenn sih ein Header-File, da mit #inlude eingefugt wird, andert.
2.2.2 Einbinden von zusatzlihen Bibliotheken
Bei fast allen Programmen wird man auf weitere Bibliotheken (auer den StandardBibliotheken) zugreifen wollen. Dafur mu sowohl dem Praprozessor gesagt werden wo er
die Header-Files dazu ndet (wenn diese niht an der Unix-Standard-Position /usr/inlude
zu nden sind) und dem Linker mu man die Namen der Bibliotheken ubergeben und evtl.
auh das Verzeihnis, wenn diese Bibliothek niht in /lib oder /usr/lib liegt. Beispiel
1: Nutzung der ti-Bibliothek, die an der Standard-Position installiert ist:
g++
g++
g++
g++
- example. -o example.o
- lasses1. -o lasses1.o
- lasses2. -o lasses2.o
example.o lasses1.o lasses2.o -o example -ltiff
4
Beispiel 2: Nutzung der FFTW-Bibliothek3 , die man im eigenen Home-Verzeihnis installiert hat (in /home/ronneber/inlude/tw.h und /home/ronneber/lib/libtw.a):
g++
g++
g++
g++
- -I/home/ronneber/inlude/ example. -o example.o
- -I/home/ronneber/inlude/ lasses1. -o lasses1.o
- -I/home/ronneber/inlude/ lasses2. -o lasses2.o
-L/home/ronneber/lib example.o lasses1.o lasses2.o -o example -lfftw
Wenn man mehrere Bibliotheken einbindet, mu man unbedingt auf die rihtige Reihenfolge ahten. Jede Bibliothek kann nur die Funktionen der weiter hinten denierten
nutzen. Beispiel: Die tw threads\ - Bibliothek benotigt Funktionen aus der pthread\
"
"
Bibliothek. Dann mu man beim Linken
-lfftw_threads -lpthreads
angeben. Niht andersherum, dann ndet der Linker die Funktionen niht. Das dem so
ist, ist ubrigens Absiht. Andernfalls ware es niht moglih nur einige Funktionen aus
einer Bibliothek mit einer eigenen Bibliothek zu ubershreiben.
2.2.3 Erzeugen von eigenen Bibliotheken
Spatestens im Rahmen des Softwarepraktikums wird man mehrere Programme entwikeln,
die alle auf dieselben Funktionen zugreifen. Diese sollte man rehtzeitig in eigene Biblio
theken legen, sonst konnen auh kleinste Anderungen
shnell zur Tortur werden. Zum
Erstellen einer Bibliothek benotigt man zusatzlih das Programm ar\ (arhive) und auf
"
manhen Arhitekturen ranlib\. Beispiel: Erstellen der Bibliothek hurz\ mit allen
"
"
Funktionen aus lasses1. und lasses2.:
g++ - lasses1. -o lasses1.o
g++ - lasses2. -o lasses2.o
ar -rv libhurz.a lasses1.o lasses2.o
ranlib libhurz.a
Das Programm ar\ hangt einfah die angegebenen Objet-Files zusammen und erstellt
"
einen Index, mit dem die Original-Files wieder hergestellt werden konnten. ranlib\
"
extrahiert die Symbol-Tables der einzelnen Objet-Files und fat sie in einem groen
Symbol-Table zusammen. Dies beshleunigt nahher das Linken, ist aber niht unbedingt
notwendig. Zum Einbinden dieser eigenen Bibliothek gilt dasselbe wie im vorigen Kapitel,
um also unser example-Programm nun zu erstellen, shreiben wir nur noh
g++ -I/home/ronneber/hurz/inlude - example. -o example.o
g++ -L/home/ronneber/hurz/lib example.o -o example -lhurz
3 Sie
enthalt die Fastest Fourier Transform in the West\ (http://www.fftw.org)
"
5
2.2.4 Weitere Optionen fur den g++
Weitere nutzlihe Kommandozeilen-Optionen fur den g++ sind
-Wall zeigt alle Warnungen an. Diese Compiler Warnungen deuten auf moglihe
-O2 optimiert das erzeugte Programm auf Geshwindigkeit. Dadurh wird es ubliherweise
-g shreibt die Informationen, die der Debugger benotigt in die Objet-Files. Das
-v (verbose) shreibt wahrend des Compilierens alle Zwishenshritte und die Ver-
Programmierfehler hin, die aber niht einen Abbruh der Compilierung erzwingen.
Pradikat: sehr sinnvoll!
etwas groer und das Compilieren dauert langer, aber gerade bei einfahen Shleifen
(wie sie ja in der Bildverarbeitung dauernd vorkommen) bringt diese Optimierung
einen enormen Geshwindigkeitsgewinn. Auerdem kann der Compiler beim Optimieren noh weitere Fehler nden, die dann als Warnungen ausgegeben werden,
wie z.B. variable xy might be used uninitialized\. Allerdings mu man sih beim
"

Debuggen von optimierten Programmen auf einige Uberrashungen
gefat mahen,
da der g auh z.B. die Reihenfolge der Befehle umtaushen kann.
sind vor allem eine Tabelle, die fur jede Soureode-Zeile die Speiherposition des
erzeugten Mashinen-Codes enthalt, aber auh die Speiherposition und Namen von
Variablen, et.
zeihnisse, in denen gesuht wird, heraus. Sehr sinnvoll, wenn man wissen will,
woher die Bibliotheken nun eigentlih kamen...
2.2.5 Sonstige Utilities
Im Zusammenhang mit dem g++ sollte auh noh kurz das Programm strip\ erwahnt
"
werden. Beispiel: mit
strip example
konnen nahtraglih alle uberussigen Symbol-Tables und Debugging-Informationen von
einem Programm entfernt werden, wodurh es ubliherweise wesentlih kleiner wird. Man
mu also niht neu kompilieren, nur um ein Programm ohne Debugging-Informationen zu
haben.
2.3 Referenzen
http://gnu.g.org (Homepage des g)
man g (Manual-Seite, gute tabellarishe Auistung der Optionen)
info g (info-Seite, f
ur die, die es ganz genau wissen wollen)
6
3 GNU make
Um den Quellode eines Programms in einen ausfuhrbaren Zustand | ausfuhrbare Binardatei
| zu uberfuhren sind vershiedenste Shritte notwendig. Zunahst einmal mussen alle
Quelldateien des Programms vom Compiler in einen Objektode uberfuhrt werden. Einige
Objektdateien werden vielleiht zu Bibliotheken zusammengefuhrt. Shluendlih mussen
alle Objektdateien und Bibliotheken zu einer Binardatei zusammengebunden (gelinkt)
werden.
Diese Arbeitsshritte sind je nah Umfang des Softwarepaketes reht komplex und zeitaufwendig. Siherlih lieen sih die Befehle statish in ein Skript odieren. Doh wurde
der Zeitaufwand immer noh immens sein, wenn immer alle Quelldateien neu ubersetzt
werden muten. Auh, wenn sih nur eine Quelldatei geandert hat. Sinnvoller und auh
Ressouren sparender ware ein Werkzeug, das erkennt, welhe Quelldateien neu ompiliert, oder welhe Bibliotheken neu gebildet werden mussen.
Genau dafur wurde das Werkzeug make4 entwikelt. Mit dem Programm make ist es
moglih, Abhangigkeiten zwishen beliebigen Dateien (z.B. Quelldateien und Objektdateien) zu denieren und Abbildungsvorshriften anzugeben, die einen Dateityp in einen
anderen uberfuhren (z.B. *. in *.o).
In diesem Kapitel wird eine kurze Einfuhrung zu make gegeben. Es ist nur eine kurze
Einfuhrung, da das make-Werkzeug von so groer Komplexitat ist, da eine ausfuhrlihe
Beshreibung den Rahmen dieser Anleitung sprengen wurde.
3.1 Grundlagen
Im allgemeinen erwartet make eine Datei mit dem Namen Makefile, die im aktuellen
Arbeitsverzeihnis steht. In der Datei Makefile ist deniert, was make mahen soll.
Beim Aufruf vom make liest das Programm das Makefile ein und interpretiert es. Soll
make eine Datei mit einem anderen Name als Makefile nehmen, so lat sih make mit
dem Parameter -f NameOfMakefile aufrufen.
Damit make wei, was es mahen soll, sind in der Makefile-Datei Regeln deniert. Alle
Regeln in einem Makefile mussen folgender Syntax genugen:
Ziel ... : Abh
angigkeiten ...
<TAB>Befehl
<TAB>...
Demnah ist ein Ziel abhangig von seinen Abhangigkeiten. Wie das Ziel gebildet wird,
steht in den Befehlszeilen darunter. Eine Regel kann auh nur aus Ziel und Abhangigkeiten
bestehen. Ferner kann ein Ziel auh ohne Abhangigkeiten deniert sein, das nur Befehlszeilen beinhaltet.
4 Diese
Beshreibung von make basiert auf GNU make und lehnt sih an die Dokumentation von GNU
make an. Ahtung: Jedes Betriebssystem (z.B. Solaris, Irix, AIX) hat sein eigenes make, was selten

vollkommen kompatibel zu GNU make ist. Um Arger
bei Portierungen von Software aus dem Weg zu
gehen, sollte GNU make verwendet werden, da GNU make fur alle gangigen Plattformen verfugbar ist.
7
Das Tabulatorzeihen zu Beginn jeder Befehlszeile ist obligatorish. Fehlt das Zeihen,
wird sih make bitterlih beshweren und die Ausfuhrung des Makefiles abbrehen. Das
Kommentarzeihen fur ein Makefile ist das #-Zeihen.
Soll make nur ein Ziel erzeugen, mu make das Ziel in der Kommandozeile als Parameter
mitgegeben werden. Ansonsten wird make versuhen, alle Regel zu befolgen.
make untersheidet zwishen impliziten und expliziten Regeln. Implizite Regel sind Regeln, die make shon kennt und niht deniert werden mussen. Zum Beispiel kann make
eine C-Quelldatei *. in eine Objektdatei *.o durh Compilation uberfuhren. Explizite
Regeln sind in dem Makefile deniert.
3.2 Ein einfahes Makefile
Fur mehr Klarheit soll das folgende Beispiel sorgen. Ein Programm myprg soll aus drei
Quelldateien first., seond. und myprg. gebildet werden. Das dazugehorige
Makefile sieht wie folgt aus:
myprg : myprg.o first.o seond.o
g++ myprg.o first.o seond.o -o myprg
myprg.o : myprg. first.hh seond.hh basis.hh
g++ - myprg.
first.o : first. first.hh
g++ - first.
seond.o : seond. seond.hh
g++ - seond.
lean :
rm -f myprg myprg.o first.o seond.o
rebuild : lean myprg
Nun soll make das Programm myprg erzeugen. Dafur wird make ohne Parameter aufgerufen. Das make-Programm liest das Makefile ein und interpretiert es. In Abhangigkeit
existierender Dateien fuhrt es die Regeln aus.
Zu Beginn gehen wir von der Existenz aller Quelldateien (*. und *.hh) aus. Die Objektdateien (*.o) und die Programmdatei myprg sollen noh niht erzeugt worden sein.
In der ersten Regel des Makefiles ist deniert, wovon die Binardatei myprg abhangt
und wie das Programm gebildet wird. Demnah mussen fur das Linken des Programms
zunahst alle Objektdateien myprg.o, seond.o und first.o generiert werden. Um das
zu erfullen suht make jetzt nah Regeln fur die Erzeugung der Objektdateien.
In der zweiten bis vierten Regel ist deniert, wie make die Objektdateien, die fur das Ziel
myprg notwendig sind, erzeugen kann. Zum Beispiel ist die Objektdatei myprg.o auf die
8
Quelldatei myprg. und den Headern first.hh, seond.hh und basis.hh angewiesen.
An dieser Stelle kann make die erste Regel erfullen, da die Abhangigkeiten als Dateien
existieren, und niht erst gebildet werden mussen. D.h. make fuhrt den Befehl g -
myprg. -o myprg.o aus und erzeugt so die Objektdatei myprg.o. Sukzessive werden so
alle Objektdateien naheinander | in der Reihenfolge wie es in der ersten Regel deniert
ist | erzeugt.
make wird nun die Befehlszeile der ersten Regel ausf
uhren, da die Abhangigkeiten erfullt
wurden. Mit der Befehlszeile werden alle Objektdateien zum Hauptprogramm myprg.o
gelinkt und das ausfuhrbare Programm myprg ist erzeugt.
Die vorletzte Regeln mit dem Ziel lean dient dem Aufraumen. Mohte man das Programm von Grund auf neu generieren, sorgt die Regel lean fur das Loshen aller Objektdateien und der Programmdatei. Der Aufruf der Regel erfolgt mit make lean.
Um das Neuerzeugen noh weiter zu vereinfahen gibt es noh die Regel mit dem Ziel
rebuild. Wird make mit dem Ziel rebuild aufgerufen, wird zunahst lean und dann
myprg ausgefuhrt.
Wir nun zum Beispiel die Quelldatei seond. geandert und anshlieend der makeBefehl aufgerufen, so passiert folgendes: make liest wiederum das Makefile ein und
shaut, ob alle Ziele erfullt wurden. Bei der Regel mit dem Ziel seond.o bemerkt das
make-Programm, da die Quelldatei seond. ein aktuelleres Datum als die Objektdatei
seond.o hat. Ergo kann die Objektdatei niht von der aktuellen Version der Quelldatei
stammen. Somit fuhrt make die zugehorige Befehlszeile aus und ompiliert seond.
neu. Bis auf die erste Regel sind nun alle anderen Regeln erfullt. Am Shlu bindet make
alle Objektdateien zu einer neuen Version von myprg zusammen und terminiert. Es wurde
nur die Arbeit vollzogen, die notwendig war.
3.3 Makefiles fur Fortgeshrittene
Das zuvor diskutierte Beispiel fur ein Makefile ist naturlih noh etwas unbeholfen.
Und zwar deshalb, weil die Regeln fur das Erzeugen der Objektdateien explizit fur alle
Dateien hingeshrieben wurde. Ferner wurden keinerlei Variablen verwendet. Soll z.B.
der Compiler g ersetzt werden, oder ein zusatzliher Parameter zum Aufruf zugefugt
werden, mussen alle betreenden Zeilen editiert werden.
Generell lassen sih Variablen in einem Makefile mit
VAR = WERT
denieren. Verwendet werden Variablen in einem Makefile mit
$(VAR).
Im folgenden Beispiel werden Compiler (CXX), Compilerparameter (CXXFLAGS), Linker
(CC) und Objektdateien (OBJS) in Variablen deniert und verwendet. Ferner werden die
impliziten Regeln von make fur C++ Quellen (*.o:*.) verwendet:
9
OBJS = myprg.o first.o seond.o
CXX = g++
CC = $(CXX)
CXXFLAGS = -Wall
all : myprg
myprg : $(OBJS)
myprg.o first.o : first.hh
myprg.o seond.o : seond.hh
myprg.o : basis.hh
lean :
rm -f myprg $(OBJS)
rebuild : lean myprg

Die Variablen CXX, CC und CXXFLAGS werden von den impliziten Regeln fur C++ Ubersetzung
und Bindung verwendet. So teilt CXXFLAGS mit dem Flag -Wall dem Compiler mit, da
wirklih alle Warnungen ausgegeben werden sollen. Beim Aufruf von make wird, wie shon
zuvor erklart, versuht alle Regeln zu erfullen. Wie make eine Objektdatei generiert ist
in der impliziten Regel fur *.o:*. erklart. Um eine Quelldatei in eine Objektdatei
abzubilden fuhrt make den Befehl:
$(CXX) - $(CPPFLAGS) $(CXXFLAGS)
aus. Die Abhangigkeiten der Objektdateien von den Headern steht nah wie vor in dem
Makefile. Allerdings sind die Abhangigkeiten diesmal zusammengefat. Das Linken der
Objektdateien wird uber die folgende implizite Regel realisiert:
$(CC) $(LDFLAGS) Objektdateien $(LOADLIBES)
Die Verwendung von Variablen und impliziten Regeln fuhrt somit zu wesentlih kompakteren Makefiles. Einen Katalog der impliziten Regeln ndet man in der Anleitung zum
GNU make (siehe Abshnitt Referenzen).
3.4 Referenzen
OÆzielle Homepage zu GNU make:
http://www.gnu.org/software/make/make.html
Manuals zu GNU make:
http://www.gnu.org/manual/make/index.html
Info-Seiten f
ur GNU make: info make
10
4 Emas
4.1 Einleitung
Emas ist ein sehr leistungsfahiger und selbstdokumentierender Editor der aus einem LispInterpreter mit Funktionen zur Textverarbeitung besteht. Emas ist dadurh sehr exibel
an vershiedene Benutzeranforderungen anpabar und kann nahezu unbegrenzt, und ohne
die Notwendigkeit einer Neukompilation, erweitert werden.
Ein wihtiges Grundkonzept von Emas sind Buer\. Dies sind voneinander getrennte
"
Arbeitsbereihe, in denen vollig untershiedlihe Dinge vor sih gehen konnen. Ein Buffer kann z.B. C++-Quellenode beinhalten, aber auh eine Verzeihnisstruktur\, eine
"
Shell\, einen Debugger\ oder einen Compiler\.
"
"
"
Die Buer sollten niht mit den vershiedene Frames\ (Fenstern) verwehselt werden. In
"
den Frames werden ein oder mehrere Buer angezeigt, was aber niht bedeutet, da ein
Buer der niht angezeigt wird, niht mehr existiert.
Ein weiteres wihtiges Grundkonzept sind die Modi, die es erlauben das Verhalten von
Emas an vershiedenen Buerinhalte anzupassen. Im C++-Mode ist z.B. eine automatishe Einrukung des Quellenodes mit Tab und die xfarblih Hervorhebung von
Shlusselwortern moglih.
4.2 Erste Shritte
Vor dem Aufrufen mu in der Shell der Befehl module add emas ausgefuhrt werden.
Aufgerufen wird Emas dann mit: emas filename, wobei filename niht mit angegeben
werden mu.
Fur Neubenutzer bietet das Tutorial, welhes mit C-h t (bei gedrukter Control-Taste die
h-Taste druken und dann die t-Taste alleine druken) aufgerufen wird, einen shnellen
Einstieg.
4.3 Dokumentation
Zusatzlih zur im Tutorial beshriebenen Online-Hilfe (uber die man sih mit C-h ? eine

Ubersiht
vershaen kann) konnen mit C-h i die Info-Files konsultiert werden. Das komplette Handbuh kann unter http://www.gnu.org/manual/emas-20.3/emas.html gefunden werden. Eine einseitige Zusammenfassung der wihtigsten Befehle (die RefereneCard) steht unter http://www.refards.om/ zur Verfugung.
4.4 Konguration von Emas
Die Konguration von Emas geshieht durh Editieren der Datei .emas im Homeverzeihnis des Users, die beim Aufstarten von Emas eingelesen wird.
Wenn zum Beispiel die Funktion dabbrev-expand, die praktish ist um z.B. lange Variablenname nah Eingabe von ein paar Zeihen automatish zu komplettieren, mit S-iso-lefttab
11
(gleihzeitiges Druken der Shift- und der Tabulatortaste) anstatt des auf der deutshen
Tastatur weniger praktishen M-/ aufgerufen werden soll, kann dies durh Eintragen der
folgenden Zeile in .emas erreiht werden:
(global-set-key [S-iso-lefttab℄ 'dabbrev-expand)
4.5 Nutzlihes

Unbegrenztes Undo Mit C- konnen alle Anderungen
in einem Buer rukgangig gemaht werden.
Inkrementale Suhe Die nah
C-s nah und nah eingegebenen Buhstaben werden
bei der Suhe beruksihtigt. Dadurh ist es moglih mit weniger Shreibaufwand
Zeihenketten zu nden.
Kompilieren Ein C++-File kann mit
M-x ompile kompiliert werden. Falls Fehler
auftreten kann durh druken von Return (oder mit der mittleren Maustaste) in
der entsprehenden Zeile des Kompilationsbuers direkt an die Stelle des Fehlers im
Quellode gesprungen werden.
Debuggen GDB kann durh
M-x gdb in Emas aufgestartet werden und erlaubt eine
komfortablere Bedienung als ein Aufruf in einer Shell.
Einfugen von Kommentaren Mit Hilfe des
urzungen deabbrev-mode konnen Abk
niert werden die nah der Eingabe in einem Buer automatish ersetzt werden.
Somit ist es z.B. moglih das Gerust\ einer Funktionsbeshreibung einmalig zu
"
erzeugen um es dann mit Hilfe der Abkurzung innerhalb des Quellodes shnell
einzufugen.
Navigieren im Quellode Mit Hilfe des Programmes
etags konnen fur vershieden
File-Typen tags (Markierungen) erzeugt werden. Diese tags konnen dann von Emas
gelesen werden und erlauben den shnellen Zugri auf den Inhalt der Files (im Falle
von C++-Files kann man z.B. so gezielt und shnell auf Funktionen zugreifen).
"Retangle-Mode\ Das Kopieren, Ausshneiden, Einfugen und Fullen von rehtekigen
Regionen ist mit dem retangle-mode\ moglih. Die Region kann mit der Maus
"
ausgewahlt werden (wobei Anfang- und Endpunkt die linke obere bzw. die rehte
untere Eke festlegen). Die wihtigsten Befehle sind:
C-x r k: kill retangle
C-x r y: yank retangle
C-x r t: string retangle
und konnen z.B. zum Auskommentieren verwendet werden.
12
5 GDB
5.1 Kurzbeshreibung
Ein Debugger ist ein Programm, das andere Programme ausfuhren kann und dem Benutzer Moglihkeiten zur Kontrolle und Untersuhung des Programmablaufs bietet. Insbesondere beinhalten diese Moglihkeiten kontrollierte shrittweise Abarbeitung des Programms
und Anzeigen momentaner Variablen, Speiherzustande et. Auh ist es moglih, aufgetretene Programmabsturze nahtraglih zu untersuhen, und den Fehler so zu lokalisieren.
Einige fortgeshrittenere Debugger bieten bequeme graphishe Darstellung ganzer Datenstrukturen und deren Abhangigkeiten oder Performaneanalysen, um bei der Optimierung
zu unterstutzen.
Der GNU-Debugger GDB ist der popularste Debugger fur UNIX-Systeme. Es ist ein
Kommandozeilendebugger, der jedoh bequem durh Emas oder andere grashe Benutzeroberahen wie DDD bedient werden kann.
5.2 Wihtigste Anwendungsvarianten
5.2.1 Starten
Voraussetzung fur das Debuggen eines Programms ist, da das Kompilat entsprehende
Informationen und Bezuge zu den Quelldateien enthalt.
Dies mu beim Compilierenaufruf explizit angegeben werden durh das Flag -g. Folgender
Aufruf erzeugt z.B. eine solhe Datei.
g++ -g myfile. -o myfile
Auf ein solhes Programm kann der GDB sofort angewandt werden. Gestartet wird er
via gdb, notwendige Kommandos, um das Programm zu debuggen sind
le myle
Dieser Befehl ladt die Debugging-Informationen aus der angegebenen Datei, und
legt myle als auszufuhrendes Programm fest. Dieser Befehl ist insbesondere nah
Neuompilieren des Codes erforderlih!
run ommandparams [< inputle℄ [> outputle ℄ Dieser Befehl startet das zuvor festgelegt Programm mit den Kommandozeilenparametern ommandparams und den
angegebenen Dateien als Quellen fur stdin/stdout.
Weitere allgemeine Kommandos sind z.B.
help
Zeigt Hilfethemen an, bzw. durh Angabe eines konkreten Befehls dessen spezishe
Hilfekommentare.
13
shell mdstring
Fuhrt den angegebenen String in der zugrundeliegenden Shell aus.
quit
Beendet den gdb.
5.2.2 Kontrolle des Programmablaufs
Die bisherigen Befehle bieten niht mehr Funktionalitat als ein direkter Aufruf des Programms aus einer Shell heraus. Wesentlihe Elemente zur Steuerung des Programmablaufs
sind nun die Befehle zum Anhalten der Ausfuhrung an denierten Stellen (Breakpoints)
und zum shrittweisen Ausfuhren:
break [le:℄funtion, break [le:℄line
Setzt einen Haltepunkt beim Eintritt in die angegebene Funktion, bzw. an der
angegebenen Zeile im Quellode.
info break
Listet alle bisher denierten Haltpunkte auf.
delete [n℄
Loshen aller Haltepunkte oder des denierten Haltepunkts mit Nummer n.
step, s
Ausfuhren der aktuellen Zeile des Programmodes. Ist dies ein Aufruf einer Funktion, wird an den Anfang von deren Quellode gesprungen.
next, n
Ausfuhren der aktuellen Zeile des Programmodes. Ist dies ein Aufruf einer Funktion, wird die gesamte Funktion abgearbeitet, und niht in diese Funktion hineingesprungen.
up, down
Springt in der Funktionsaufruf-Hierarhie eine Stufe nah oben bzw. unten, ermogliht
hiermit Untersuhung der Funktionsaufrufe und deren Parameter, die zu einer bestimmten Programmstelle gefuhrt haben.
nish
Fuhrt das Programm bis zum Ende der aktuellen Funktion aus.
ont, Fuhrt das Programm normal aus, bis der nahste Haltepunkt erreiht wird, oder
das Programm terminiert.
14
5.2.3 Speiherkontrolle
Weitere wesentlihe Funktionalitat eines Debuggers umfat Zugrismoglihkeiten auf den
Speiher, d.h. Speiher auslesen bzw. Speiherinhalte manipulieren:
print expr, p expr
Wertet den C-Ausdruk expr (normalerweise eine Variable) einmalig aus, und stellt
das Ergebnis dar.
display expr
Wertet den C-Ausdruk expr aus, und stellt das Ergebnis bei jedem folgenden Programmstop dar.
undisplay n
Losht den anzuzeigenden Ausdruk mit Nummer n von der Liste der wiederholt
anzuzeigenden Ausdruke.
set var = expr
Wertet den Ausdruk expr aus, und setzt dies als neuen Wert der Variablen var.
5.2.4 Untersuhung von Programmabsturzen
Auer kontrolliertem Ausfuhren von Programmen ermogliht GDB auh die Untersuhung
vorangehender Programmabsturze auf Basis eines beim Absturz erzeugten Coreles. Die
Erzeugung solher Files mu in der Shell zunahst eingestellt werden. Mit Hilfe von
ulimit -a
werden die Speihergrenzen fur diverse Groen angezeigt. Unter oredump muss ein positiver Eintrag stehen, damit Coredumps erzeugt werden. Dies kann (in den meisten Shells)
via
ulimit - oresize
eingestellt werden, wobei oresize die gewunshte Groe in Bytes darstellt.
Hat ein Fehlerhaftes Programm anshlieend ein Corele erzeugt, kann die Absturzstelle
mit GDB ermittelt werden, indem nah normalem Starten von GDB und Festlegen des
zu inspizierenden (abgesturzten) Programms mit le, das Corele geladen wird. hierzu
dient der Befehl
ore orele
Der Programmablauf bendet sih exakt am Absturzpunkt. Ein Abarbeiten des Programms ist selbstverstandlih niht weiter moglih, jedoh lassen sih die Variablen weiter
abfragen.
15
5.3 GDB unter Emas
Speziell unter Verwendung von Emas lat sih der GDB bequem bedienen. Mit M-x
gdb wird ein Fenster geonet, in dem GDB-Kommandos ausgefuhrt werden konnen. Indem man im Hauptprogramm einen Haltepunkt setzt und das Programm startet, teilt
sih das aktuelle Fenster, und der Quellode ersheint. Emas interpretiert die Informationen von gdb, indem es die aktuelle Position im Sourele markiert, und dies auh beim
shrittweisen Abarbeiten des Programms immer aktualisiert.
Spezielle Tastenkombinationen ermoglihen einfahere Eingabe von Befehlen. u.a.
C- C- Briht Programmablauf ab, springt an die aktuelle Stelle im Programm
C-x SPC
und ermogliht anshlieend shrittweise Abarbeitung.
Fugt einen Haltepunkt in der Zeile der aktuellen Cursorposition ein.
M-p, M-n
Die Liste der bisher eingegebenen GDB-Kommandos wird abgelaufen, ermogliht so
einfahes Wiederholen von Befehlen.
5.4 Referenzen
Die angegebenen Varianten der Befehle sind nur ein Bruhteil aller moglihen. Fur
ausfuhrlihere Beshreibungen siehe folgende Referenzen:
Online-Handbuh: http://soures.redhat.om/gdb/onlinedos/gdb_to.html
Referenz-Karte: http://www.s.prineton.edu/~benjasik/gdb/gdb.ps
6 CVS
6.1 Was ist CVS?
Das Conurrent Versions System (CVS) dient zur Versionsverwaltung kompletter und
ggf. mehrstuger Datei-Verzeihnisse, wie sie ubliherweise in groeren Software- oder
Kongurationsprojekten entstehen. CVS baut intern auf das sogenannte Revision Control
System (RCS) auf und benutzt eine ahnlihe Begriswelt wie RCS. Im Gegensatz zu RCS
sind jedoh keine expliziten Sperren auf Dateien moglih, so da auh mehrere Personen
die gleihe Datei andern (oder gar loshen) konnen. Etwaige Konikte, die bei den meisten
Projekten erfahrungsgema jedoh selten auftreten, werden spater aufgelost.
Die Grundidee bei CVS ist, da es ein zentrales Repository (auf deutsh: Lagerstatte)
gibt, in dem der gesamte Dateibaum vershiedener Projekte mit den dazugehorigen Verzeihnissen, Dateien und deren Versionen abgelegt ist. Jeder Benutzer erzeugt mit Hilfe
von CVS eine private Arbeitskopie (oder auh mehrere) eines zu einem Projekt gehorenden
16
Dateibaums. Hier kann er die Dateien beliebig andern, sowie neue Dateien und Verzeihnisse erzeugen oder auh veraltete Dateien und Verzeihnisse entfernen. Nahdem er seine

Anderungen
vorgenommen hat, mu er diese zunahst mit der Version im Repository abgleihen und anshlieend in das Repository eintragen, nahdem er ggf. Konikte mit

den Anderungen
anderer Benutzer aufgelost hat. Hilfreih ist hier oft, sih zunahst die

eigenen Anderungen nohmals anzusehen, insbesondere, wenn mehrere Dateien betroen
sind.
Anmerkungen : CVS wird fast vollstandig durh den Befehl vs(1) gesteuert. Die eigentlihen Aktionen von CVS werden durh Kommandonamen gesteuert, die als erster
Parameter auf der Kommandozeile dem Befehlswort vs folgen (s.u.). An vershiedenen
Stellen werden Versionsnummern und Bezeihner benotigt und benutzt, auf die wir hier
aber niht weiter eingehen.
6.2 Arbeiten mit CVS
6.2.1 Vorbereitungen
module add vs | Programm in den Suhpfad laden Das Programm vs mu
der Shell bekannt gemaht werden. Das geshieht in unserer Umgebung durh die Eingabe
von
idefix:~ $ module add vs
vs init | Neues CVS-Repository anlegen Ein neues Repository wird angelegt, in-
dem man (an beliebiger Stelle) ein Verzeihnis anlegt, die Environment-Variable CVSROOT
darauf einstellt, in dieses wehselt und dann das Kommando init ausfuhrt:
idefix:~ $ mkdir /sw-praktikum/vsroot
idefix:~ $ d /sw-praktikum/vsroot
idefix:~ $ setenv CVSROOT /sw-praktikum/vsroot
idefix:/sw-praktikum/vsroot $ vs init
vs import | Neues CVS-Projekt anlegen Man beginnt ein neues Projekt, indem
man in einem beliebigen Verzeihnis work dir (niht in CVSROOT!) mindestens ein neues
Verzeihnis anlegt, ggf. auh weitere Unterverzeihnisse des neuen Projekts. Anshlieend
wehselt man wieder nah work dir und ruft dort das CVS-Kommando import auf. Dabei
werden drei weitere Parameter notig:
1. Der Projektname (Verzeihnisname), unter dem das Projekt abgelegt werden soll.
17
2. Ein globaler Bezeihner fur die Version, der vor allem wihtig ist, wenn mehrere
Versionen von Fremdsoftware mit verwaltet werden sollen (hier also niht).
3. Ein lokaler Bezeihner fur die Version.
Die lokalen bzw. globalen Bezeihner sind fur uns in diesem Falle (neues Projekt) niht
weiter von Interesse. Wir wahlen einfahe Bezeihner, die auf die Neuheit des Projektes
verweisen:
idefix:... $ mkdir my proj
idefix:... $ d my proj
idefix:.../my proj $ mkdir sr
idefix:.../my proj $ mkdir inlude
idefix:.../my proj $ vs import new proj start it developer 0
vs import: Importing $CVSROOT/new proj/sr
vs import: Importing $CVSROOT/new proj/inlude
-->$CVSEDITOR
No onflits reated by this import
6.2.2 Arbeiten mit einem CVS-Repository
vs hekout | Arbeitskopie erzeugen Nahdem man die Environment-Variable
$CVSROOT auf den Pfad des Repositories eingestellt hat, kann man mit dem CVS-Kommando
hekout im aktuellen Verzeihnis eine Kopie der aktuellen Version des Dateibaums von
einem im Repository abgelegten Projekt erzeugen (hier z.B. test):
idefix:~/... $ vs hekout test
vs hekout: Updating test
U test/file
Nun konnen die bestehenden Dateien geandert (bzw. neue angelegt oder veraltete gelosht)
werden:
idefix:~/... $ d test
idefix:~/.../test $ $EDITOR file
18
Anmerkung : CVS legt im Arbeitsverzeihnis (und in allen Unterverzeihnissen) zusatzlihe
Verzeihnisse mit dem Namen CVS an. Diese und die darin enthaltenen Dateien durfen
niht manipuliert werden!

vs update | Eigene Anderungen
mit dem Repository abgleihen Nah er-

folgter Anderung
werden die Dateien mit dem CVS-Kommando update mit der Version
im Repository verglihen. Hierbei wird insbesondere gepruft, ob seit dem letzten Abgleih (oder hekout) Dateien durh andere Benutzer geandert wurden. Existieren solhe

Anderungen,
werden sie automatish in der eigenen Arbeitskopie nahgetragen. Falls dabei Konikte auftreten, z.B. weil zwei Benutzer an der gleihen Stelle einer Datei geandert
haben, so mussen diese zunahst aufgelost werden.
idefix:~/.../test $ vs update
vs update: Updating .
M file

Es wird fur jede Datei, die von Anderungen
betroen ist, ihr Name ausgegeben und ein

Indikator (Buhstabe am Anfang der Zeile), der die Anderung
beshreibt:

Updated Anderungen
aus dem Repository wurden in die Arbeitsdatei ubernommen. Es
sind keine Konikte aufgetreten.

Modied Die Arbeitsdatei wurde verandert. Anderungen
konnen durh ein ommit ins
Repository ubertragen werden.


Conits Es gibt Konikte zwishen Anderungen
in der Arbeitsdatei und Anderungen
im Repository (s. Konikte auosen).
Removed Die Arbeitsdatei wird (durh das ommit) auh im Repository gelosht.
Added Die Arbeitsdatei wird (durh das ommit) als neue Datei ins Repository aufgenommen.
? Arbeitsdatei: Keine korrespondierende Datei im Repository

vs ommit | Anderungen
ins Repository eintragen Treten keine Konikte auf,

bzw. sind diese behoben, so werden die Anderungen
endgultig mit dem CVS-Kommando
ommit ins Repository eingetragen. Dabei wird f
ur die geanderten Dateien ein Editor
(Environment-Variable $CVSEDITOR bzw. $EDITOR) geonet, in den man seine Anmer
kungen zu den Anderungen
eintragen kann:
idefix:~/.../test $ vs ommit
vs ommit: Examining .
vs ommit: Committing .
19
-->$CVSEDITOR
Cheking in file;
$CVSROOT/test/file,v <-- file
new revision: 1.2; previous revision: 1.1
done
Ahtung : Wurden die Konikte nah einem update-Kommando niht aufgelost, so werden
die Dateien mit Koniktmarkierungen (s. Konikte auosen) ins Repository ubertragen.
Das Arbeitsverzeihnis bleibt durh den Befehl ommit erhalten, es kann einfah gelosht
werden, falls es niht mehr gebrauht wird.
vs add | Neue Dateien einfugen Hat man, z.B. mit dem Editor, eine neue Datei
angelegt, so mu diese mit dem CVS-Kommando add beim Repository angemeldet werden.
idefix:~/.../test $ $EDITOR newfile
idefix:~/...;/test $ vs add newfile
vs add: sheduling file `newfile' for addition
vs add: use 'vs ommit' to add this file permanently

Die endgultige Ubernahme
erfolgt erst bei einem ommit:
idefix:~/.../test $ vs ommit
vs ommit: Examining .
vs ommit: Committing .
RCS file: $CVSROOT/test/newfile,v
done
-->$CVSEDITOR
Cheking in newfile;
$CVSROOT/test/newfile,v <-- newfile
initial revision: 1.1
done
vs remove | Dateien loshen Dateien bzw. Verzeihnisse konnen durh das CVSKommando remove aus dem Repository gelosht werden, wenn sie auh im Arbeits20
verzeihnis gelosht wurden (bei Verzeihnissen erst deren Dateien aus dem Repository
loshen, ggf. rekursiv).
idefix:~/.../test $ rm file
idefix:~/.../test $ vs remove file
vs remove: sheduling `file' for removal
vs remove: use 'vs ommit' to remove this file permanently
Auh hier erfolgt die endgultige Loshung erst durh ein ommit (Die Dateien werden
niht wirklih im Repository gelosht, sondern nur als gelosht markiert, da man jederzeit
eine alte Version des Projektes wieder herstellen konnen mu):
idefix:~/.../test $ vs ommit
vs ommit: Examining .
vs ommit: Committing .
-->$CVSEDITOR
Removing file;
$CVSROOT/test/file,v <-- file
new revision: delete; previous revision: 1.2
done

vs di | Anderungen
betrahten Oft will sih der Benutzer vor einem
ommit

nohmals die Anderungen
ansehen, die er vorgenommen hat. Hier gibt es das CVSKommando diff, das auf dem UNIX-Befehl diff(1) aufbaut und auh die gleihen

Optionen hat. In diesem Fall werden Anderungen
mit einem ! eingeleitet:
idefix:~/.../test $ vs diff -b
vs diff: Diffing .
Index: file
===================================================================
RCS file: $CVSROOT/test/file,v
retrieving revision 1.1
diff -b - -r1.1 file
*** file
1998/01/20 00:03:59
1.1
21
--- file
1998/01/21 08:15:21
***************
*** 3,9 ****
#
# test CVS -- history at end
! testfile
#
# Revision 1.4 2000/01/13 08:25:19 duda
# Seitenfuss vereinheitliht
#
# Revision 1.3 2000/01/12 09:56:11 duda
# ISA-->VS
#
# Revision 1.2 1998/07/01 09:35:28 asheman
# Ruk-Verweis auf CVS-Hauptseite eingefuhrt
#
# Revision 1.1 1998/04/20 11:13:39 asheman
# Initial revision
#
--- 3,10 ---#
# test CVS -- history at end
! hanged one line
! to two lines!
#
# Revision 1.4 2000/01/13 08:25:19 duda
# Seitenfuss vereinheitliht
#
# Revision 1.3 2000/01/12 09:56:11 duda
22
# ISA-->VS
#
# Revision 1.2 1998/07/01 09:35:28 asheman
# Ruk-Verweis auf CVS-Hauptseite eingefuhrt
#
# Revision 1.1 1998/04/20 11:13:39 asheman
# Initial revision
#
Konikte auosen Treten bei dem Kommando update Konikte auf, z.B.
idefix:~/.../test $ vs update
vs update: Updating .
RCS file: $CVSROOT/test/newfile,v
retrieving revision 1.1
retrieving revision 1.2
Merging differenes between 1.1 and 1.2 into newfile
rsmerge: warning: onflits during merge
vs update: onflits found in newfile
C newfile
die niht von CVS automatish aufgelost werden konnen (Dateien, die mit dem Indikator
C gekennzeihnet sind), so passiert folgendes:
1. Die unmodizierte Datei, von der beide Versionen ausgegangen sind, wird als .#le.version im jeweiligen Arbeitsverzeihnis abgelegt. Dabei entspriht le dem Dateinamen und version der Versionsnummer.
2. Die eigentlihe Datei enthalt den kompletten Inhalt beider Versionen inkl. der Konikte. Bereihe, in denen Konikte aufgetreten sind, sind folgendermaen aufgebaut:
<<<<<<< newfile
Conflit from loal file!
=======
Conflit from repository!
23
>>>>>>> 1.2
Die Konikte mussen dann in der Arbeitsdatei manuell aufgelost werden. Anshlieend
mu die Datei (oder die Dateien) wieder mit den Befehlen update und ommit ins Repository ubertragen werden.
6.2.3 CVS und Emas
Die meisten CVS Kommandos lassen sih komfortabel im Emas ausfuhren.
Als Vorbereitung mu dafur (vor dem Start des emas) in der Shell der Befehl
module add emas
ausgefuhrt werden. Folgende Zeile ist auerdem in die Datei ~/.emas zu ubernehmen:
(autoload 'vs-update "pl-vs" nil t)
Der CVS-Modus kann dann durh den Emas-Befehl
M-x vs-update
aktiviert werden. Hilfe zu den verfugbaren Kommandos gibt anshlieend die Eingabe
eines ?.
Alternativ dazu kann auh der Menupunkt Tools!Version Control verwendet werden.
6.2.4 CVS Home
CVS kann auh von einem Heimarbeitsplatzrehner verwendet werden. Zunahst muss
man gewahrleisten, dass eine ordnungsgemae ssh-Verbindung vom Heimarbeitsplatz zu
dem CVS-Server aufgebaut werden kann. Naheres dazu unter man ssh, man ssh-keygen.
Weiterhin mussen folgende Variablen (auf dem Heimarbeitsplatz) gesetzt werden:
heimrehner:~ $ setenv CVSROOT USERNAMESERVERNAME:/sw-praktikum/vsroot
heimrehner:~ $ setenv CVS RSH ssh
USERNAME steht f
ur den Uni-Aount, als SERVERNAME kann
miraulix.informatik.uni-freiburg.de eingesetzt werden. Anshlieend kann wie
gewohnt durh den Befehl
heimrehner:~ $ vs hekout test
24
eine Arbeitskopie erzeugt werden.
6.3 Referenzen
Die hier beshriebene Kurzanleitung orientiert sih zu einem groen Teil an
http://www.informatik.tu-darmstadt.de/VS/Rehner/Software/Cvs/Kurz.html
Weitere Referenzen lassen sih ausgehend von http://www.vshome.org lesen.
Weiterhin stehen im Labor die Handbuher ,,Version Management with CVS\, ,,User's
Guide to pl-vs|the Emas Front-End to CVS\ und ,,CVS Quik Referene Card\
bereit.
7 Doxygen
7.1 Kurzbeshreibung
Doxygen ist ein Dokumentationssystem fur C++, Java, IDL und C. Es kann auf 3 vershiedene Weisen eingesetzt werden:
1. Es kann auf Basis von kommentierten Quelldateien on-line Dokumentationen in
HTML und/oder o-line Handbuher in LATEX erzeugen. Ausgabe in RTF (MSWord), PostSript, hyperlinked PDF, komprimiertem HTML und als Unix man
pages werden ebenfalls unterstutzt. Die Dokumentation wird direkt aus den Quelldateien extrahiert, wodurh die Konsistenz von Programmode und Dokumentation
sehr viel einfaher gewahrleistet werden kann.
2. Doxygen kann dazu verwendet werden die Programmstruktur aus unkommentierten
Souren zu extrahieren. Dies kann sehr nutzlih sein, um sih shnell in groen
Paketen von Quelldateien zu orientieren. Die Abhangigkeiten zwishen Dateien, die
hierarhishen Beziehungen zwishen Klassen und die Komponenten von Klassen
bzw. Strukturen werden durh Graphen visualisiert, die alle automatish generiert
werden.
3. Doxygen kann durh seinen Befehlssatz (einshlielih einiger LATEX und HTMLKommandos) dazu mibrauht werden, gewohnlihe Dokumente zu erzeugen.
7.2 Wihtigste Anwendungsvarianten
7.2.1 Setup und einfaher Aufruf
Um Doxygen benutzen zu konnen mussen zunahst entsprehende Softwarepakete eingebunden werden. Dies geshieht durh die shell-Kommandos
module add doxygen
module add gv
25
Die gesamten Optionen zur Funktionsweise von Doxygen mussen in einem Kongurationsle angegeben werden, das ahnlihe Struktur wie ein Makele hat.
Ein solhes Default-Kongurationsle wird erzeugt, indem Doxygen mit der -g Option
aufgerufen wird:
doxygen -g <onffile>
Anshlieend kann die Datei <onffile> mit einem beliebigen Editor bearbeitet werden,
oder man verwendet die grashe Oberahe doxywizard, die uber nutzlihe Hilfekommentaren zu den einzelnen Eintragen verfugt.
Die minimal anzugebenden Optionen sind
INPUT,FILEPATTERNS: die zu durhsuhenden Dateien festlegen
HAVE_DOT: Erzeugen der diversen Graphen
GENERATE_HTML,GENERATE_RTF,GENERATE_LATEX, GENERATE_XML,GENERATE_MAN:
Festlegen der Ausgabeformate.
Ohne weitere Angaben wird fur die entsprehenden Ausgabeformate jeweils ein defaultVerzeihnis angelegt, in das die Ausgabe erfolgt.
Weitere nutzlihe Optionen sind
OUTPUT_LANGUAGE: Ausgabesprahe festlegen
HTML_HEADER,HTML_FOOTER: Festlegen der HTML-Files, die in der HTML-Dokumenta-
tion als Kopf bzw. Fu jeder Seite eingefugt werden.
7.2.2 Kommentieren der Souren
Fur sinnvolle Aussagen aus der durh Doxygen erzeugten Dokumentation ist ein vorgeshriebener Dokumentationsstil der Quelldateien notwendig. Durh einen Kommentarblok der Form /*! text */ bzw. die Einzelzeilenvariante //! text konnen Kommentarbloke deniert werden, die von Doxygen bearbeitet werden. Innerhalb dieser Bloke
kann beliebiger freier Text und eine Vielzahl von Shlusselworter verwendet werden.
Fur alle Bestandteile wie Dateien, Klassen, Methoden, Variablen, Funktionen et. ist eine
solhe Dokumentation moglih und sinnvoll. Grundsatzlih ist fur jedes dieser Objekte
eine Kurzdokumentation (durh die Einzeilenvariante) und eine detailliertere Dokumentation (durh einen Kommentarblok) moglih.
Ist eine Kurzdokumentation langer als eine Zeile, mu diese innerhalb des Detaildokumentationsbloks durh das Kommando \brief deniert werden. Der gesamte Text bis
zur nahsten Leerzeile wird dabei als Kurzdokumentation aufgefat.
Die Kommentarbloke stehen grundsatzlih vor den Denitionen oder Deklarationen. In
Einzelfallen ist eine andere Position sinnvoll. Eine Referenz auf das vorhergehenden Objekt kann z.B. durh die Einzeilenvariante via //!< text hergestellt werden. Dies maht
bei Variablen Sinn, die nur einer kurzen Erlauterung bedurfen, ein Beispiel folgt unten.
26
Will man einen Kommentarblok vollkommen von der Denition oder der Deklaration
eines Objektes losen, mu der Bezug des Bloks zu dem Objekt hergestellt werden mittels
dem entsprehenden Shlusselwort \lass, \strut, \union, \enum, \fn, \var, \def,
\file oder \namespae und anshlieendem Objektnamen.
Grundsatzlih sollen publi-Komponenten in den Header-Dateien dokumentiert werden,
private-Komponenten stattdessen in den zugehorigen Quelldateien.
Einige Shlusselworter, die in den Bloken verwendet werden sollen, sind:
\param <parname> <desription>: Dokumentation von Funktionsparametern.
\exeption <exname> <desription>: Dokumentation mogliher Exeptions.
\return <desription> : Dokumentation des R
ukgabewertes einer Funktion.
Nun wird ein Beispiel fur eine solhe kommentierte Datei angegeben. Man beahte,
da die 'Kommentarsternhen' von Doxygen sinnvollerweise niht als Textbestandteile
ubernommen werden.
/*! ***************************************************************
**
** \file dummylass.hh
** \brief provides dummy lass for demonstration of
**
doxygen-funtionality.
**
****************************************************************/
#inlude <parentlass.hh>
//! brief desription of Dummylass.
/*! More detailed desription an be
longer. */
lass DummyClass : publi ParentClass
{
publi:
/*!
*
*
*
*
*
*
*
*
*
*/
\brief
a brief desription an also last over several lines
as shown in this example of a onstrutor.
detailed desription of the onstrutor:
reates new Dummylass Instane.
\param
\param
param1
name
some initialization parameter
name of the instane.
\exeption
DummyClassExeption the possible exeptions
DummyClass(onst int param1, onst har *name);
//!
/*!
*
*
alulation of some reasonable value.
\param
param1
some neessary parameter for alulation
27
* \return
*/
the result of the alulation
int al_something(onst int param1);
/*!
*/
};
a publi variable ontaining one property.
int property1;
float property2; //!< this is a bakward-referene doumentation line.
7.2.3 Weitere Funktionalitat
Die bisher angegebenen Shlusselworter sind nur ein geringer Ausshnitt aller moglihen.
Unter anderem sind viele HTML und LATEX Kommandos moglih, fur Details hierzu und
zu den vielfaltigen Eintragen in den Kongurationsles siehe unterstehende Referenz.
7.3 Referenzen
Doxygen Homepage: http://www.stak.nl/~dimitri/doxygen/index.html
28