#format rst #language de Tipps zur Arbeit unter GNU/Linux ================================ | Hubert Högl, | URL: http://elk.informatik.hs-augsburg.de/hhweb/doc/unixtipps.html | Last update: 2012-10-28 .. contents:: Inhalt .. sectnum:: Änderungen am Dokument ---------------------- :: Datum Änderung 2013-02-09 Update einiger Links; Djgpp entsorgt 2012-10-28 Nach ReST übertragen 2004-10-26 Wie installiert man Djgpp? 2003-03-23 Unterschiede beim Textformat unter UNIX / MSDOS 2002-04-09 Vim-Links hinzugefügt 2002-04-06 Die wichtigsten Emacs und Vim Kommandos 2002-03-27 Einige Verbesserungen im Make-Abschnitt 2002-03-25 Initiales Dokument Die Shell --------- * Da häufig das aktuelle Verzeichnis nicht Teil der ``PATH`` Umgebungsvariable ist, müssen ausführbare Dateien mit dem Prefix ``./`` gestartet werden, z.B. ``./mein_erstes_programm``. Sie können sich die ``PATH`` Variable mit ``echo $PATH`` ausgeben lassen. * Das Sonderzeichen ``~`` steht für Ihr Homeverzeichnis, z.B. ``/home/frodo/``. Möchten Sie eine Datei aus einem anderen Home kopieren (sofern dies durch die Dateirechte möglich ist), dann können Sie den login-Namen einfach an die Tilde hängen, z.B. :: cp ~hhoegl/swep/* . Dieses Kommando kopiert alle Dateien im Unterverzeichnis ``swep/`` des Users ``hhoegl`` in das aktuelle Verzeichnis. * Mit dem ``history`` Kommando können Sie sich früher eingegebene Kommandos anzeigen lassen. * Kommandos werden durch Anhängen eines ``&`` Zeichen im Hintergrund gestartet, so dass man nachher in der gleichen Shell weitere Kommandos eingeben kann. Beispiel: :: emacs& Sollte ein Kommando ohne ``&`` gestartet worden sein, dann kann man nachträglich die Tastenfolge ``Ctrl-Z`` und ``bg`` eingeben. Damit wird der Prozess suspendiert und danach in den Hintergrund (background) geschoben. * Moderne Shells wie die ``bash`` haben einen sehr zeitsparenden Vervollständigungs-Mechanismus (auto-completion), der durch Drücken auf die ``TAB`` Taste ausgeführt wird. Das Kommando ``vim meinerstesprogramm.cc`` kann man z.B. abkürzen durch ``vim mein``, danach sollte dann der komplette Dateiname vervollständigt worden sein (falls "mein" eindeutig war). * Terminieren von Programmen. Falls ein Programm in der Shell im Vordergrund läuft, dann können sie es einfach durch ``Ctrl-C`` (gleichzeitiges Drücken der Control und C Taste) beenden. Falls das Programm im Hintergrund läuft, müssen sie zuerst die PID (Prozess ID) herausfinden und dann das Kommando ``kill -9 `` anwenden. Die PID finden Sie mit dem auf allen UNIX Systemen verfügbaren ``pid`` Kommando heraus. Am besten sie verwenden die Optionen ``-efl``, um alle Prozessor im long-Format angezeigt zu bekommen. Die Ausgabe können sie mit dem Werkzeug ``less`` lesen, so dass sie bequem nach Ihrem Prozess suchen können. :: ps -efl | less # pid ist z.B. 4197 kill -9 4197 UNIX Kommandos -------------- Den Inhalt dieses Dokumentes kann man auch auf Unix-ähnliche Betriebssysteme und Umgebungen anwenden, wie z.B. Linux, Cygwin oder Djgpp. * Workstations unter UNIX oder LINUX *nicht* ohne vorherigen Shutdown ausschalten. * Sie arbeiten auf der Workstation in einem Shell-Fenster (oder in einer "Console", was hier keine Unterschied ist). Dazu müssen Sie in Ihrer grafischen Oberfläche (z.B. CDE, KDE oder GNOME) erst mal eine Shell starten. In diesem Shell-Fenster können Sie die in der jeweiligen Shell verfügbaren Kommandos eingeben. Typische Shells sind z.B. die ``bash`` ("bourne again shell") oder die ``sh`` (Ur-Shell), oder die ``csh`` (C-Shell), oder die ``tcsh`` (wesentlich verbesserte ``csh``). Welche Kommandos Ihnen zur Verfügung stehen, sehen Sie in den man-Pages der Shell. * Sie haben jede Menge Manuals auf Ihrem Rechner. Diese man-Pages können Sie mit dem ``man`` Kommando betrachten, z.B. :: man cp man ls man mv man bash (bzw. man sh) man man Falls Sie nicht genau wissen, wie die man-Page heisst, nach der Sie suchen, können Sie das ``apropos``-Kommando eingeben: :: apropos Das Werkzeug ``man`` verwendet die Umgebungsvariable ``MANPATH``, um die Seiten zu finden. Falls Sie eigene Verzeichnisse mit Manuals hinzufügen wollen, müssen Sie den ``MANPATH`` um den entsprechenden Pfad erweitern. * Hier sind ein paar einfache UNIX Kommandos: a. Mit dem Kommando ``cd`` wechseln Sie das Verzeichnis (change directory). Das aktuelle Verzeichnis ist immer ``.`` (Punkt). Das direkt darüberliegende Verzeichnis ist immer ``..`` (zwei Punkte). Falls Sie kein Argument angeben, wechselt ``cd`` in Ihr Homeverzeichnis. Beispiele:: cd swep/ cd .. cd /home/sonst/hhoegl/ cd #. Dateien kopieren Sie mit dem ``cp`` Kommando (copy). :: cp meinprogramm.cc meinprogramm2.cc #. Dateien löschen Sie mit dem ``rm`` Kommando (remove). :: rm meinprogramm.cc #. Dateien schaffen Sie von einem Ort im Dateisystem an einen anderen mit dem ``mv`` Kommando (move). Dieses Kommando ist äquivalent zu einem ``cp`` mit anschliessendem ``rm`` der Quelldatei. :: mv meinprogramm.cc alte_programme/ #. Das Kommando ``mkdir`` legt ein Verzeichnis an. #. Das Kommando ``rmdir`` löscht ein (leeres) Verzeichnis. #. Das Kommando ``less`` ist zum Betrachten ("browsen") von Textdateien vorzüglich ausgestattet. Sie rufen es z.B. auf mit ``less meinedatei.txt``. Sie können mit den Tasten ``j``, ``k`` und ``Space``, ``Backspace`` im Text navigieren (Vi kompatibel). Mit der Taste ``q`` beenden Sie ``less``. * Das GNU Projekt stellt ein mächtiges Hilfesystem zur Verfügung, das sich GNU-Info nennt. Die Hilfetexte schreibt man mit *TeX* unter Verwendung von speziellen Makros. Diese Dateien enden mit ``.texinfo`` oder ``.texi``. Mit Hilfe des GNU Werkzeugs ``makeinfo`` werden daraus die Info-Dateien erzeugt (Dateiendung .info), die Sie mit dem ``info`` Viewer oder mit dem Emacs (``C-h i``) ansehen können. Sie sehen in meinem Home unter ``~hhoegl/local/info/`` einige dieser Info-Dateien. Auch in diesem Verzeichnis enthalten ist die Datei ``dir``, die Verweise auf die einzelnen Info-Dateien enthält. Damit der info-Viewer die ``dir`` Dateien findet, müssen Sie u.U. die ``INFOPATH`` Umgebungsvariable um weitere Pfad-Segmente erweitern. Sollten Sie meine Info-Dateien lesen wollen (was ich Ihnen empfehle), dann machen Sie das so: :: export INFOPATH=$INFOPATH:/home/sonst/hhoegl/local/info Mit GNU-Info geschriebene Hilfetexte lassen sich auch mit Hilfe von *TeX* in ein gedrucktes Handbuch im PDF oder PostScript-Format umwandeln. Ausserdem gibt es eine Vielzahl an Konvertierprogrammen in weitere Formate, z.B. HTML (``makeinfo --html`` oder ``texi2html``), rohen Text (.txt) oder RTF. * Sollten Sie Ihre Textdateien unter MS Windows oder MS-DOS schreiben, dann können Sie diese jederzeit auf Ihren Unix Account kopieren und verwenden, allerdings müssen Sie folgende Kleinigkeit beachten: Sie werden bemerken, dass diese aus der MS-Welt kommenden Dateien beim Betrachten unter UNIX am Ende jeder Zeile ein zusätzliches Zeichen haben, das Sie in der ursprünglichen Datei gar nicht geschrieben haben, da es vom Editor automatisch eingefügt wird. Es handelt sich um das Wagenrücklaufzeichen -- auch bezeichnet als Carriage Return, Control-M bzw. Hex 0x0D. MS Textdateien schliessen nämlich jede Zeile mit der Sequenz 0x0D, 0x0A ab (Wagenrücklauf, Zeilenvorschub). Unter UNIX wird hingegen jede Zeile nur mit einem Zeilenvorschub abgeschlossen, somit ist das Zeichen 0x0D überschüssig und erscheint im Text. Unter Umständen macht das 0x0D-Zeichen unter UNIX gar keine Probleme, z.B. bei Quelltexten die mit gcc kompiliert werden. Mit Sicherheit gibt es aber Probleme beim Makefile. Sie müssen also unter UNIX dieses Zeichen irgendwie entfernen. Dazu gibt es mehrere Möglichkeiten: 1. Mit dem UNIX Werkzeug ``tr`` ("translate"): :: tr -d '\r' < infile > outfile Damit werden im File infile alle Wagenrücklaufzeichen ($\backslash$ r) gelöscht (-d) und das Ergebnis nach outfile geschrieben. 2. Mit dem Vim bei geöffneter Textdatei: :: :,$s/^M//g Damit wird im ganzen Text (``,$``) das Zeichen Control-M durch "kein Zeichen" ersetzt. Sie müssen ``^M`` als Folge "Control-V Control-M" tippen! Der VI/VIM Text Editor ---------------------- Verwenden Sie ``vi`` nur, wenn Sie keinen ``vim`` haben. Der ``vi`` ist auf jedem UNIX/Linux Rechner installiert, der ``vim``, obwohl wesentlich besser, nur manchmal. Bei den meisten Linux-Installationen ist allerdings der ``vim`` auch immer dabei. Nach dem Starten des Vi(m) landet man im **Kommando-Modus**. Dieser Modus dient nicht zum Schreiben von Text, sondern erlaubt z.B. das Navigieren im Text oder die Eingabe von einer Vielzahl an Kommandos an den Editor. Der Cursor wird bewegt mit ``j``, ``k``, ``h`` und ``l`` (ab, auf, links, rechts). Nach unten Blättern geht mit ``C-D`` (Control-D) nach oben mit ``C-B``. Sie verlassen den Vi/Vim im *Kommando-Modus* mit ``:wq`` (write and quit) oder mit ``ZZ`` (zweimal Gross-Z). Möchte man Text eingeben, dann muss man zuerst mit einer der Tasten ``i`` (insert), ``a`` (append), ``o`` (nach Zeile) oder ``O`` (vor Zeile) in den Eingabe-Modus schalten. Danach kann der Text wie gewohnt eingegeben werden. Um wieder in den Kommando-Modus zu schalten, weil man den Cursor vielleicht an eine andere Stelle bewegen möchte, tippt man auf die ``ESC`` Taste. Einen Vim Tutor ``vim_tutor.txt`` finden Sie im Verzeichnis ``swep/aufgaben/``. Öffnen Sie diesen Tutor mit Vim (oder Vi) wie folgt:: vim vim_tutor.txt Während Sie diesen Text lesen, werden Ihnen die wichtigsten Kommandos erklärt. Mit der ``j``-Taste können Sie im Text nach unten scrollen. Im folgenden sind ein paar Tutorials zum Vi(m) aufgeführt: * Mastering the Vi Editor (University of Hawaii). http://web.eng.hawaii.edu/Tutor/vi.html .. http://www.hs-augsburg.de/~hhoegl/swep/www/editor/vi.html * An Introduction to Display Editing with Vi (by Bill Joy, Mark Horton. http://docs.freebsd.org/44doc/usd/12.vi/paper.html .. http://www.hs-augsburg.de/~hhoegl/swep/www/editor/vi-paper/paper.html * Vi Macros (Fred Buck, 1988). http://www.phil.muni.cz/~letty/software/vi-macros.html .. http://www.hs-augsburg.de/~hhoegl/swep/www/editor/vimacros.txt Der Emacs Texteditor -------------------- Das Emacs-Tutorial erreichen Sie durch die Eingabe von ``C-h t``, nachdem der Emacs gestartet ist. Im Klartext heisst dieses Kommandokürzel: Control-Taste drücken und gleichzeitig auch die ``h`` Taste. Danach weg von beiden Tasten und nur die ``t``-Taste drücken. Nun sollte im Emacs das Tutorial angezeigt werden. Die in der Emacs-Dokumentation als *Meta* bezeichnete Taste ist i.d.R. die ESC Taste. Diese Taste wird mit dem Kürzel ``M-`` bezeichnet, z.B. bedeutet ``M-x compile`` das Drücken der Meta- und der x-Taste, und danach das Eingeben des Wortes "compile". Häufig kann man aber auch bei IBM-PC Tastaturen die ALT-Taste bzw. bei der Sun Workstation die Taste mit der Raute verwenden -- beide sind links neben der langen Leerzeichen-Taste angeordnet. Ein paar wichtige Tastenkürzel: :: C-x C-f Őffnen eines neuen oder bereits vorhandenen Files. C-n Cursor nach unten. C-p Cursor nach oben. C-a Cursor zum Zeilenanfang. C-e Cursor zum Zeilenende. M-v Seite rückwärts scrollen. C-v Seite vorwärts scrollen. C-g Ab und zu nötig, wenn nichts mehr geht. C-x C-s Datei sichern. C-h i In den Info-Reader wechseln. Sie verlassen den Modus durch die Taste q (quit) C-x C-c Emacs beenden. Zur Schreibweise der Tastenkommandos: Bei ``C-x C-f`` bleiben Sie auf der Control-Taste und drücken nacheinander die ``x`` und ``f`` Taste. Bei ``C-h t`` hingegen drücken Sie erst gemeinsam ``Control`` und ``h``, lassen dann die Tasten los und geben noch ein einzelnes ``h`` ein. Sie leiten das Kompilieren unter Emacs mit der Tastenfolge ``M-x compile`` ein. Danach werden Sie in der Statuszeile gefragt, welche Kommandozeile an ``make`` geschickt werden soll. Damit dies klappt, müssen Sie in Ihrem Arbeitsverzeichnis natürlich ein ``Makefile`` haben. Der Emacs Editor liest, während er startet, die Datei ``.emacs`` aus Ihrem Home-Verzeichnis. In dieser Datei können Sie viele Voreinstellungen für Ihre bevorzugtes Emacs Erscheinungsbild unterbringen, z.B. Syntax-Highlighting und Layout der Statuszeile. Sehen Sie sich dazu meine Einstellungen in ``~hhoegl/.emacs`` an. Emacs Tutorials * A Tutorial Introduction to GNU Emacs http://www2.lib.uchicago.edu/keith/tcl-course/emacs-tutorial.html * Xah Emacs Tutorial http://ergoemacs.org/emacs/emacs.html Der g++ Compiler ---------------- 1. Im einfachsten Fall wird der ``g++`` für eine Quelltextdatei ``demo.cc`` durch die Kommandozeile :: g++ demo.cc aufgerufen. Falls keine Fehler während der Kompilierung auftreten, wird eine Datei ``a.out`` erzeugt. Dieser Dateiname ist typisch für die meisten UNIX-Rechner. Sie können einen anderen Namen durch die ``-o`` Option wählen: :: g++ -o demo demo.cc Es ist zu empfehlen, auch die folgenden Optionen zu verwenden: :: g++ -g -Wall -pedantic -o demo demo.cc Die -g Option fügt symbolische Information an die ausführbare Datei, so dass komfortables Debuggen möglich ist. Umfangreichere Fehlermeldungen erhält man mit -Wall und -pedantic. * Mit der ``-v`` Option können Sie prüfen, welche Version des gcc/g++ Sie verwenden. Das Kommando ``g++ -v`` führt auf meinem Rechner (Djgpp unter Windows) zur folgenden Ausgabe: :: Reading specs from c:/djgpp/lib/specs gcc version 2.95.3 20010315/djgpp (release) c:/djgpp/bin/ld.exe c:/djgpp/lib/crt0.o -Lc:/djgpp/lib -Lc:/djgpp/lib/gcc-lib/djgpp/2.953 -Lc:/djgpp/bin -Lc:/djgpp/lib -lgpp -lstdcx -lm -Tdjgpp.djl -lgcc -lc -lgcc * Der C-Präprozessor, obwohl in C++ nicht empfohlen, kann doch gute Dienste leisten, wenn man längere Sequenzen in einem C oder C++ Quelltext auskommentieren will. Ein ``#if`` das als Bedingung immer ``false`` (= 0) hat, erfüllt diesen Zweck, wie in folgendem Beispiel: :: #if 0 void meine_funktion() { ... } #endif Make und das Makefile --------------------- Hier ist ein sehr einfaches Makefile (der Name dieser Datei ist ``Makefile``):: CC = g++ demo: demo.cc $(CC) -Wall -pedantic -o demo demo.cc clean: rm -f demo *.o *~ Beachten Sie nun folgenden Hinweise: * Diese Makefile beschreibt zwei *Make-Targets*, und zwar ``demo`` und ``clean``. Sie können demzufolge das ``make`` Werkzeug wie folgt aufrufen: :: make demo make clean Das erste Target ``demo`` beschreibt, wie aus der Datei ``demo.cc`` die ausführbare Datei ``demo`` gemacht wird. Hier spricht man von einer Abhängigkeit ("dependency"): ``demo`` wird aus ``demo.cc`` durch Anwenden des C++ Compilers erzeugt. Das Makro ``CC`` ist auf den Namen des C++ Compilers ``g++`` gesetzt. Bei der Verwendung eines Makros muss der Makro-Name in das $() Konstrukt gesetzt werden. In diesem Beispiel steht also ``$(CC)`` für den String ``g++``. Makros werden auch einfach als Make-Variable bezeichnet. Beachten Sie, dass immer das erste Target in einem Makefile aufgerufen wird, falls auf der Kommandozeile kein Target angegeben wird. Das zweite Target ``clean`` beschreibt, wie man das Arbeitsverzeichnis wieder "sauber machen" kann, das heisst alle vom Compiler generierten Dateien und auch Backup-Dateien (z.B. ``*~``} wieder löschen kann. *WICHTIG:* Die Zeilen mit den Aktionen sind mit einem ``TAB`` eingerückt! In unserem Beispiel ist vor dem ``$(CC)`` und vor dem ``rm`` also ein Tabulator-Zeichen. Der Emacs im Makefile-Mode überprüft diese Zeichen und meldet einen Fehler, falls an dieser Stelle kein ``TAB`` eingefügt ist. Beim Vi/Vim muss man sich vergewissern, dass auch tatsächlich ein "Hard-TAB" eingefügt wird, notfalls muss das Tabulatorzeichen mit der Tastensequenz ``C-V TAB`` erzwingen. Sie können das ``make`` Werkzeug sowohl aus dem Emacs als auch aus dem Vim aufrufen. Im Emacs geben Sie dazu ``M-x compile`` ein. Im Vim müssen Sie ``:make`` eingeben. Beide Editoren analysieren die unter Umständen vorhandene Fehlerausgabe des Compilers und zeigen dem Benutzer die Stellen im Quelltext, an denen der Compiler Fehler berichtet hat. Falls Sie ein Makefile mit einem anderen Namen als das voreingestellte ``Makefile`` verwenden möchten, dann können Sie mit der ``-f`` Option ein beliebiges File wie folgt verwenden:: :: make -f mein_makefile mein_target Der GNU Debugger gdb -------------------- Hier ist ein kleines Programm zum Ausprobieren des gdb. Sie finden es auch unter ``gdbdemo.cc`` in diesem Verzeichnis. :: // gdbdemo.cc // Kompilieren mit g++ -g -o gdbdemo gdbdemo.cc #include #include int fun1(int n) { int i = 0; while (i < n) { cout << i++ << endl; } return 0; } int main(int argc, char **argv) { int n = 4; // default loops if (argc > 1) { n = atoi(argv[1]); } fun1(n); return 0; } Sie haben dieses Programm erfolgreich mit der Option ``-g`` in ein ausführbares Programm ``gdbdemo`` kompiliert und möchten nun den GNU Debugger aufrufen. Dazu geben Sie ein: :: gdb gdbdemo Danach meldet sich der Debugger mit dem Prompt ``(gdb)``. Sie können nach dem Prompt gdb Kommandos eingeben, z.B. ``help``. Mit dem Kommando ``quit`` beenden Sie den Debugger. Die gdb Kommandozeile hat eine "History", die sie mit ``C-p`` und ``C-n`` durchwandern können. Allgemein gelten zur Navigation die Emacs Tastenkürzel -- es lohnt sich also, Emacs zu lernen! Es gibt ausserdem eine automatische Vervollständigung mit der ``TAB`` Taste. Falls Sie das Executable nicht gleich beim Start des gdb angeben, können Sie es hinterher von der gdb Kommandozeile mit dem ``file`` Kommando angeben: :: (gdb) file gdbdemo Sie können das Programm im gdb starten mit dem ``run`` Kommando: :: (gdb) run Das Programm läuft daraufhin bis zum Ende durch und Sie sehen die Ausgabe auf dem Bildschirm. Durch ein erneutes ``run`` können Sie die Ausführung wiederholen. Optional können Sie nach ``run`` noch Kommandozeilenparameter angeben. In diesem Beispiel bestimmen Sie mit einem numerischen Parameter die Anzahl der Schleifendurchläufe -- falls kein Parameter angegeben ist, dann ist der voreingestellte Wert gleich 4. Mit :: (gdb) r 12 haben Sie also 12 Durchläufe. Falls Sie in Zukunft nur ``r`` allein eingeben, also ohne weitere Option, dann merkt sich gdb die 12. Sie setzten die Kommandozeile wieder zurück mit ``set args``. Falls Sie sich nun genauer für die Funktion ``fun1`` interessieren, dann können Sie einen *Breakpoint* auf diese Funktion setzen, und zwar so: :: (gdb) break fun1 Beachten Sie, dass es "completion" mit ``TAB`` gibt. Auch break müssen Sie nicht ausschreiben sondern können es mit ``b`` abkürzen. Mit ``info breakpoints`` werden die gesetzten Breakpoints ausgegeben. Ein gesetzter Breakpoint kann mit ``clear`` gelöscht werden, in unserem Fall also mit ``clear fun1``. Informationen zu allen gesetzten Breakpoints bekommen Sie mit :: (gdb) info breakpoints Nun können Sie das Programm wieder starten mit ``run``, bzw. kurz ``r``. Es wird nun nach dem Einsprung in die Funktion ``fun1`` stoppen. Sie können nun das Programm entweder mit ``continue`` weiter bis zum Ende laufen lassen oder mit ``step`` von Zeile zu Zeile abarbeiten lassen. Das Kommando ``next`` ist ähnlich wie ``step``, läuft jedoch komplett durch auf dem Weg liegende Funktionsaufrufe hindurch. Quelltext können Sie sich übrigens mit ``list`` ausgeben lassen, z.B. ``list fun1``. Beim ``step``-pen durch das Programm können Sie mit dem ``print`` Kommando auch den Werte von Variablen ausgeben lassen, z.B. mit ``print i``, oder kurz ``p i``. Der Wert von ``i`` wird dann z.B. wie folgt ausgegeben:: $1 = 3 Das ``$1`` auf der linken Seite bezeichnet eine gdb "value history" -- nach jedem Aufruf von ``p i`` wird das n in ``$n`` um eins erhöht. Nachdem das Programm terminiert, können Sie sich den Exitcode mit dem Kommando ``print $_exitcode`` ansehen. Weitere Informationen zu gdb finden Sie in den GNU-Info Seiten zum gdb. Aus dem Emacs heraus sollte Sie die folgende Tastensequenz zu diesem Manual führen: :: C-h i m gdb [Return] Nachdem Sie den gdb auf der Kommandozeile beherrschen, können Sie sich daran machen, auch das grafische Frontend zum gdb, den ``ddd``, kennenzulernen. Veraltete Abschnitte -------------------- **Djgpp** Die Djgpp Programmierumgebung (http://www.delorie.com) ist eine Portierung von sehr vielen GNU Werkzeugen auf den x86. Man braucht mindestens eine 386er CPU und DOS -- man muss also kein modernes Windows (98, 2000, XP, etc.) installiert haben. Es stört aber auch nicht, wenn man in einer Win32 DOS-Box mit Djgpp arbeitet. Fast alle Werkzeuge, die man aus einer Unix oder Linux Umgebung kennt, kann man damit unter DOS/Windows verwenden. Zur Installation: * Von der Djgpp Website lädt man die wichtigsten Pakete der Djgpp-Version V2 herunter. Das wären: :: unzip32.exe # Zum Entpacken der nachfolgenden .zip Archive djdev203.zip # Hilfsdateien, damit Djgpp funktioniert mak375b.zip # make utility fil313b.zip # ls, cp, mv, ... bnu27b.zip # Bin utilities bsh1147b.zip # Bourne shell gcc3xxb.zip # GNU C Compiler gdb416b.zip # GNU Debugger gdb Diese Archive speichert man in einem beliebigen Verzeichnis. Die Zahlen in den Dateinamen geben die Versionen an. Achten Sie darauf, möglichst neue Version zu nehmen. * Dann legt man ein beliebiges Djgpp Wurzelverzeichnis an, oft wird einfach :: c:\\djgpp\\ verwendet. Nun wechselt man mit ``cd`` in dieses Verzeichnis und entpackt alle zip-Archive mit ``unzip32 ``. Dazu muss das Programm ``unzip32.exe`` natürlich an der Stelle liegen, an der man es auch aufruft (oder man speichert es in einem Verzeichnis, das in ``PATH`` angegeben ist). Danach hat man unter ``djgpp`` einige Unterverzeichnisse, z.B. ``bin/``, ``lib/`` und andere. * Jetzt muss man nur noch die beiden Umgebungsvariablen DJGPP und PATH setzen. Die angegebenen Pfade müssen natürlich auf die aktuell gewählten Installationspfade abgestimmt sein. Die Datei ``djgpp.env`` wird beim Entpacken von ``djdev203.zip`` angelegt. :: set DJGPP=c:\djgpp\djgpp.env set PATH=%PATH%;c:\djgpp\bin * Fertig! Nun können Sie in der DOS-Box wie unter Unix/Linux die Kommandos ls, cp, mv, gcc, as, gdb, make und so weiter verwenden. Eine grosse Erleichterung bei der Eingabe ist die ``bash`` Shell, die sich ausgezeichnet zur interaktiven Arbeit auf der Kommandozeile eignet. Von der Standard DOS-Box lässt sich das nicht gerade sagen. * Je nach Geschmack können Sie auch noch andere Pakete von der Djgpp Website herunterladen und in gewohnter Weise installieren. .. vim: et sw=4 ts=4