Crash-Kurs EMACS
Damit ich nicht immer die selben Fragen beantworten muß, sind im
folgenden die beiden Dateien zu finden, mit denen ich den EMACS
konfiguriere.
- Die erste Datei (unter Unix/Linux: .emacs,
unter NT: _emacs) wird beim Starten des EMACS gelesen (dazu
muß sie in dem Verzeichis stehen, das in der environment-Variablen
HOME hinterlegt ist).
Diese Datei ist einfach ein LISP-Programm, das beim Starten
ausgeführt wird.
Als Kommentar habe ich dort einige grundlegenden Informationen zum
EMACS untergebracht.
In dieser Konfigurationsdatei wiederum steht ein Aufruf, eine
weitere Datei mit abbreviations
zu lesen: .abbrev.
Die beiden Dateien kann man als Anregungen für eigene Anpassungen
verwenden.
In der gezeigten Form werden zwei zusätzliche Dateien benötigt:
ishl.el und filladapt.el. Entweder holt man sich diese Dateien in
einer aktuellen Version aus dem Internet, oder man kommentiert in der
.emacs die Zeilen mit filladapt und ishl aus (mit Semikolon davor).
.emacs/_emacs
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -*- Emacs-Lisp -*-;;;;;;
;;;
;;; Time-stamp: "13.10.05 14:59 .emacs klaus@wachtler.de"
;;;
;;; Beispielkonfiguration für den EMACS von
;;;
;;; Klaus Wachtler
;;; Breidingstr. 17
;;; 29614 Soltau
;;; Tel. 05191/70 2 71, 0171/45 53 039
;;; Fax: 05191/70 2 72
;;; email: Klaus@Wachtler.de
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; ///| |||\ || |||| //
;;; ////| |||\\ || |||| //
;;; ////|| ||||\\ || |||| //
;;; //// || |||| \\ || |||| //
;;; ////==|| |||| \\|| ||||//
;;; //// || |||| \\| |||//
;;; //// || |||| \| ||//
;;; |//
;;; |||| /| // // ///| ||||=====// ////=======
;;; |||| /|| // // ////| |||| // ////
;;; |||| //|| // // ////|| |||| // ////
;;; |||| // || // // //// || |||| // ////
;;; ||||// ||// // ////==|| ||||=(( ((((=======
;;; |||// |// // //// || |||| \\ \\\\
;;; |||/ |/ // //// || |||| \\ \\\\=======
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Aenderungen:
;;;
;;; 05.04.1996 kw Ergaenzungen zu c-mode-common (C und C++), Korrektur
;;; fuer diverse abbreviations
;;;
;;; 11.04.1996 kw bunte Syntax auch fuer C++
;;;
;;; 15.04.1996 kw Korrektur fuer LaTeX-em
;;;
;;; 07.06.1997 kw standard-display-european eingeschaltet
;;;
;;; 01.07.1997 kw Funktion pps definiert (gibt aktuellen Puffer mit
;;; angehaengtem .ps als buntes PS aus)
;;;
;;; 07.10.1997 kw Ergaenzungen zu fortran-mode
;;;
;;; 26.11.1997 kw Ergaenzungen zu pascal-mode
;;;
;;; 17.05.1998 kw C-7 fuer geschweifte Klammern; C-8 fuer eckige
;;;
;;; 19.05.1998 kw C-cC-i fuer indent-region
;;;
;;; 18.08.1997 kw _ soll Teil eines C-Namens sein
;;;
;;; 28.10.1998 kw je ein neues Fenster beim Aufruf über
;;; gnuclient/gnuclientw mit (setq gnuserv-frame nil)
;;;
;;; 16.11.1998 kw Etwas mehr kommentiert (für die FH-Studenten)
;;;
;;; 19.01.1999 kw copy-char-form-previous-line und
;;; copy-word-form-previous-line eingefügt (kopieren ein
;;; Zeichen/Wort aus der vorhergehenden Zeile)
;;;
;;; 14.03.1999 kw automatische Erkennung, ob NT.
;;; Nur dann wird gnuclient geladen.
;;;
;;; 07.06.2000 kw C-c M-% an query-replace-regexp gebunden, perl mode
;;;
;;; 17.08.2000 kw ishl.el
;;;
;;; 21.11.2001 kw Tabs und schließende Leerzeichen anzeigen
;;;
;;; 24.11.2001 kw Doku um Prefix und narrow erweitert
;;;
;;; 03.12.2001 kw Korrektur von for- und class-Abkürzungen aufgepeppt
;;;
;;; 10.12.2001 kw Korrektur class-Abkürzung (generiert clone(),
;;; ostream &operator<<(), und nimmt Rücksicht
;;; auf static-Elemente)
;;;
;;; 28.12.2001 kw Noch ein paar Spielereien von http://www.dotemacs.de/
;;; und http://www.dotfiles.com geklaut
;;; (z.B. mouse-avoidance-mode)
;;;
;;; 23.01.2002 kw Summenberechnen eines markierten Rechtecks mit rect-sum,
;;; Tastenbelegung kommentiert
;;;
;;; 18.02.2002 kw Die gesetzten Tastenbelegungen werden in *Messages*
;;; ausgegeben; dann kann man schnell mal nachgucken.
;;;
;;; 01.05.2002 kw Editieren über ftp
;;;
;;; 29.06.2002 kw (toggle-uniquify-buffer-names)
;;;
;;; 10.07.2002 kw kleinere Ergänzungen, Korrekturen, getestet mit
;;; EMACS 21.2 unter Windows 2000.
;;;
;;; 13.01.2005 kw Passive mode für ftp-Verbindungen
;;;
;;;
;;; nachtragen:
;;; http://ls6-www.cs.uni-dortmund.de/~grossjoh/emacs/tutorials.html
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;
;
; ***** * * *** *** ***
; * ** ** * * * * * *
; * * ** * * * * *
; **** * * ***** * *** *****
; * * * * * * *
; * * * * * * * * *
; ***** * * * * *** ***
;
;
; *** **** *** *** * * * * * * **** ***
; * * * * * * * * * * * * * * * * * *
; * * * * * * * * * * * * * * *
; * **** ***** *** ***** ** * * **** ***
; * * * * * * * * * * * * * * *
; * * * * * * * * * * * * * * * * * *
; *** * * * * *** * * * * ***** * * ***
;
;
;
; Der EMACS ist im wesentlichen ein Editor, um Texte zu editieren.
; Dazu sind etliche Kommandos definiert, um beispielsweise Dateien zu laden,
; abzuspeichern, Textstellen zu suchen/ersetzen, etc.
;
; Der Emacs unterliegt der GPL (General Public License) der FSF (Free
; Software Foundation). Das heißt, daß er
; a) im Quelltext zur Verfügung steht
; b) nichts kostet
; c) frei verwendet und weitergegeben werden kann und soll (solange die
; GPL eingehalten wird)
;
; Der EMACS kann auf allen gängigen Systemen (MS-DOS, Windows, NT, 95,
; Linux, alle Unix, VMS, Mac, Atari TOS/GEM) installiert werden.
;
; Je nach Umgebung kann er sowohl auf einfachen Terminals als auch in
; eine Fensteroberfläche eingebunden verwendet werden.
;
; Unter einer Fensteroberfläche existiert eine Menüleiste, über die man
; die wichtigtsen Befehle erreicht. Für erste Übungen kann man damit
; leben.
;
; Am effektivsten wird der EMACS aber über Tastaturkommandos gesteuert.
; Während die üblichen (druckbaren) Zeichen meistens als einzugebender
; Text interpretiert wird, bestehen die EMACS-Kommandos weitgehend aus
; Tastenkombinationen mit der Control-Taste und der Meta-Taste.
;
; Da diese Kommandos eine gewisse Gewöhnung benötigen, ist der Einstieg
; etwas zäh. Dafür muß man diese Kommandos nur einmal lernen, egal auf
; welchem System und unter welcher Oberfläche man damit
; arbeitet. Zumindest wenn man im Lauf seiner Karriere mehrmals die
; Betriebssystemumgebung wechselt, spart man sich sehr viel
; Eingewöhnungszeit. Zudem ist der EMACS verblüffend leistungsfähig, so
; daß man oft mehrere andere Programme damit ersetzen kann.
;
; Da der EMACS sehr weitgehend konfigurierbar ist, kann man auch
; spezielle Anpassungen so bauen, daß sie über alle Rechnergrenzen
; hinweg funktionieren.
;
; Die Control-Taste ist das, was auf der deutschen Tastatur mit "Strg"
; beschriftet ist.
; In der gesamten EMACS-Dokumentation werden Tastenkombinationen mit der
; Control-Taste mit den Zeichen "C-" vor dem zugehörigen Buchstaben
; bezeichnet. Beispiel:
; C-x C-f (öffnet eine Datei zum Editieren)
; Das ist so einzugeben: während die [Strg]-Taste gedrückt ist, muß man
; die [x]-Taste drücken, und dann (immer noch bei gedrückter
; [Strg]-Taste) die [f]-Taste. In diesem Beispiel erscheint dann in der
; untersten Zeile die Aufforderung, den gewünschten Dateinamen
; einzugeben.
;
; Man sollte im Auge behalten, daß bei einer Tastenfolge bei jeder
; einzelnen Taste vorgegeben ist, ob sie mit oder ohne [Ctrl] gedrückt
; werden muß. Deshalb sind C-x C-s (Speichern des aktuellen buffer) und
; C-x s (Speichern aller buffer) zwei interschiedliche Kommandos!
;
; Die Meta-Taste (in der Dokumentation mit "M-" bezeichnet) dagegen
; existiert als solche nicht auf einem einfachen
; Terminal; je nach verwendetem System ist dafür etwas anderes
; einzugeben. Auf fast jeder aktuellen Tastatur gibt es eine
; [Esc]-Taste. Anstatt der fiktiven Meta-Taste tippt man vor dem
; jeweilgen Zeichen dann einmal die [Esc]-Taste. Bei vielen Systemen ist
; zusätzlich die [Alt]-Taste als Meta-Taste konfiguriert.
; Beispielsweise kann man mit M-% das "Suchen und Ersetzen" starten.
; Dazu muß man dann entweder
; a) die [Esc]-Taste drücken, dann "%" (also [Shift]+[5]), oder
; b) -wenn es so eingerichtet ist- die [Alt]-Taste drücken, und gedrückt
; lassen, dann die "%"-Taste (also [Shift]+[5]), dann die [Alt]-Taste
; loslassen.
;
;
;
; buffer, window, frame
; #####################
;
;
; Wenn man mehrere Dateien gleichzeitig editieren will, muß man dazu den
; EMACS nur einmal auf dem Rechner laufen lassen. Jede Dateikopie, die
; im Speicher editiert wird, ist ein "buffer".
;
; Die Anzahl der Buffer ist dabei unabhängig von der Anzahl der
; sichtbaren Fenster. Das kommt daher, daß der EMACS ursprünglich für
; die Bedienung an Terminals gedacht war, wo es Fenster im Sinne von
; Windows/X-Windows nicht gibt.
; An einem Terminal hat man meistens dann nur einen buffer im Blick,
; obwohl der EMACS eventuell mehrere buffer geöffnet hat. Mit C-x b kann
; man dann von einem buffer zu einem anderen umschalten.
; Der Bildschirm sieht dann etwa so aus:
;
; +--------------------------------------------------------------+
; |#include |
; |_ |
; |int main() |
; |{ |
; | int i; |
; | |
; | for( i=0; i<10; i++ ) printf( "i ist %d\n", i ); |
; | |
; | return 0; |
; |} |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; | |
; |-\** t.cpp 10:04 (C++ Abbrev)--L2--C1--20%-----------|
; | |
; +--------------------------------------------------------------+
;
; Der größte Bereich ist der zu editierende Text.
;
; Die vorletzte Zeile ist eine Statuszeile, in der einige Informationen
; ausgegeben werden:
; Die beiden Sternchen hinter dem "-\" zeigen an, daß der aktuelle
; buffer geändert wurde, und die Änderungen noch nicht in die zugehörige
; Datei zurückgeschrieben wurden (also der buffer noch nicht gespeichert
; ist).
; Dahinter steht der Name des buffers, das ist meistens der Name der
; entsprechenden Datei. Werden mehrere Dateien mit unterschiedlichen
; Pfaden, aber gleichen Namen geöffnet, dann werden ab der zweiten
; solchen Datei an den buffer-Namen noch "<2>", "<3>" etc. angehängt.
; Die restliche Statuszeile ist teilweise abhängig davon, wie der EMACS
; konfiguriert ist: Die Uhrzeit, dann in Klammern der aktuelle
; Hauptmodus (hier C++), evtl. gefolgt von Untermodi (hier Abbrev), dann
; Zeilen- und Spaltennummer, und eine prozentuale Angabe der Position im
; Text.
;
; Für jeden Modus können unabhängig von anderen Modi bestimmte
; Einstellungen vorgenommen werden. Beispielsweise unterscheiden sich
; der "fortran-mode" und der "c-mode" in der Syntax, nach der
; Einrückungen vorgenommen werden. Jetzt kann gleichzeitig ein buffer
; mit einem Fortran-Quelltext geöffnet sein, und ein anderer mit einem
; C-Quelltext. Solange man den einen buffer bearbeitet, verhält sich
; der EMACS anders, als nach dem Wechsel zu dem buffer mit dem
; C-Quelltext.
;
; Die letzte Zeile des Bildschirms, also die Zeile unter der
; Statuszeile, ist der sogenannte "mini buffer", der für
; Kommandoeingaben verwendet wird.
; Um ein Kommando aufzurufen, das nicht direkt über eine
; Tastenkombination erreichbar ist, muß man den Kommandonamen kennen.
; Beispelsweise kann man mit Kommandos wie "c-mode", "c++-mode",
; "text-mode" etc. zwischen den verschiedenen Hauptmodi wechseln.
;
; Ist man im mini buffer, hat man folgende Kommandos:
; [Tab]-Taste: vervollständigen, soweit möglich
; [ ]-Taste: nur ein Wort vervollständigen
; [Ret]-Taste: vervollständigen, und ausführen
; [?]-Taste: Möglichkeiten (zum Vervollständigen) anzeigen
; M-p: letzte Eingabe holen
; M-n: nächste Eingabe holen
; (und weitere).
;
; Um ein solches Kommando einzugeben, muß man vorher M-x drücken. Um
; also von irgendeinem Modus in den Textmodus zu wechseln, tippt man:
; [Esc]-Taste [x]-Taste [t]-Taste [e]-Taste [x]-Taste [t]-Taste
; [-]-Taste [m]-Taste [o]-Taste [d]-Taste [e]-Taste [Return]-Taste
; , oder kürzer geschrieben:
; M-x text-mode
;
; Soviel zum Umgang mit einem Fenster.
;
; Leider werden die Bezeichnungen beim Umgang mit mehreren Fenstern
; etwas verwirrend. Da es den EMACS schon länger
; gibt, als die fensterorientierten Benutzeroberflächen, hatte damals
; niemand ein schlechtes Gewissen dabei, den Begriff "window" für etwas
; zu verwenden, was kein Fenster im Sinne von MS-Windows oder X-Windows
; ist. Vielmehr versteht der EMACS unter "window" einen Teil seines
; Bildschirms, also auf einem Terminal einen Teil der
; Bildschirmfläche. Verwendet man den EMACS auf einem System mit
; grafischer Benutzeroberfläche, dann entspricht der Terminalbildschirm
; einem Fenster der Benutzeroberfläche, und das kann nun mal im Sinne
; von EMACS in mehrere windows geteilt sein.
;
; Der gesamte Bildschirm eines Terminals, beziehungsweise ein Fenster im
; Sinne der Benutzeroberfläche, heißt für den EMACS "frame".
;
;
; Mit dem Kommando C-x 2 kann man den aktuellen "frame" in zwei (EMACS-)
; windows unterteilen. Auf einem Terminal könnte das so aussehen:
;
; +--------------------------------------------------------------+
; |#include |
; |_ |
; |int main() |
; |{ |
; | int i; |
; | |
; | for( i=0; i<10; i++ ) printf( "i ist %d\n", i ); |
; | |
; | return 0; |
; |} |
; | |
; |-\** t.cpp 10:04 (C++ Abbrev)--L2--C1--20%-----------|
; |#include |
; |_ |
; |int main() |
; |{ |
; | int i; |
; | |
; | for( i=0; i<10; i++ ) printf( "i ist %d\n", i ); |
; | |
; | return 0; |
; |} |
; | |
; |-\** t.cpp 10:04 (C++ Abbrev)--L2--C1--20%-----------|
; | |
; +--------------------------------------------------------------+
;
; Dadurch hat man zwei Ansichten auf ein und denselben buffer. Editiert
; man in einem der beiden (EMACS-) Fenster, dann wirkt sich das auch auf
; den Inhalt des anderen aus.
; Mit C-x o kann man zwischen den beiden (EMACS-) Fenstern wechseln, so
; daß man beispielsweise zwei Abschnitte einer Datei leicht im Wechsel
; bearbeiten kann. Je nach Bedarf kann man auch zwei verschiedene
; Dateien in die (EMACS-) Fenster laden, und so beim Editieren schnell
; zwischen den Dateien (besser gesagt: deren buffer) springen.
; (Unter einer grafischen Benutzeroberfläche kann man zum Wechseln
; des aktiven window auch einfach in das gewünschte klicken; dann
; wird dort der Cursor positioniert.)
;
; Mit C-x 1 kann man das aktuelle (EMACAS-) window zum einzigen in
; diesem frame machen (also auf maximale Größe bringen).
;
; Ein frame kann also einen oder mehrere (EMACS-) Fenster
; beinhalten. Zudem kann unter einer grafischen Benutzeroberfläche ein
; laufender EMACS auch beliebig viele frames (also Fenster im Sinne der
; Benutzeroberfläche) öffnen, in denen jeweils eines oder mehrere
; (EMACS-) Fenster zu sehen sind. In den (EMACS-) Fenstern können nun
; lauter unterschiedliche Datei-buffer erscheinen, oder solche buffer
; können auch mehrfach sichtbar sein.
;
; Soweit (EMACS-) Fenster und frames (Fenster im Sinne der Oberfläche)
; ähnliche Funktionen haben, sind auch die Kommandos ähnlich.
; (Emacs-) Fenster-Befehle lauten immer "C-x irgendwas", während die
; entsprechenden Befehle für frames "C-x 5 irgendwas" lauten.
; Beispiel:
; C-x 2 teilt das aktuelle (EMACS-) Fenster in zwei auf, wobei
; beide anfangs den gleichen buffer an derselben Stelle
; darstellen.
; C-x 5 2 öffnet ein neues frame, wobei das alte und das neue
; frame anfangs den gleichen buffer an derselben Stelle
; darstellen.
;
; Mit C-x o kann man zwischen den (Emacs-) Fenstern eines frames
; springen, mit C-x 5 o zwischen den frames.
;
; Mit C-x 0 kann man ein (EMACS-) Fenster schließen; der freigewordene
; Bildschirmbereich wird von dem/den anderen Fenster(n) belegt.
; C-x 5 0 schließt ein frame.
;
;
; Im folgenden Beispiel sind zwei frames offen. Der hintere frame
; (rechts unten, teilweise verdeckt) zeigt den buffer t.cpp; der Cursor
; steht hier gerade in Zeile 8 und Spalte 1.
; Das vordere frame dagegen ist in zwei (EMACS-) Fenster aufgeteilt. Das
; untere stellt ebenfalls den buffer t.cpp darf, steht aber gerade an
; einer anderen Stelle. Das obere Fenster des vorderen frames zeigt
; einen anderen buffer, nämlich test.txt:
;
; +--------------------------------------------------------------+
; | * test.txt_________________________________________________#X|
; | Buffers Files Tools Edit Search Help |
; +--------------------------------------------------------------+
; |Wuff, wuff, meine Name ist Rex! |^|
; |Wuff, wuff, meine Name ist Rex! | |
; |Wuff, wuff, meine Name ist Rex! | |
; |Wuff, wuff, meine Name ist Rex! | |
; |Wuff, wuff, meine Name ist Rex!_ | |-----------+
; | | |_________#X|
; | | | |
; | | |-----------+
; | |-| |^|
; | | | | |
; | |v| | |
; |-\** test.txt 10:04 (Text Fill)---L5--32--100%--------|-| | |
; |#include |^| | |
; |_ | | | |
; |int main() | | | |
; |{ | | | |
; | int i; | | | |
; | | | | |
; | for( i=0; i<10; i++ ) printf( "i ist %d\n", i ); | | | |
; | | | | |
; | return 0; |-| | |
; |} | | | |
; | |v| | |
; |-\** t.cpp 10:04 (C++ Abbrev)--L2--C1--20%---------|-| | |
; | | | | |
; +--------------------------------------------------------------+ | |
; | | |
; | |v|
; |-\** t.cpp 10:04 (C++ Abbrev)--L8--C1--20%---------|-|
; | | |
; +--------------------------------------------------------------+
;
; Bewaffnet mit diesem Grundwissen sollte man die grundlegenden
; Kommandos auf der "EMACS Reference card" verwenden können.
; Diese ist hoffentlich bei jeder EMACS-Installation als
; Postscript-Datei (refcard.ps) mit dabei.
;
;
; Selektieren
; ###########
;
; Etwas gewöhnungsbedürftig ist das Markieren (Selektieren) von Text.
; Dazu geht man zum einen Ende des zu markierenden Bereichs. Dort drückt
; man C-Leertaste. Dann geht man mit dem Cursor an das andere Ende des
; Bereichs. Der Cursor ist immer ein Ende des selektierten
; Bereichs.
; Alternativ kann man je nach Benutzeroberfläche auch mit der Maus
; markieren, indem man die linke Taste gedrückt hält. Oder man klickt
; mit der linken Maustaste an das eine Ende des zu markierenden
; Bereichs, und mit der rechten an das andere Ende.
; Mit einem Klick mit der mittleren Maustaste (falls vorhanden) kann man
; den markierten Bereich an eine beliebigen Stelle kopieren.
;
; Die Stelle im Text, an der gerade eine Eingabe eingefügt wird (also
; üblicherweise "Cursor" genannt) heißt beim EMACS "point".
; Die Stelle, die man mit C-space markiert hat, heißt "mark".
; Der markierte Bereich (die "region") erstreckt sich also von mark
; zum point.
;
;
; Makros
; ######
;
; Man kann mit
; C-x (
; eine Makroaufzeichnung starten. Dabei wird alles in einem Makro
; gemerkt, bis man
; C-x )
; tippt. Dieses Makro kann dann jederzeit mit
; C-x e
; ausgeführt werden.
;
; An ein bereits definiertes Makro kann man auch noch etwas anhängen mit
; C-u C-x (
; Dadurch wird das bereits definierte Makro ausgeführt, und jede weitere
; Eingabe bis zum nächsten C-x ) aufgezeichnet und angehängt.
;
; Ganz praktisch ist gelegentlich das Kommando
; M-x apply-macro-to-region-lines
; Damit wird ein aufgezeichnetes Makro auf jede Zeile des gerade
; markierten Bereichs angewandt.
;
;
; Argumente:
; ##########
;
; Manche Kommandos benötigen ein Argument. Das ist eine ganze Zahl, die
; man mit M- beziehungsweise nach einem [Esc], und vor dem eigentlichen
; Kommando eingeben kann.
;
; Die meisten Kommandos benötigen kein Argument, und verwenden ein
; trotzdem eingegebenes Argument als Wiederholungsfaktor.
; Beispielsweise kann man mit der Tastenfolge
; M-1 2 #
; zwölfmal das Zeichen "#" einfügen.
; M-2 5 C-x e
; führt das zuletzt aufgezeichnete Makro 25 mal aus.
;
; Dann gibt es weiterhin ein "prefix", das kein Argument mit einem
; konkreten Wert ist, aber trotzdem existieren kann.
; Dieses Präfix kann man durch Drücken von C-u vor dem eigentlichen
; Kommando eingeben. Manche Kommandos verhalten sich dann daraufhin
; anders; beispielsweise kann man in C-Programmen mit C-c C-c einen
; markierten BEreich auskommentieren, dagegegn mit C-u C-c C-c die
; Kommentarzeichen von einem auskommentierten Bereich wieder
; entfernen.
;
;
; Narrow, widen
; #############
;
; Man kann bei Bedarf die Sichtbarkeit aller Aktionen auf einen Teil
; eines buffers begrenzen.
; Dann werden alle Operationen wie Suchen, Ersetzen, jedes Umformatieren
; etc. nur in diesem begrenzten Teil stattfinden.
; Den buffer derart zu begrenzen heißt "narrow" (narrow-to-region, C-x n n,
; oder narrow-to-page C-x n p, oder narrow-to-defun C-x n d),
;
; Das Erweitern zurück auf den gesamten buffer heißt "widen" (widen,
; C-x n w).
;
; Bei narrow-to-region wird der aktuell als "region" markierte Teil als
; verbleibender Bereich verwendet, bei narrow-to-page der aktuelle
; Inhalt des Bildschirmfensters (meist ist dieses Kommando aber
; inaktiv). Bei narrow-to-defun ist es vom aktuellen Modus abhängig,
; welcher Bereich verwendet wird. Im lisp-mode ist es die umgebende
; Funktionsdefinition, in C oder C++ dagegen der äußerste umgebende
; Block, als der Rumpf der aktuellen Funktion oder der aktuellen Klasse,
; je nachdem wo der Cursor (in EMACS "point" genannt) gerade steht.
;
;
; Die wichtigsten Kommandos auf einen Blick
; #########################################
;
; Die folgende Tabelle ist i.w. ein Auszug aus refcard.ps.
;
; -------------+------------------------------------------------------------
; |
; C-z | EMACS in den Hintergrund bringen/Icon
; |
; C-x C-c | beenden (wenn noch Puffer offen sind, wird man gefragt,
; | ob man sie nicht speichern möchte)
; |
; C-x C-f | Datei öffnen (in neuen buffer einlesen)
; |
; C-x C-s | buffer in der zugehörigen Datei speichern
; C-x s | alle buffer speichern
; C-x C-w | buffer unter neuem Namen speichern (save as...)
; |
; C-x i | am Cursor eine andere Datei einfügen
; |
; C-x 0 | das aktuelle (EMACS-) window verschwindet, andere
; | belegen den Platz im frame
; C-x 1 | das aktuelle (EMACS-) window wird zum einzigen im frame,
; | und erhält den ganzen Platz im frame.
; C-x o | zu einem anderen (EMACS-) window im gleichen frame springen
; |
; C-_ | Undo (mehrfach möglich, geht ziemlich weit zurück)
; |
; C-g | ein begonnenes Kommando abbrechen
; |
; C-s | inkrementelles Suchen vorwärts
; C-r | dto. rückwärts
; |
; C-M-s | Suche nach regulärem Ausdruck vorwärts
; C-M-r | dto. rückwärts
; M-p | (bei der Eingabe des Suchstrings:) den letzten String nehmen
; M-n | dto. den nächsten
; |
; C-b | ein Zeichen rückwärts/nach links (backward)
; C-f | ein Zeichen vorwärts/nach rechts (forward)
; M-b | ein Wort rückwärts/nach links
; M-f | ein Wort vorwärts/nach rechts
; C-M-b | eine Zeile rückwärts/nach oben
; C-M-f | eine Zeile vorwärts/nach unten
; |
; C-a | zum Start der Zeile
; C-e | zum Ende der Zeile
; M-a | zum Anfang des Satzes/Ausdrucks
; M-e | zum Ende des Satzes/Ausdrucks
; C-M-a | zum Anfang des sexp (syntactical expression)
; C-M-e | zum Ende des sexp (syntactical expression)
; M-< | zum Anfang des buffer
; M-> | zum Ende des buffer
; C-v | Seite vorwärts
; M-v | Seite rückwärts
; C-l | aktuelle Zeile mittig in Fenster, Bildschirm komplett
; | neu aufbauen
; |
; C-d | ein Zeichen löschen
; M-d | Wort löschen
; M-0 C-k | Zeile bis Cursor löschen
; C-k | Zeile ab Cursor löschen
; C-M-k | sexp löschen
; M-k | Satz/Ausdruck löschen
; C-w | markierten Bereich löschen und in Puffer (unter Windows:
; | auch in Clipboard) kopieren
; M-w | markierten Bereich in Puffer (unter Windows: auch in
; | Clipboard) kopieren
; C-y | letzten Inhalt aus dem Puffer wieder am Cursor einfügen
; |
; C-Leertaste | aktuelle Stelle als Blockanfang merken
; |
; C-x C-x | Blockanfang und Cursor tauschen
; |
; M-% | Suchen und ersetzen (wenn man dabei reguläre Ausdrücke
; | verwenden will, muß man tippen:
; | M-x query-replace-regexp
; | Bei jedem Vorkommen des zu ersetzenden Textes hat man
; | folgende Möglichkeiten:
; | Leertaste: Ersetzen, und weitergehen
; | [,]-Taste: Ersetzen, nicht mehr weitergehen
; | [Del]-Taste: Nicht ersetzen, aber weitergehen
; | [!]-Taste: Dieses, und alle weiteren ersetzen
; | [^]-Taste: Das letzte Ersetzen rückgängig machen
; | [Return] : Fertig
; |
; [Tab]-Taste | je nach Modus richtig einrücken
; C-x [Tab] | alle Zeilen im markierten Bereich um (Argument)
; | Spalten nach rechts einrücken (wenn Argument>0)
; | bzw. nach links.
; |
; M-u | Das folgende Wort in Großbuchstaben verwandeln
; M-l | dto. in Kleinbuchstaben
; M-c | Den nächsten Buchstaben groß, Rest des Wortes klein
; C-x u | markierten Bereich in Großbuchstaben
; C-x l | dto. in Kleinbuchstaben
; |
; C-x b | anderen buffer wählen
; C-x C-b | alle buffer in einem (EMACS-) window listen
; | (Auswählen eines buffers mit mittlerer Maustaste)
; C-x k | buffer löschen
; |
; C-t | zwei Zeichen vertauschen (das unter dem Cursor, und
; | das davor).
; | Wenn unter dem Cursor kein Zeichen ist, weil man am
; | Ende der Zeile ist, dann halt die zwei Zeichen vor
; | dem Cursor.
; M-t | Zwei Worte vertauschen
; C-x C-t | Zwei Zeilen vertauschen
; C-M-t | Zwei sexp vertauschen
; |
; C-x r k | (markiertes) Rechteck löschen und merken
; C-x r y | gemerktes Rechteck an Cursor einfügen
; C-x r r | (markiertes) Rechteck in Register kopieren
; | (Nach dem Befehl ist ein Zeichen anzugeben, das ist
; | der Name des Registers)
; C-x r i | Inhalt des Registers einfügen (nach dem Befehl
; | ist wieder das Zeichen des Registers beim Abspeichern
; | anzugeben)
; | NB: In Registern kann man nicht nur Rechtecke,
; | sondern auch andere Dinge speichern (Fenster-
; | konfigurationen, Textausschnitte, Cursorpositionen
; | etc.; siehe Doku).
; C-x r o | Rechteck nach rechts schieben
; C-x r c | Rechteck löschen
; |
; C-x ( | Start einer Makroaufzeichnung
; C-x ) | Ende der Makroaufzeichnung
; C-x e | Makro ausführen
; C-u C-x e | Makro ausführen, und weitere Kommandos aufzeichnen
; | (bis wieder ein C-x ) kommt.
; | Das neue Makro enthält alles aus dem bisherigen,
; | plus das neu aufgezeichnete.
; |
; | Mit
; | M-x name-last-kbd-macro
; | kann man einem Makro einen Namen geben.
; | Mit
; | M-x insert-kbd-macro
; | kann man im aktuellen buffer den LISP-Code zu
; | einem Makro einfügen (z.b., um es dann auszuschneiden
; | und in der Initialisierungsdatei zu hinterlegen).
; | Ein benamstes Makro kann man mit
; | M-x name
; | wieder ausführen.
; |
;
;
; FTP-Adressen
; ############
;
; Als Dateiname (beispielsweise zum Öffnen einer Datei mit C-x C-f)
; kann man auch eine ftp-Adresse angeben, falls auf dem entsprechenden
; Rechner ein ftp-Server läuft und man eine Zugangsberechtigung hat.
; Wenn ich eben mal in einer HTML-Datei meiner Homepage, die von
; einem Provider gehostet wird, etas ändern will, dann kann ich diese
; Datei direkt vom EMACS aus öffnen:
; C-x C-f /ftp31331@www.wachtler.de:/www.wachtler.de/index.html
; Das Schema einer solchen Datei ist:
; /username@rechnername:/pfad/zur/datei
; Nach einem [Return] wird man nach dem Passwort gefragt, der EMACS holt
; sich die Datei per ftp, und man kann fröhlich darin editieren.
; Bei jedem Abspeichern wird der aktuelle Inhalt dann wieder per ftp
; zurückgeschrieben.
;
;
; Debuggen
; ########
;
; Mit M-x gdb kann man den gdb aufrufen zum Debuggen eines
; kompilierten Programms.
; Dazu wird ein neues Fenster geöffnet (kein frame!), in dem man die
; gdb-Kommandos eingeben kann (das ist das GUD-Fenster).
; Als Abkürzung kann man im GUD-Fenster einige Kommandos
; mit C-c... eingeben, oder mit C-x C-a... in jedem Fenster.
; Das was nach C-c bzw. nach C-x C-a kommt, ist jeweils gleich:
;
; -------------+------------------------------------------------------------
; |
; C-c C-l | display last line referred to in another window
; C-x C-a C-l |
; |
; C-c C-s | step (zur nächsten Quelltextzeile gehen, ggf. in
; C-x C-a C-s | einer aufgerufenen Funktion)
; |
; C-c C-n | next (wie step, aber nur in der aktuellen Funktion
; C-x C-a C-n | oder beim Aufrufer)
; |
; C-c C-i | step instruction (einen Maschinenbefehl weitergehen)
; C-x C-a C-i |
; |
; C-c C-r | continue (laufe bis zum nächsten break point, oder
; C-x C-a C-r | Signal, oder Programmende)
; |
; C-c C-d | delete break point on current line
; C-x C-a C-d |
; |
; C-c C-t | set break point on current line
; C-x C-a C-t |
; |
; C-c C-f | finish (run program until selected stack frame
; C-x C-a C-f | returns)
; |
; C-c C-< | up (select next enclosing stack frame)
; C-x C-a C-< |
; |
; C-c C-> | down (select next inner stack frame)
; C-x C-a C-> |
; |
;
; Zudem kann man mit C- (also Ctrl und Leertaste) an der aktuellen
; Stelle einen break point setzen.
;
;
; LISP
; ####
;
; Etwas anspruchsvoller ist es, den EMACS gezielt anzupassen. Da der
; EMACS eigentlich nur ein LISP-Interpreter ist, der mit entsprechenden
; LISP-Programmen erst zum Editor wird, kann man eigene Anpassungen
; vornehmen, indem man LISP-Funktionen schreibt, und diese an passenden
; Stellen aufruft.
;
; Einige kleinere Anpassungen kann man direkt mit EMACS-Kommandos
; vornehmen (z.B. Definition von Makros, oder Ändern der
; Tastaturbelegung). Auf Dauer kommt man aber an einem Minimum
; LISP-Wissen nicht vorbei. Dies beginnt schon bei der
; Initialisierungsdatei, mit der jeder Benutzer sich "seinen" EMACS
; basteln kann. Diese Datei (auf Unix-Systemen .emacs, in der DOS-Welt
; _emacs) ist nichts anderes als LISP-Code.
; Die hier vorliegende Datei ist in Beispiel für eine solche
; Initialisierungsdatei.
;
;
;
; Weitere Unterlagen
; ##################
;
;
; a) GNU Emacs Manual (ca. 200 Seiten, über ftp: emacs-manual-6_0_dvi.gz)
; b) Einführung in EMACS LISP (ca. 250 Seiten, emacs-lisp-intro_1_05_tar.gz)
; c) EMACS LISP Referenz (ca. 900 Seiten, elisp-manual-20-2_5_tar.gz)
; d) NT-Emacs-FAQ
; e) info (online)
; f) Von O'Reilly gibt es ein Buch über den GNU-Emacs
; ... und tausend andere
;
; Das GNU Emacs Manual paßt zur nicht mehr aktuellen Version 19. Derzeit
; im Umlauf ist die Version 21. Der Inhalt des Buches ist nicht
; falsch, aber inzwischen etwas unvollständig.
;
;
; Bei neueren Versionen hat sich insbesondere die Anpassung an
; Benutzervorstellungen vereinfacht: Man kann Anpassungen teilweise vom
; EMACS direkt in der Initialisierungsdatei vornehmen zu lassen, ohne
; von Hand den LSIP-Code ändern zu müssen.
;
; Die jeweils aktuelle Version ist im EMACS selbst dokumentiert, in Form
; sogenannter info-Dateien. Diese können im EMACS direkt gelesen werden
; (C-h i), oder mit TeX in eine druckbare Form gebracht werden. Es gibt
; auch andere Programme, um die Dateien online anzuzeigen (info, xinfo,
; tkinfo, ...).
;
;
;
; Zu den hier verwendeten LISP-Befehlen
; #####################################
;
;
; Mit
; (setq variablenname wert)
; kann man einer (evtl. neuen) Variable einen Wert zuweisen.
; Der Typ der Variable ergibt sich dabei aus der Zuweisung.
;
; Mit
; (setq-default variablenname wert)
; kann man einer Variable, die in verschiedenen Modi (C, C++, Text, ...)
; vorkommen kann, einen Standarwert geben. Dieser Wert wird dann als
; Anfangswert genommen, wenn DANACH ein Puffer in einen anderen Modus
; übergeht (also beispielsweise eine neue Datei geladen wird).
; Mit
; (global-set-key "Tastenkombination" 'funktionsname)
; kann man einer Tastenkombination einen Funktionsaufruf zuordnen.
; Diese Einstellung gilt dann für alle Modi, die nicht selbst diese
; Kombination übersteuern (daher "global").
; Der Apostroph vor dem Funktiosnanmen bewirkt, daß hier nicht die
; Funktion aufgerufen wird, und ihr Ergebnis an global-set-key
; übergeben würde.
; Da viele Erweiterungspakete für den Emacs existieren und ständig
; neue entstehen, sollte man etwas darauf achten, welche
; Tastenkombinationen man sich selbst definiert, um nicht mit bereits
; existierenden oder noch auftauchenden Kommandos zu kollidieren.
; Recht gefahrlos ist die Verwendung von Tastenkombinationen, die mit
; C-c (also Strg+c) beginnen. Denn diese sind für privaten Gebrauch
; reserviert.
; Wenn man also eigene Kommandos auf Tastatutkombinationen legen möchte,
; guckt man am besten nach, ob eine Wunschkombination noch frei ist, die
; mit C-c beginnt.
; Das kann man mit M-x describe-variable machen.
;
;
; Wenn der EMACS in einen neuen Modus wechselt (beispielsweise in
; den c-mode), dann werden alle Funktionen einer dafür vorgesehenen
; Liste abgearbeitet.
; Mit einem Aufruf von add-hook wird an eine solche Liste eine eigene
; Funktion angehängt.
; Für jeden Modus existiert eine solche Liste.
; Man könnte also mit
; (add-hook 'c-mode-hook 'meine-funktion-fuer-c-mode)
; eine solche Funktion für den c-mode anhängen.
; Da für C und C++ viele Dinge gleich sind, gibt es einen
; c-mode-common-hook, der wowohl für c-mode als auch für c++-mode
; verwendet wird.
;
;
;
; Informationen und Literatur
; ###########################
;
; Zum EMACS gibt es natürlich Literatur bis zum Abwinken.
;
; Die wichtigsten Dokus sind:
;
; - dieser Text :-))
;
; - GNU-EMACS-Howto (im EMACS mit C-h F zu erreichen, oder
; - beispielsweise von
; ftp://ftp.uni-paderborn.de/pub/doc/FAQ/comp/emacs/)
; - oder bei Linux gleich mit dabei
;
; - GNU-EMACS FAQ for Windows 95/98/ME/NT/XP and 2000
;
; - GNU EMACS Manual (Richard M. Stallman)
; - http://www.gnu.org/manual/emacs/ps/emacs.ps.gz (Postscript)
; - http://www.gnu.org/manual/emacs/index.html (HTML)
; - oder bei Linux gleich mit dabei
;
; - Emacs Lisp Reference Manual
; - http://www.gnu.org/manual/elisp-manual-21-2.6/elisp.html (HTML)
; - ftp://ftp.gnu.org/pub/gnu/emacs/elisp-manual-21-2.6.tar.gz (Info)
; - oder bei Linux gleich mit dabei
;
; - Programming in EMACS LISP
; An Introduction
; (elispint.ps beispielsweise)
;
; - Die eingebauten Hilfen (C-h C-f für jede Funktion, C-h F für die
; FAQ, C-h i oder M-x info zum Lesen von Dateien im Info-Format,
; C-h v zum Anzeigen der Beschreibung und des Werts jeder Variable,
; usw.)
;
; - http://www.dotemacs.de/
;
; - http://tiny-tools.sourceforge.net/emacs-keys.html
;
; - http://www.dotfiles.com
;
; - NT-EMACS: http://www.gnu.org/software/emacs/windows/ntemacs.html
;
; - http://wonderworks.com/
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Meine momentane Tastenbelegung:
; F1 Vervollständigen eines angefangenen Worts
; F2 springt zwischen öffnender und schießender Klammer hin und her
; F3 fügt das Datum an der Cursorposition ein
; S-F3 wie F3, aber zusätzlich mit Uhrzeit
; F4 addiert alle Zahlen in einem markierten Rechteck
; F5 fügt "Mit freundlichen Grüßen, Klaus Wachtler" ein
; S-F5 fügt "Viele Grüße, Klaus Wachtler" ein
; F6 step instruction in gdb
; F7 step in gdb
; F8 next in gdb
; F9 cont in gdb
; F12 in C/C++: Einfügen von "->"
; in TeX: markierten Bereich in ein \index{} hineinkopieren
; C-c C-i markierten Bereich richtig einrücken (indent-region)
; C-7 Einfügen von "{}"
; C-8 Einfügen von "[]"
; M-, ein Zeichen aus der Zeile drüber kopieren
; M-; ein Wort aus der Zeile drüber kopieren
; C-c _ undo (weil das dafür vorgesehene C-_ unter Windows zumindest
; früher nicht ging)
(global-set-key [f1] 'dabbrev-expand)
(message "F1 gesetzt: dynamische Abkuerzung einfuegen")
; load-path um einen Eintrag ergänzen, der ins Homeverzeichnis zeigt:
(setq load-path (cons "~/.elisp" load-path))
;;;;
;;;; Mit [F2] zwischen öffnenden und schließenden Klammern springen:
;;;;
;;
;; Here's my take on it:
;;
(defun joc-bounce-sexp ()
"Will bounce between matching parens "[{(<" && ">)}]" just like % in vi"
(interactive)
(let ((prev-char (char-to-string (preceding-char)))
(next-char (char-to-string (following-char)))
)
(cond ((string-match "[[{(<]" next-char) (forward-sexp 1))
((string-match "[]})>]" prev-char) (backward-sexp 1))
(t (error "%s" "Not on a paren, brace, or bracket"))
)
)
)
;; ----- bounce back & forth between matching parens, braces or brackets -----
(global-set-key [f2] 'joc-bounce-sexp)
(message "F2 gesetzt: zwischen oeffnender und schliessender Klammer springen")
;;
;; I'm not quite sure I'm using the word sexp right, but the function works....
;; Regards,
;; joe
;; joc@netaxs.com
;insert date into buffer
(defun insert-date ()
"Insert date at point."
(interactive)
;(insert (format-time-string "%a %b %e, %Y %l:%M %p"))
(insert (format-time-string "%02e.%02m.%Y"))
)
;insert date into buffer
(defun insert-date-time ()
"Insert date at point."
(interactive)
;(insert (format-time-string "%a %b %e, %Y %l:%M %p"))
(insert (format-time-string "%02e.%02m.%Y %02H:%02M"))
)
(global-set-key [f3] 'insert-date)
(message "F3 gesetzt: aktuelles Datum einfuegen")
(global-set-key [\S-f3] 'insert-date-time)
(message "S-F3 gesetzt: Datum und Uhrzeit einfuegen")
; Mit freundlichen Grüßen, Viele Grüße:
(defun insert-mfg ()
"Insert: Mit freundlichen Grüßen, Klaus Wachtler"
(interactive)
(insert "Mit freundlichen Grüßen, Klaus Wachtler")
)
(defun insert-viele-gruesse ()
"Insert: Viele Grüße, Klaus Wachtler"
(interactive)
(insert "Viele Grüße, Klaus Wachtler")
)
(global-set-key [f5] 'insert-mfg)
(message "F5 gesetzt: Mit freundlichen Grüßen")
(global-set-key [\S-f5] 'insert-viele-gruesse)
(message "S-F5 gesetzt: Viele Grüße")
(defun rect-sum() "Addiert alle Zahlen im markierten Rechteck,\ngibt die Summe als message aus,\nund speichert sie auch im kill-ring (zum Wiedereinfuegen)\n23.01.2002 Klaus Wachtler"
(interactive)
( let( (r (extract-rectangle (mark) (point))) ; Rechteck nach r holen:
woerter
(summe 0)
)
; In r steht jetzt eine Liste der einzelnen Zeilen des Rechtecks.
; Schleife über alle Zeilen des Rechtecks:
(while r
(setq woerter (split-string (car r))) ; Zeile zu Liste von Wörtern machen
; Schleife über die Wörter einer Zeile:
(while woerter
(setq summe (+ summe (string-to-number (car woerter)))) ; addieren
(setq woerter (cdr woerter)) ; Liste um erstes Wort kürzen
)
(setq r (cdr r)) ; Liste um erste Zeile erleichtern
)
; Summe im mini buffer und in den *Message*-buffer ausgeben:
(message "Summe ist %s" summe)
; in kill-ring setzen (dann kann der String mit yank, z.B. C-y
; jederzeit wieder eingefügt werden):
(kill-new (number-to-string summe))
)
)
(global-set-key [f4] 'rect-sum)
(message "F4 gesetzt: alle Zahlen im markierten Rechteck addieren")
(global-auto-revert-mode 1) ; autorevert buffers if files change
;(auto-insert-mode 1) ; bei neuen Dateien gleich ein Template laden
;(setq auto-insert-directory "~/.emacstemplates")
; Wenn ein buffer größer ist als dieser Wert, dann wird er nicht
; gemäß Syntaxregeln bunt eingefärbt (je nach mode)
(setq font-lock-maximum-size 1000000)
;;; >
;;; > To insert a time stamp, you want time-stamp.el.
;;; >
;;; > ; time stamp (Time-stamp: " " in first eight lines of file)
;;; >
;;; > (add-hook 'write-file-hooks 'time-stamp)
;;; > (setq time-stamp-active t)
;;; > (setq time-stamp-format "%02d %:b %:y %02H:%02M:%02S")
;;; >
;;; > So if your header text has the special time stamp text in the first 8
;;; > lines, you'll get a time stamp every time you write the file.
;;; >
;;; > I don't know how to add the current user name.
; time stamp (Time-stamp: " " in first eight lines of file)
(add-hook 'write-file-hooks 'time-stamp)
(setq time-stamp-active t)
(setq time-stamp-format "%02d.%02m.%02y %02H:%02M %f %u@%h")
; aus time-stamp.el:
; A string is used verbatim except for character sequences beginning with %:
;
; %:a weekday name: `Monday'. %#A gives uppercase: `MONDAY'
; %3a abbreviated weekday: `Mon'. %3A gives uppercase: `MON'
; %:b month name: `January'. %#B gives uppercase: `JANUARY'
; %3b abbreviated month: `Jan'. %3B gives uppercase: `JAN'
; %02d day of month
; %02H 24-hour clock hour
; %02I 12-hour clock hour
; %02m month number
; %02M minute
; %#p `am' or `pm'. %P gives uppercase: `AM' or `PM'
; %02S seconds
; %w day number of week, Sunday is 0
; %02y 2-digit year: `97' %:y 4-digit year: `1997'
; %z time zone name: `est'. %Z gives uppercase: `EST'
;
; Non-date items:
; %% a literal percent character: `%'
; %f file name without directory %F gives absolute pathname
; %s system name
; %u user's login name %U user's full name
; %h mail host name
;
; Decimal digits between the % and the type character specify the
; field width. Strings are truncated on the right; years on the left.
; A leading zero causes numbers to be zero-filled.
(global-set-key [f6] 'gud-stepi)
(message "F6 gesetzt: gud step instruction (naechst. Maschinenbefehl)")
(global-set-key [f7] 'gud-step)
(message "F7 gesetzt: gud step (naechste Anw., ggf. in f())")
(global-set-key [f8] 'gud-next)
(message "F8 gesetzt: gud next (naechste Anw., f() ueberspringen)")
(global-set-key [f9] 'gud-cont)
(message "F9 gesetzt: gud continue")
; Unter Linux tritt manchmal folgendes Problem auf:
; Wenn man in einem xterm ein "su -" macht, dann wird zwar die TERM-Variable
; (TERM=xterm) an die neue shell weiterverebt, aber nicht die DISPLAY-Variable.
; Wenn man dann den EMACS aufruft, bewirkt ein Drücken der Backspace-Taste
; ein C-h, was wiederum als Prefix (für die Hilfefunktionen) interpretiert
; wird. In einem solchen Fall wird mit der folgenden Anpassung ein Umdefinieren
; erreicht. Die Hilfefunktionen sind dann nicht erreichbar (mit C-h), und
; stattdessen hat man wieder ein Backspace.
(defun Ctrl-h-als-DEL ()
"Ctrl-h-als-DEL definiert die Tastaturtabelle so um, daß C-h nicht mehr als Prefix für Hilfe zählt, sondern Backspace ermöglicht"
(keyboard-translate ?\C-h ?\C-?)
(keyboard-translate ?\C-? ?\C-h)
)
(if (and (string= (getenv "TERM") "xterm") (not (getenv "DISPLAY") ) )
(Ctrl-h-als-DEL)
)
; ; ersetzt den Text unter dem Cursor (zwischen dem vorhergehenden und dem
; ; nachfolgenden Leerzeichen) durch das aktuelle Datum.
; ; geht nur unter Unix/Linux, nicht NT
; (defun update-datum () "ersetzt das aktuelle Wort durch das aktuelle Datum"
; (interactive)
; (search-forward " ")
; (backward-char)
; (push-mark)
; (set-mark (point))
; (search-backward " ")
; (forward-char)
; (delete-region (mark) (point))
; (pop-mark)
; (shell-command "echo -n `date +%d.%m.%Y`" t )
; )
;
; (global-set-key [f1] 'update-datum)
; mit C-c M-% startet ein Suchen und Ersetzen mit regulären Ausdrücken:
;(global-set-key "\C-c\M-%" 'query-replace-regexp)
; mit C-c i kann man den markierten Bereich gemäß aktueller
; Syntax einrücken lassen:
(global-set-key "\C-c\C-i" 'indent-region)
(message "C-c C-i gesetzt: markierten Block einruecken")
; zusammengehörige Klammernpaare anzeigen lassen:
(show-paren-mode t)
;; Maus mit Rad: Mit dem Rad rauf und runter blättern:
(defun scroll-up-half ()
"Scroll up half a page."
(interactive)
(scroll-up (/ (window-height) 2))
)
(defun scroll-down-half ()
"Scroll down half a page."
(interactive)
(scroll-down (/ (window-height) 2))
)
(global-set-key [(mouse-5)] 'scroll-up-half)
(global-set-key [(mouse-4)] 'scroll-down-half)
;; 03.10.2003 kw: scheint nicht mehr zu gehen unter akutellem Linux (Debian)
;; ;;; For imwheel
;; (setq imwheel-scroll-interval 3)
;; (defun imwheel-scroll-down-some-lines ()
;; (interactive)
;; (scroll-down imwheel-scroll-interval))
;; (defun imwheel-scroll-up-some-lines ()
;; (interactive)
;; (scroll-up imwheel-scroll-interval))
;; (global-set-key [?\M-\C-\)] 'imwheel-scroll-up-some-lines)
;; (global-set-key [?\M-\C-\(] 'imwheel-scroll-down-some-lines)
;;
;; (define-key global-map [(control \))] 'imwheel-scroll-up-some-lines)
;; (define-key global-map [(control \()] 'imwheel-scroll-down-some-lines)
;; ;;; end imwheel section
(defun c-deref-operator ()
"Einfuegen eines deref-operators (->)"
(interactive)
(insert "->")
)
; bei jedem Suchen mit C-s oder C-r springt der Cursor wie gehabt zum nächsten
; gefundenen Vorkommen. Zusätzlich werden die dann folgenden Vorkommen gleich
; farblich markiert.
; Benötigt die Datei ishl.el oder ishl.elc im lisp-Verzeichnis:
(require 'ishl)
(ishl-mode t)
; Falls der EMACS auch als IRC-Client fungieren soll: ERC
; (require 'erc)
;(require 'cc-mode)
;(modify-syntax-entry ?_ "w" c++-mode-syntax-table)
;(require 'c-mode)
;(modify-syntax-entry ?_ "w" c-mode-syntax-table)
; ich will keine TABs im Text haben (sonst stimmt beim Austausch mit anderen
; Editoren (DevStudio) die Formatierung nicht mehr).
(setq-default indent-tabs-mode nil)
; Eine LISP-Funktion wird mit "defun" definiert:
; ( defun funktionsname
; ( parameterliste )
; "beschreibender Text"
; (interactive)
; (Anweisung 1)
; (Anweisung 2)
; (Anweisung ...)
; )
;
; Wenn man keine Parameterliste hat, dann läßt man die Klammern leer.
;
; Der beschreibende Text wird angezeigt, wenn der Benutzer
; M-x describe-function zu dieser Funktion aufruft.
;
; Durch das (interactive) kann man die Funktion als Benutzer direkt
; aufrufen.
;
; Die darauf folgenden Anweisungen werden in der angegebenen Reihenfolge
; ausgeführt.
;
; Die i.F. definierte Funktion geschweifte-klammern fügt ein paar
; geschweifter Klammern ein, und geht dann wieder mit dem Cursor ein
; Zeichen nach links, damit man zwischen den Klammern weiterschreiben kann.
;
; Aufrufen kann man eine LISP-Funktion in der Form:
; (funktionsname parameter1 parameter2 ... )
;
;
(defun geschweifte-klammern ()
"Einfuegen von geschweiften Klammern {}"
(interactive)
(insert "{}")
(backward-char 1)
)
(global-set-key "\C-c7" 'geschweifte-klammern)
(message "C-c 7 gesetzt: '{}' einfuegen")
(defun eckige-klammern () "Einfuegen von eckigen Klammern []"
(interactive)
(insert "[]")
(backward-char 1)
)
(global-set-key "\C-c8" 'eckige-klammern)
(message "C-c 8 gesetzt: '[]' einfuegen")
; kopiert aus der vorhergehenden Zeile ein Zeichen in die aktuelle:
(defun copy-char-from-previous-line()
"kopiert ein Zeichen aus der letzten Zeile in die aktuelle Zeile"
(interactive)
(push-mark) ; merken, um danach die ursprüngliche
(set-mark (point)) ; Stelle zu finden
; aus irgendwelchen kühlen Gründen wird manchmal nicht kopiert, wenn man
; wenn man am Zeilenende steht,
; sondern man springt stattdessen in die nächste
; Zeile. Wenn man vorher allerdings etwas schreibt, und wieder löscht, dann
; klappts.?!?
; Also etwas schreiben, und wieder löschen:
(insert " ")
(backward-delete-char 1)
(push-mark)
(previous-line 1) ; eine Zeile hoch
(set-mark (point)) ; Markierung setzen
(forward-char 1) ; ein Zeichen weiter
(copy-region-as-kill ; das markierte Zeichen in yank-Puffer kopieren
(mark)
(point)
)
(pop-mark)
(exchange-point-and-mark) ; ursprüngliche Stelle wiederfinden
(pop-mark)
(yank) ; das Zeichen aus dem Puffer einfügen
)
(defun copy-word-from-previous-line()
"kopiert ein Wort aus der letzten Zeile in die aktuelle Zeile"
(interactive)
(push-mark) ; merken, um danach die ursprüngliche
(set-mark (point)) ; Stelle zu finden
(push-mark)
(previous-line 1) ; eine Zeile hoch
(set-mark (point)) ; Markierung setzen
(forward-word 1) ; ein Wort weiter
(copy-region-as-kill ; das markierte Wort in yank-Puffer kopieren
(mark)
(point)
)
(pop-mark)
(exchange-point-and-mark) ; ursprüngliche Stelle wiederfinden
(pop-mark)
(yank) ; das Wort aus dem Puffer einfügen
)
(global-set-key "\M-," 'copy-char-from-previous-line)
(message "M-, gesetzt: ein Zeichen aus der Zeile drueber kopieren")
(global-set-key "\M-;" 'copy-word-from-previous-line)
(message "M-; gesetzt: ein Wort aus der Zeile drueber kopieren")
; \index{}-Befehl für LaTeX:
(defun latex-region-to-index ()
"latex-region-to-index kopiert region in einen \index{}-Befehl hinter der
region.
Beispiel: Wenn im Text:
\"...was ist ein DBMS?...\"
das Wort \"DBMS\" markiert ist, dann macht die Funktion daraus:
\"...was ist ein DBMS\\index{DBMS}?...\""
(interactive)
(copy-region-as-kill (mark) (point))
(insert "\\index{")
(yank)
(insert "}")
)
;;; To use it, copy it to _emacs in a directory where emacs will
;;; search it. Were will emacs search it? If emacs installed in a
;;; directory named `bin', it will search _emacs in the parent
;;; directory, else it will search it in the directory it is installed
;;; in. Setting the environment variable `HOME' probably interferes
;;; with this scheme.
(standard-display-european 1)
;;; 1. 7.97 kw: Funktion pps:
;;; Damit kann man den emacs so aufrufen, daß er eine Datei in Postscript
;;; konvertiert, den PS-Code abspeichert, und sich dann beendet.
;;; Unter NT geht das so: runemacs %1 -f pps --kill
;;; Unter Linux: emacs -nw %1 -f pps --kill
(defun pps() "pps gibt den aktuellen Puffer in eine
PS-Datei aus.
Dateiname ist der Dateiname des Puffers mit angehaengtem .ps.
1. 7.97 AnyWare Klaus Wachtler"
(interactive)
(ps-print-buffer (concat buffer-file-name ".ps" ) )
)
(defun ppsc() "pps gibt den aktuellen Puffer mit Syntaxhighlighting in eine
PS-Datei aus.
Dateiname ist der Dateiname des Puffers mit angehaengtem .ps.
1. 7.97 AnyWare Klaus Wachtler"
(interactive)
(ps-print-buffer-with-faces (concat buffer-file-name ".ps" ) )
)
; Mit dem Paket gnuserv wird der EMACS zu einem Server, der durch Kommandos
; von außen fernbedienbar ist. Diese Kommandos kommen meist aus dem Programm
; gnuclient (oder unter Windows gnuclientw).
; Wenn man gnuclient aufruft, aber noch kein EMACS läuft, dann wird er
; halt gestartet, ansonsten wird der bereits laufende verwendet um die
; Kommandos auszuführen.
; Wenn man nun nie den EMACS aufruft, sondern zum Editieren nur noch gnuclient,
; dann muß EMACS nur noch einmal gestartet werden -> geht schneller, außerdem
; hat man dann immer aller buffer gleichzeitig im Zugriff.
; (require 'gnuserv)
; (gnuserv-start)
; (setq gnuserv-frame (selected-frame))
; ;(setq gnuserv-frame (selected-frame)) ; immer im gleichen frame
; (setq gnuserv-frame nil) ; jeweils ein neuer frame
;;; 14. 3.99 Klaus Wachtler: Unterscheidung zwischen Win95/NT einerseits,
;;; und X-Windows andererseits.
;;; Grund: das Paket gnuclientw kann und braucht man nur unter Windows
;;; laden.
(defun meine-win32-anpassungen()
"macht Anpassungen an Win32"
(message "Anpassungen an Win32")
; die folgenden will ich jetzt (13.06.2002) auch unter Unix haben;
; deshalb nach oben verschoben:
; (require 'gnuserv) ; mit diesen beiden Zeilen
; (gnuserv-start) ; kann man eine Verbindung von
; VC++ 5.0 aus
; herstellen.
; Nötig sind die Pakete
; gnuserv (für den EMACS)
; und VisEmacs (für
; DeveloperStudio).
)
(defun meine-x-anpassungen()
"macht Anpassungen an X-Windows"
(message "Anpassungen an X-Windows")
; ...
)
(if (string= "w32" window-system)
(meine-win32-anpassungen)
(if (string= "x" window-system)
(meine-x-anpassungen)
(message "kein X-Windows, kein Win32!")
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; Ergaenzungen 5.4.96 Klaus Wachtler:
;;;
;;; a) ob beim Suchen Gross-/Kleinschreibung unterschieden wird, ist
;;; eigentlich egal. Aber wenn case-fold-search auf t steht, dann
;;; klappen auch Ergaenzungen (M-/) nicht so recht. ZB. wird nach dem
;;; Text: "AnyWare" das Wort "An" durch M-/ zu "Anyware" anstatt
;;; "AnyWare" ergaenzt. So gehts besser (dann klappt's auch mit dem
;;; Nachbarn):
(defun kw-ergaenzungen-zu-c-c++-mode()
"Ergaenzungen zu c-mode:
a) schaltet Unterscheidung Gross-/Klein ein
b) schaltet abbrev-mode ein
5.4.96 kw"
(local-set-key [f12] 'c-deref-operator)
(message "F12 gesetzt: '->' einfuegen (nur C/C++)")
;if (0) becomes if (0)
; { {
; ; ;
; } }
(c-set-offset 'substatement-open 0)
;first arg of arglist to functions: tabbed in once
;(default was c-lineup-arglist-intro-after-paren)
;(c-set-offset 'arglist-intro '+)
;second line of arglist to functions: tabbed in once
;(default was c-lineup-arglist)
;(c-set-offset 'arglist-cont-nonempty '+)
;switch/case: make each case line indent from switch
(c-set-offset 'case-label '+)
;make open-braces after a case: statement indent to 0 (default was '+)
(c-set-offset 'statement-case-open '+)
;make a #define be left-aligned
(setq c-electric-pound-behavior (quote (alignleft)))
; c-auto-state fügt selbständig LF ein (z.B. nach ';'),
; c-hungry-state löscht statt eines whitespace gleich alle:
(c-toggle-auto-hungry-state 1)
;(set-frame-height (selected-frame) 45)
;(set-frame-width (selected-frame) 72)
( setq case-fold-search nil )
( setq abbrev-mode t )
( setq c-auto-newline nil )
; die folgenden Zeilen, um mit filladapt Kommentare besser zu
; formatieren (benötigt filladapt.el/filladapt.elc von
; http://cc-mode.sourceforge.net/filladapt.php und klappt am besten mit
; cc-* http://download.sourceforge.net/cc-mode/cc-mode-5.28.tar.gz);
'(require 'filladapt)
;(cc-setup-filladapt)
'(filladapt-mode 1)
; und wenn das mit dem automatischen Formatieren in den Kommentaren
; schon so schön klappt, dann kann man das auch gleich laufend
; automatisch machen lassen:
(auto-fill-mode t)
)
(add-hook 'c-mode-common-hook 'kw-ergaenzungen-zu-c-c++-mode)
(add-hook 'cc-mode-hook 'kw-ergaenzungen-zu-c-c++-mode)
;;; (einfach mit (setq...) setzen reicht nicht, da case-fold-search
;;; offenbar durch den c-mode danach noch uebersteuert wird.
;;;
;;; b) Bei kleinen Texten (Buffer
;;; To: Jason Diamond
;;; Cc: help-emacs-windows@gnu.org
;;; Subject: Re: [h-e-w] View Whitespace
;;;
;;; Jason Diamond wrote:
;;; >
;;; > Hi.
;;; >
;;; > Is there a Lisp function that toggles whether or not whitespace (horizontal
;;; > tabs, line feeds, carriage returns, and spaces) are "visible"?
;;; >
;;; > Thanks,
;;; > Jason.
;;;
;;; I don't know where I got this from, but it does tabs and trailing
;;; spaces.
;;;
;;; ;;; Editor behavior: color tabs
;;; (custom-set-faces
;;; '(my-tab-face ((((class color)) (:background "Khaki"))) t)
;;; '(my-trailing-space-face ((((class color)) (:background "Gold"))) t))
;;; (add-hook 'font-lock-mode-hook
;;; (function
;;; (lambda ()
;;; (setq font-lock-keywords
;;; (append font-lock-keywords
;;; '(("\t+" (0 'my-tab-face t))
;;; ("[ \t]+$" (0 'my-trailing-space-face
;;; t))))))))
;;;
;;; --
;;; Tom Schutter
;;; t.schutter@att.net
;;;
;;; Editor behavior: color tabs
(custom-set-faces
'(my-tab-face ((((class color)) (:background "Khaki"))) t)
'(my-trailing-space-face ((((class color)) (:background "Gold"))) t))
(add-hook 'font-lock-mode-hook
(function
(lambda ()
(setq font-lock-keywords
(append font-lock-keywords
'(("\t+" (0 'my-tab-face t))
("[ \t]+$" (0 'my-trailing-space-face t))))))))
;;; From: Christian Mallwitz
;;; To: "'ntemacs-users@cs.washington.edu'"
;;; Subject: RE: Trailing spaces
;;; Date: Wed, 20 Jun 2001 09:52:58 +0200
;;; X-Mailer: Internet Mail Service (5.5.2650.21)
;;; Precedence: bulk
;;; X-FAQ: http://www.gnu.org/software/emacs/windows/ntemacs.html
;;;
;;; Mike,
;;;
;;; I use this in my .emacs
;;;
;;; ;; special customization for coloring leading and trailing spaces
;;;
;;; (custom-set-faces
;;; '(my-tab-face ((((class color)) (:background "lavender blush")))
;;; t)
;;; '(my-trailing-space-face ((((class color)) (:background "cornsilk"))) t))
;;;
;;; (add-hook 'font-lock-mode-hook
;;; (function
;;; (lambda ()
;;; (setq font-lock-keywords
;;; (append font-lock-keywords
;;; '(("\t+" (0 'my-tab-face t))
;;; ("[ \t]+$" (0 'my-trailing-space-face t))))))))
;;;
;;; which you may treak for your purposes ...
;;; Bye
;;; Christian
;show ascii table
(defun ascii-table ()
"Print the ascii table. Based on a defun by Alex Schroeder "
(interactive)
(switch-to-buffer "*ASCII*")
(erase-buffer)
(insert (format "ASCII characters up to number %d.\n" 254))
(let ((i 0))
(while (< i 254)
(setq i (+ i 1))
(insert (format "%3d 0x%3x %c\n" i i i))))
(beginning-of-buffer))
; Mouse avoidance mode.
; Dadurch wird der Mauszeiger irgendwohin verschoben, wenn er dem
; Textcursor im Weg ist.
; So sieht man immer, was man schreibt.
; Und es sieht einfach cool aus.
(if window-system (mouse-avoidance-mode 'animate))
; So muß man nicht immer "yes" und "no" eingeben, ein einfaches
; "y" oder "n" genügt:
(fset 'yes-or-no-p 'y-or-n-p)
;; ; Mailcrypt
;; (load-library "mailcrypt")
;; (mc-setversion "gpg") ; use GPG as default
;; (autoload 'mc-install-write-mode "mailcrypt" nil t)
;; (autoload 'mc-install-read-mode "mailcrypt" nil t)
;; (add-hook 'mail-mode-hook 'mc-install-write-mode)
;;
;; The first time you save the state of the Emacs session, you must
;; do it manually, with the command M-x desktop-save. Once you have
;; done that, exiting Emacs will save the state again -- not only
;; the present Emacs session, but also subsequent sessions. You can
;; also save the state at any time, without exiting Emacs, by typing
;; M-x desktop-save again.
(load "desktop")
(desktop-load-default)
(desktop-read)
(setq ange-ftp-ftp-program-args '("-i" "-n" "-g" "-v" "-p"))
; Normalerweise wird ein buffer den selben Namen haben, wie die zugehörige
; Datei (aber ohne Pfadangabe).
; Lädt man eine zweite (dritte...) Datei mit demselben Namen aus einem
; anderen Verzeichnis, dann wird deren buffer zur Unterscheidung eine
; Zahl angehängt bekommen ("<2>", "<3>" etc.).
; Das kann man ändern; dann wird der Pfadname in den buffer-Namen
; mit aufgenommen anstatt einer Zahl.
;
; Mögliche Werte für uniquify-buffer-name-style:
; forward bar/mumble/name quux/mumble/name
; reverse name\mumble\bar name\mumble\quux
; post-forward name|bar/mumble name|quux/mumble
; post-forward-angle-brackets name name
; nil name name<2>
(require 'uniquify)
(setq uniquify-buffer-name-style 'post-forward-angle-brackets)
; Anm.: In jedem Fall kann man mit C-x C-b eine Liste aller buffer
; zusammen mit den zugehörigen vollen Pfadnamen anzeigen lassen
; (und ggf. durch Anklicken mit der mittleren Maustaste dorthin
; springen).
; tool bars brauchen viel Platz, und machen mich auch nicht glücklicher.
; also weg damit:
(tool-bar-mode nil)
; Für ftp-Zugriff PASV verwenden
; ; Tweaked by eraatikidotfi based on code from
; ; http://mail.gnu.org/pipermail/help-gnu-emacs/2001-April/006468.html:
; ;; From: Ehud Karni ehudatunixdotsimonwieseldotcodotil
; ;; Date: Wed, 18 Apr 2001 19:45:08 +0300
; ;; Subject: Ange-ftp: passive mode transfers?
;
; (defvar ange-ftp-hosts-no-pasv '("localhost")
; "*List of hosts that do not need PASV (e.g. hosts within your firewall).
; Used by `ange-ftp-set-passive'.") ; rephrased, added "*" // era
;
; (defun ange-ftp-set-passive ()
; "Function to send a PASV command to hosts not named in the variable
; `ange-ft-hosts-no-pasv'. Intended to be called from the hook variable
; `ange-ftp-process-startup-hook'." ; rephrased significantly // era
; (if (not (member host ange-ftp-hosts-no-pasv))
; (ange-ftp-raw-send-cmd proc "passive")))
;
; (add-hook 'ange-ftp-process-startup-hook 'ange-ftp-set-passive)
;
Und hier die Datei .abbrev:
.abbrev
(define-abbrev-table 'idl-mode-abbrev-table '(
))
(define-abbrev-table 'text-mode--abbrev-table '(
("LIM" "Local Improvement Movement" nil 0)
))
(define-abbrev-table 'c++-mode-abbrev-table '(
("switch10" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch10 0)
("ifpp" "#if" abbrev-korrekt-ifpp 1)
("ifepp" "#if" abbrev-korrekt-ifepp 1)
("ifdef" "#ifdef" abbrev-korrekt-ifdef 1)
("ifdefe" "#ifdef" abbrev-korrekt-ifdefelse 1)
("ifndef" "#ifndef" abbrev-korrekt-ifndef 1)
("print" "printf( \"\\n\" )" abbrev-korrekt-printf 0)
("ifdeb" "#ifndef NDEBUG" abbrev-korrekt-ifdeb 1)
("forever" "for(;;)
{
} // for(;;)" abbrev-korrekt-forever 0)
("if" "if( )
{
}" abbrev-korrekt-if 9)
("templ" "template" nil 0)
("try" "try
{
}
catch( std::exception &Fehler )
{
std::cerr << \"Fehler: <\"
<< Fehler.what()
<< \"> in \"
<< __PRETTY_FUNCTION__
<< \"\\n\";
//throw( Fehler );
}
catch( ... )
{
std::cerr << \"unbekannter Fehler in \"
<< __PRETTY_FUNCTION__
<< \"\\n\";
//throw;
}" abbrev-korrekt-try 0)
("scan" "scanf( \"%\", & )" abbrev-korrekt-scanf 0)
("cout" "std::cout << \"\" << << std::endl;" abbrev-korrekt-cout 0)
("cerr" "std::cerr << \"\" << << std::endl;" abbrev-korrekt-cout 0)
("cin" "std::cin >>;" abbrev-korrekt-cin 0)
("whil" "while( )
{
}" abbrev-korrekt-while 1)
("main" "// Time-stamp: \"abc\"
//
//
//#include
//#include
//#include
//#include
//#include
#include
//#include
//#include
//#include
// Ausnahmen für Fehler:
#define DERIVEEXCEPTION( NAME, BASENAME, TEXT ) \\
class NAME : public BASENAME \\
{ \\
public: \\
NAME( const std::string &_what = #NAME ) \\
: BASENAME( std::string( TEXT ) + std::string( \"\\n\" ) + _what ) \\
{} \\
}
int main( int nargs, char **args )
{
return 0;
} // main( int nargs, char **args )" nil 1)
("dlprint" "#ifdef DEBUG
lgprintf( LogHandle, \"\\n\" )
#endif // DEBUG" nil 9)
("sstream" "std::stringstream" nil 0)
("isstream" "std::istringstream" nil 0)
("osstream" "std::ostringstream" nil 0)
("ifstream" "std::ifstream" nil 0)
("ofstream" "std::ofstream" nil 0)
("s" "std::string" nil 0)
("vec" "std::vector< >" abbrev-korrekt-backeins 0)
("map" "std::map< >" abbrev-korrekt-backeins 0)
("mmap" "std::multimap< >" abbrev-korrekt-backeins 0)
("set" "std::set< >" abbrev-korrekt-backeins 0)
("mset" "std::multiset< >" abbrev-korrekt-backeins 0)
("list" "std::list< >" abbrev-korrekt-backeins 0)
("sscan" "sscanf( puffer, \"%\", & )" abbrev-korrekt-scanf 0)
("lprint" "lgprintf( \"\\n\" )" abbrev-korrekt-printf 0)
("switch9" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch9 0)
("def" "#define" nil 1)
("switch8" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch8 0)
("class" "class
{
}; // class " abbrev-korrekt-class 0)
("switch7" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch7 0)
("fprints" "fprintf( stderr, \"\\n\" )" abbrev-korrekt-printf 0)
("switch6" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch6 0)
("switch5" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch5 0)
("do" "do
{
}
while( );" abbrev-korrekt-do 0)
("else" "else" c-electric-continued-statement 0)
("switch4" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch4 0)
("switch3" " switch( )
{
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch3 0)
("switch" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch4 3)
("switch2" " switch( )
{
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch2 0)
("switch1" " switch( )
{
case :
break;
default :
break;
}" abbrev-korrekt-switch1 0)
("dfprint" "#ifdef DEBUG
fprintf( stderr, \"\\n\" )
#endif // DEBUG" nil 0)
("sprint" "sprintf( puffer, \"\" )" abbrev-korrekt-printf 0)
("aprint" "ads_printf( \"\\n\" )" abbrev-korrekt-printf 0)
("catch" "catch" c-electric-continued-statement 0)
("myinc" "#include \".h\"
" abbrev-korrekt-include 0)
("snprint" "snprintf( puffer, sizeof(puffer), \"\" )" abbrev-korrekt-printf 0)
("fprint" "fprintf( , \"\\n\" )" abbrev-korrekt-printf 0)
("for" "for(; ; )
{
}" abbrev-korrekt-for 0)
("fscan" "fscanf( f, \"%\", & )" abbrev-korrekt-scanf 0)
("inc" "#include <>
" abbrev-korrekt-backzwei 0)
))
(define-abbrev-table 'c-mode-abbrev-table '(
("switch10" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch10 0)
("ifdef" "#ifdef" abbrev-korrekt-ifdef 1)
("print" "printf( \"\\n\" )" abbrev-korrekt-printf 0)
("ifdeb" "#ifdef DEBUG
#else /* nicht DEBUG */
#endif /* DEBUG */" abbrev-korrekt-ifdeb 1)
("forever" "for(;;)
{
}" abbrev-korrekt-for 0)
("if" "if( )
{
}" abbrev-korrekt-if 9)
("scan" "scanf( \"%\", & )" abbrev-korrekt-scanf 0)
("whil" "while( )
{
}" abbrev-korrekt-while 1)
("main" "/* Time-stamp: \"abc\"
*
*/
#include
#include
#include
#include
int main( int nargs, char **args )
{
return 0;
} /* main( int nargs, char **args ) */" nil 0)
("dlprint" "#ifdef DEBUG
lgprintf( LogHandle, \"\\n\" )
#endif // DEBUG" nil 9)
("sscan" "sscanf( puffer, \"%\", & )" abbrev-korrekt-scanf 0)
("lprint" "lgprintf( LogHandle, \"\\n\" )" abbrev-korrekt-printf 0)
("switch9" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch9 0)
("def" "#define" nil 1)
("switch8" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch8 0)
("switch7" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch7 0)
("fprints" "fprintf( stderr, \"\\n\" )" abbrev-korrekt-printf 0)
("switch6" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch6 0)
("switch5" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch5 0)
("do" "do
{
}
while( );" abbrev-korrekt-do 0)
("else" "else" c-electric-continued-statement 0)
("switch4" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch4 0)
("switch3" " switch( )
{
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch3 0)
("switch" " switch( )
{
case :
break;
case :
break;
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch4 3)
("switch2" " switch( )
{
case :
break;
case :
break;
default :
break;
}" abbrev-korrekt-switch2 0)
("switch1" " switch( )
{
case :
break;
default :
break;
}" abbrev-korrekt-switch1 0)
("dfprint" "#ifdef DEBUG
fprintf( stderr, \"\\n\" )
#endif /* DEBUG */" nil 0)
("sprint" "sprintf( puffer, \"\" )" abbrev-korrekt-printf 0)
("aprint" "ads_printf( \"\\n\" )" abbrev-korrekt-printf 0)
("myinc" "#include \".h\"
" abbrev-korrekt-include 0)
("snprint" "snprintf( puffer, sizeof(puffer), \"\" )" abbrev-korrekt-printf 0)
("fprint" "fprintf( , \"\\n\" )" abbrev-korrekt-printf 0)
("for" "for(; ; )
{
}" abbrev-korrekt-for 0)
("fscan" "fscanf( f, \"%\", & )" abbrev-korrekt-scanf 0)
("inc" "#include <.h>
" abbrev-korrekt-include 0)
))
(define-abbrev-table 'java-mode-abbrev-table '(
("if" "if( )
{
}" abbrev-korrekt-if 9)
("cout" "System.out.println(" nil 0)
("while" "while( )
{
}" abbrev-korrekt-while 1)
("main" "// Time-stamp: \"abc\"
//
// javac klassenname.JAVA && java klassenname
import java.util.*;
public class klassenname
{
public static void main( String args[] )
{
System.out.println( );
}
} // public class klassenname
" abbrev-java-korrekt-main 1)
("finally" "finally" c-electric-continued-statement 0)
("else" "else" c-electric-continued-statement 0)
("catch" "catch" c-electric-continued-statement 0)
("for" "for(; ; )
{
}" abbrev-korrekt-for 0)
))
(define-abbrev-table 'objc-mode-abbrev-table '(
("while" "while" c-electric-continued-statement 0)
("else" "else" c-electric-continued-statement 0)
))
(define-abbrev-table 'text-mode-abbrev-table '(
("foot" "{\\footnotesize}" abbrev-korrekt-latex-foot 0)
("script" "{\\scriptsize}" abbrev-korrekt-latex-script 0)
("item" "\\item" nil 0)
("bf" "{\\bf}" abbrev-korrekt-latex-em 0)
("Huge" "{\\Huge}" abbrev-korrekt-latex-huge 0)
("bibi" "{\\bibitem}" abbrev-korrekt-latex-bibi 0)
("bibitem" "\\bibitem[]{} % [Bezeichnung im Text]{label}
{:\\\\ % Verfasser
{\\em \\\\ % Titel
\\/}\\\\ % Untertitel
\\\\ % Verlag, Jahr
ISBN % ggf.ISBN
}" nil 1)
("doc" "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Time-stamp: \"a\"
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ///| |||\\ || |||| //
% ////| |||\\\\ || |||| //
% ////|| ||||\\\\ || |||| //
% //// || |||| \\\\ || |||| //
% ////==|| |||| \\\\|| ||||//
% //// || |||| \\\\| |||//
% //// || |||| \\| ||//
% |//
% |||| /| // // ///| ||||=====// ////=======
% |||| /|| // // ////| |||| // ////
% |||| //|| // // ////|| |||| // ////
% |||| // || // // //// || |||| // ////
% ||||// ||// // ////==|| ||||=(( ((((=======
% |||// |// // //// || |||| \\\\ \\\\\\\\
% |||/ |/ // //// || |||| \\\\ \\\\\\\\=======
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Copyright:
%%%%%%%%%%%%
%
% (C) 2002 AnyWare
%
% Klaus Wachtler
% Breidingstr. 17
% 29614 Soltau
%
% Tel. (49)-5191-70 2 71
% Fax: (49)-5191-70 2 72
% eMail AnyWare@Wachtler.de
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Geschichte:
%%%%%%%%%%%%%
%
% Datum: Name: Vers. Aenderung:
% kw 0.1 Basisversion
%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Zukunft:
%%%%%%%%%%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Benoetigt:
%%%%%%%%%%%%
%
% dvips
% c2tex
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%%%% entweder Needstexformat..., documentclass... mit den %
%%%% usepackage... (neues LaTeX) %
%
\\NeedsTeXFormat{LaTeX2e} %
\\documentclass[12pt,a4paper,twoside,titlepage]{article} %
\\usepackage{a4,german,makeidx,graphicx} %
%\\usepackage{helvet} %
\\usepackage[ansinew]{inputenc} %
\\usepackage{epsf,colordvi} %
\\usepackage{html} %
\\usepackage{htmllist} %
\\usepackage{marvosym}
\\usepackage{fancyhdr} %
%
%%%% oder documentstyle... und input{psbox} (alt, fuer tex2rtf) %
%
%\\documentstyle[12pt,german,inputenc,texhelp]{book} %
%\\input{psbox} %
%\\inputencoding{ansinew} %
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\\parindent0pt
\\parskip5mm
%\\textheight25cm
%\\textwidth10cm
%\\topmargin0cm
%\\leftmargin0cm
%\\evensidemargin0cm
%\\oddsidemargin0cm
%\\input{version.tex}
\\makeindex
%\\renewcommand\\familydefault{\\sfdefault}
\\begin{document}
%\\pagestyle{myheadings}
%\\pagestyle{headings}
\\pagestyle{fancy}
\\newsavebox{\\logo}
\\savebox{\\logo}{\\makebox{\\raisebox{-1em}{\\parbox[t]{2cm}{\\includegraphics[width=3cm]{anywbutn.eps}}}}}
\\renewcommand{\\sectionmark}[1]{\\markboth{{\\sl \\thesection\\ #1}}{}}
\\renewcommand{\\subsectionmark}[1]{\\markright{{\\sl \\thesubsection\\ #1}}}
\\renewcommand{\\headrulewidth}{0.15pt}
\\addtolength{\\headheight}{5mm}
\\fancyhead{}
\\fancyhead[LE,RO]{\\thepage}
\\fancyhead[CE]{\\leftmark}
\\fancyhead[CO]{\\rightmark}
\\fancyhead[RE]{\\usebox{\\logo}}
\\fancyhead[LO]{\\usebox{\\logo}}
\\newcommand{\\CC}{C\\nolinebreak\\hspace{-.05em}\\raisebox{.4ex}{\\tiny\\bf +}\\nolinebreak\\hspace{-.10em}\\raisebox{.4ex}{\\tiny\\bf +}}
\\author{Klaus Wachtler}
\\date{\\today}
\\title{Titel...\\\\[5mm]
%includegraphics[width=4cm]{anywbutn.ps}\\\\[3mm]
%Version \\version
}
\\maketitle
\\clearpage
\\tableofcontents
\\clearpage
\\section{Einleitung}
%\\addcontentsline{toc}{chapter}{Literatur}
%
%\\begin{thebibliography}{STROU78945dddddd}
%
%\\bibitem[man make]{lit-man-make} % Label fuer \\cite{...}
%{Dennis Morse\\index{Dennis Morse}\\index{Morse, Dennis}, Roland McGrath\\index{Roland McGrath}\\index{McGrath, Roland}:\\\\ % Verfasser
%{\\em make - GNU make utility to maintain groups of programs\\\\ % Titel
%{\\tt{}man 1L make}\\/}\\\\ % Untertitel
%{\\em Linux man pages, 1989-2000 by the Free Software Foundation\\index{Free Software Foundation},
%Inc.\\/, {\\tt http://www.fsf.org}}\\\\ % Verlag/Ort, Jahr
%}
%
%\\bibitem[info make]{lit-info-make} % Label fuer \\cite{...}
%{Free Software Foundation:\\\\
%{\\em make - GNU make utility to maintain groups of programs\\\\ % Titel
%{\\tt{}info make}\\/}\\\\ % Untertitel
%{\\em Linux man pages, 1989-2000 by the Free Software Foundation\\index{Free Software Foundation},
%Inc.\\/, {\\tt http://www.fsf.org}}\\\\ % Verlag/Ort, Jahr
%}
%
%\\bibitem[man bash]{lit-man-bash} % Label fuer \\cite{...}
%{Brian Fox\\index{Brian Fox}\\index{Fox, Brian}, Chet Ramey\\index{Chet Ramey}\\index{Ramey, Chet}:\\\\ % Verfasser
%{\\em bash - GNU\\index{GNU} Bourne-Again SHel\\\\ % Titel
%{\\tt{}man 1 bash}\\/}\\\\ % Untertitel
%{\\em Linux man pages, 1989-1999 by the Free Software Foundation\\index{Free Software Foundation},
%Inc.\\/, {\\tt http://www.fsf.org}}\\\\ % Verlag/Ort, Jahr
%{\\em Brian Fox, Free Software Foundation, {\\tt bfox@gnu.ai.MIT.Edu}\\/}\\\\
%{\\em Chet Ramey, Case Western Reserve University, {\\tt chet@ins.CWRU.Edu}\\/}\\\\ % Verlag, Jahr
%}
%
%\\bibitem[info bash]{lit-info-bash} % Label fuer \\cite{...}
%{Brian Fox\\index{Fox, Brian}, Chet Ramey\\index{Ramey, Chet}:\\\\ % Verfasser
%{\\em bash - GNU\\index{GNU} Bourne-Again SHell\\\\ % Titel
%info bash\\/}\\\\ % Untertitel
%{\\em Linux man pages, 1989-1999 by the Free Software Foundation\\index{Free Software Foundation},
%Inc.\\/, {\\tt http://www.fsf.org}}\\\\ % Verlag/Ort, Jahr
%{\\em Brian Fox, Free Software Foundation, {\\tt bfox@gnu.ai.MIT.Edu}\\/}\\\\
%{\\em Chet Ramey, Case Western Reserve University, {\\tt chet@ins.CWRU.Edu}\\/}\\\\ % Verlag, Jahr
%}
%
%\\bibitem[Herold: Shell]{lit-herold-shells} % Label fuer \\cite{...}
%{Helmut Herold\\index{Helmut Herold}\\index{Herold, Helmut}:\\\\ % Verfasser
%{\\em Linux - Unix Shells\\\\ % Titel
%Bourne-Shell\\index{Bourne-Shell}, Korn-Shell\\index{Korn-Shell},
%C-Shell\\index{C-Shell}, bash\\index{bash}, tcsh\\index{tcsh}\\/}\\\\ % Untertitel
%3. Auflage\\\\
%Addison Wesley, 1999\\\\ % Verlag, Jahr
%ISBN 3-8273-1511-5% ggf.ISBN
%}
%
%
%\\bibitem[LaTeX2html]{lit-latextotohtml} % Label fuer \\cite{...}
%{Nikos Drakos\\index{Nikos Drakos}\\index{Drakos, Nikos}:\\\\ % Verfasser
%{\\em The \\latextotohtml\\index{\\sortby+LaTeX2html+\\latextotohtml}{} Translator\\\\ % Titel
%(Onlinehilfe zu \\latextotohtml{}\\index{\\sortby-LaTeX2html-\\latextotohtml{}} Version 96.1)\\/}\\\\ % Untertitel
%CTAN\\index{CTAN} (Comprehensive \\TeX{} archive\\index{Comprehensive \\TeX{} archive}), z.B.\\ {\\tt ftp.shsu.edu}, {\\tt ftp.dante.de} % Verlag, Jahr
%}
%
%
%
%\\bibitem[v.Helden,Dunkel: Inf2]{lit-jvh-inf-ii}
%{Josef v.\\ Helden\\index{Josef v.\\ Helden}\\index{\\sortby-Helden, Josef-v.\\ Helden, Josef}, Jürgen Dunkel\\index{Jürgen Dunkel}\\index{Dunkel Jürgen}:}\\\\
%{\\em Informatik 2\\\\
%Vorlesungsskript Sommersemester 2000\\/}\\\\
%FH Hannover, FB Informatik
%}
%
%\\bibitem[Knuth 1]{knuth1}{Donald E.\\ Knuth:\\\\
%{\\em The Art of Computer Programming\\/}\\\\
%{\\em Vol. 1: Fundamental Algorithms\\/}\\\\
%2. Auflage\\\\
%Addison-Wesley, 1973\\\\
%ISBN 0-201-03809-9
%}
%
%\\bibitem[Knuth 2]{knuth2}{Donald E.\\ Knuth:\\\\
%{\\em The Art of Computer Programming\\/}\\\\
%{\\em Vol. 2: Seminumerical Algorithms\\/}\\\\
%2. Auflage\\\\
%Addison-Wesley, 1971\\\\
%ISBN 0-201-03822-6
%}
%
%\\bibitem[Knuth 3]{knuth3}{Donald E.\\ Knuth:\\\\
%{\\em The Art of Computer Programming\\/}\\\\
%{\\em Vol. 3: Sorting and Searching\\/}\\\\
%2. Auflage\\\\
%Addison-Wesley, 1973\\\\
%ISBN 0-201-03803-X
%}
%
%
%\\bibitem[Knuth Sel.]{knuthsel}{Donald E.\\ Knuth:\\\\
%{\\em Selected Papers on Computer Science\\/}\\\\
%Center for the Study of language and Information (CSLI Publications), Leland Stanford Junior University 1996\\\\
%ISBN 1-881526-91-7 (paperback)\\\\
%ISBN 1-881526-92-5 (hardback)\\\\
%}
%
%%{\\em Kein Lehrbuch, aber sehr interessant zu lesen\\/}
%
%\\bibitem[Ziegenbalg]{ziegenbalg} % Label fuer \\cite{...}
%{Jochen Ziegenbalg:\\\\ % Verfasser
%{\\em Algorithmen\\\\ % Titel
%Von Hammurapi bis Gödel\\/}\\\\ % Untertitel
%Spektrum Akademischer Verlag, 1996\\\\ % Verlag, Jahr
%ISBN 3-8274-0114-3% ggf.ISBN
%}
%
%%{\\em Recht interessant zu lesen, weil neben der nüchternen
%%Beschreibung auch ein paar Geschichten erzählt werden.\\/}
%
%\\bibitem[Sedgewick C]{lit-sedgewick-c-dt}{Robert Sedgewick:\\\\ % Verfasser
%{\\em Algorithmen in C\\/}\\\\ % Untertitel
%Addison Wesley 1992\\\\
%ISBN 3-89319-376-6
%}
%
%%{\\em Gutes Lehr- und Referenzbuch für einen relativ weiten Bereich (Suchen,
%%Sortieren, Zeichenfolgen, etwas Geometrie, etwas Numerik)\\/}
%
%\\bibitem[Sedgewick C (eng.)]{lit-sedgewick-c-en}{Robert Sedgewick:\\\\ % Verfasser
%{\\em Algorithms in C\\/}\\\\ % Untertitel
%Addison Wesley 1990\\\\
%ISBN 0-201-51425-7
%}
%
%%{\\em Originaltext der deutschen Übersetzung \\cite{lit-sedgewick-c-dt}\\/}
%
%\\bibitem[Strou II]{lit-stro2}{Bjarne Stroustrup:\\\\
%{\\em Die C++ Programmiersprache\\/}\\\\
%2. Auflage\\\\
%Addison-Wesley, 1992
%}
%
%\\bibitem[Strou IV]{lit-stro4}{Bjarne Stroustrup:\\\\
%{\\em Die C++ Programmiersprache\\/}\\\\
%4. Auflage\\\\
%Addison-Wesley, 1999 % TODO: Datum strou4
%}
%
%\\bibitem[Cline: C++ FAQs]{lit-cppfaq}{Marshall Cline, Greg Lomow, Mike Girou:\\\\
%{\\em C++ FAQs\\/}\\\\
%2nd Edition\\\\
%Addison-Wesley, 1999\\\\
%{\\em Eine Sammlung vieler kleinerer Aspekte zu C++, CORBA und COM\\/}
%}
%
%\\bibitem[Josuttis: Stdbib.]{lit-josuttis-standardbibliothek}{Nicolai Josuttis::\\\\
%{\\em Die C++-Standardbibliothek\\/}\\\\
%Eine detaillierte Einführung in die vollständige ANSI/ISO-Schnittstelle\\\\
%1. Auflage\\\\
%ISBN 3-8273-1023-7\\\\
%Addison-Wesley, 1996
%}
%
%\\bibitem[RRZN]{lit-rrzn}{{\\em Die Programmiersprache C++ für C-Programmierer\\\\
%RRZN-Klassifikationsschlüssel SPR.C 2\\/}\\\\
%3. Auflage\\\\
%Revision B
%Regionales Rechenzentrum für Niedersachsen/Universität Hannover\\\\
%Juni 1993
%}
%
%
%\\bibitem[KW:0 ist false]{lit-cbuch}{Klaus Wachtler:\\\\
%{\\em 0 ist false, alles andere true}\\\\
%Selbstverlag Klaus Wachtler\\\\
%Breidingstraße 17\\\\
%29614 Soltau\\\\
%\\htmladdnormallink{http://www.wachtler.de}{http://www.wachtler.de}\\\\
%August 2001
%}
%
%
%\\bibitem[ct 9/94 Hartinger]{lit-ct-syntaxpuzzle}{Roland Hartinger:\\\\
%{\\em Syntax-Puzzle\\\\
%Die jüngsten C++-Erweiterungen\\/}\\\\
%c't 9/1994, S. 184\\\\
%Korrektur in c't 10/1994, S. 12\\\\
%{\\em Kurzabriß der neueren Sprachelemente (außer templates):\\\\
%Ausnahmebehandlung, RTTI, Namensräume (name spaces)\\/}
%}
%
%\\bibitem[ct 9/94 Hueskes]{lit-ct-hueskes}{Ralf Hüskes:\\\\
%{\\em Geduldsspiel\\\\
%Der kommende C++-Standard\\/}\\\\
%c't 9/1994, S. 180\\\\
%{\\em Zur Standardisierung von C++, Interview mit Bjarne Stroustrup\\/}
%}
%
%\\bibitem[ct 11/94 Langner]{lit-ct-langner}{Angelika Langner:\\\\
%{\\em Instantware\\\\
%Die neuen Standardklassen für C++\\/}\\\\
%c't 11/1994, S. 272\\\\
%}
%
%\\bibitem[c't 5/89 Bayerbäume]{lit-ct-bayerbaeume}{:\\\\ % Verfasser
%{\\em Bayer-Bäume\\\\ % Titel
%-\\/}\\\\ % Untertitel
%c't 5/89, S. 178\\\\ % Verlag, Jahr
%}
%
%\\bibitem[c't 6/89 Winkler/M.]{lit-ct-starke-typen}{Eckart Winkler,
%Dirk Meiners:\\\\ % Verfasser
%{\\em Starke Typen\\\\ % Titel
%Funktions- und Prozedurtypen in modernen Programmiersprachen\\/}\\\\ % Untertitel
%c't 6/89, S. 174\\\\ % Verlag, Jahr
%}
%
%%{\\em Kurze und verständliche Beschreibung der Übergabe von Funktionen
%%und Prozeduren als Parameter in C, Turbo-Pascal, und Modula-2\\/}
%
%
%\\bibitem[c't 6/89 Berchtold]{lit-ct-evolution-im-computer}{Stefan Berchtold:\\\\ % Verfasser
%{\\em Evolution im Computer\\\\ % Titel
%Optimierung mit genetischen Algorithmen\\/}\\\\ % Untertitel
%c't 6/89, S. 130\\\\ % Verlag, Jahr
%}
%
%%{\\em Übersichtliche Beschreibung des Konzepts der genetischen
%%Algorithmen, mit einem Beispiel in Pascal (Entwickeln einer
%%Spielstrategie für das Spiel {\\em Nimm\\/})\\/}
%
%\\bibitem[Eckel: TIC++ 1]{lit-tica1}{Bruce Eckel:\\\\
%{\\em Thinking in C++\\\\
%Volume 1\\/}\\\\
%\\htmladdnormallink{http://www.mindview.net/Books/DownloadSites}{http://www.mindview.net/Books/DownloadSites}
%}
%
%\\bibitem[Eckel: TIC++ 2]{lit-tica2}{Bruce Eckel:\\\\
%{\\em Thinking in C++\\\\
%Volume 2\\/}\\\\
%\\htmladdnormallink{http://www.mindview.net/Books/DownloadSites}{http://www.mindview.net/Books/DownloadSites}
%}
%
%\\bibitem[Eckel: TIJ]{lit-tij}{Bruce Eckel:\\\\
%{\\em Thinking in Java}\\\\
%\\htmladdnormallink{http://www.mindview.net/Books/DownloadSites}{http://www.mindview.net/Books/DownloadSites}
%}
%
%\\bibitem[KW-C++]{lit-kw-cpp} % Label fuer \\cite{...}
%{Klaus Wachtler:\\\\ % Verfasser
%{\\em Ein Überblick über die Programmierung mit C++}\\\\ % Untertitel
%Selbstverlag, 2002\\\\ % Verlag, Jahr
%\\htmladdnormallink{http://www.wachtler.de}{http://www.wachtler.de}\\\\
%}
%
%\\bibitem[KW-DLL]{lit-kw-dll} % Label fuer \\cite{...}
%{Klaus Wachtler:\\\\ % Verfasser
%{\\em Dynamische Bibliotheken unter Windows und Linux\\/}\\\\
%Selbstverlag 2002\\\\ % Verlag, Jahr
%}
%
%% [3] N. Wirth, Compilerbau, 4. Auflage, Stuttgart 1986
%
%% GNU Coding Standards:
%% http://www.gnu.org/prep/standards_toc.html
%
%\\bibitem[Muellges/R.]{lit-muellges-reutter}{G. Engeln-Müllges\\index{Engeln-Müllges, Gisela}, F. Reutter\\index{Reutter, Fritz}:\\\\
%{\\em Numerische Mathematik\\/}\\\\
%Bibliographisches Institut Mannheim\\\\
%ISBN 3-411-01688-4 \\\\ % ggf.ISBN
%}
%
%%{\\em Sehr praxisgerechte Darstellung der wichtigsten numerischen
%%Verfahren aus der Technik (Fehleranalyse, Lösen von Gleichungen,
%%numerische Lösung von linearen und nichtlinearen Gleichungssystemen\\index{Gleichungssystem},
%%Approximation\\index{Approximation}, Interpolation\\index{Interpolation}, numerisches Integrieren\\index{Integrieren},
%%Anfangswertprobleme\\index{Anfangswertprobleme}).
%%
%%Als Ergänzung ist eine Formelsammlung \\cite{lit-muellges-reutter-fs-f77} erhältlich.\\/}
%
%
%\\bibitem[Muellges/R./F77]{lit-muellges-reutter-fs-f77}{G. Engeln-Müllges\\index{Engeln-Müllges, Gisela}, F. Reutter\\index{Reutter, Fritz}:\\\\
%{\\em Formelsammlung zur Numerischen Mathematik mit Standard-FORTRAN~77-Programmen\\/}\\\\
%Bibliographisches Institut Mannheim\\\\
%ISBN 3-411-03125-5 \\\\ % ggf.ISBN
%}
%
%%{\\em \\index{Formelsammlung}Formelsammlung zum Nachschlagen als Ergänzung zu
%%\\cite{lit-muellges-reutter}; enthält alle Verfahren in Fortran\\index{Fortran}~77
%%formuliert. Analoge Ausgaben sind mit BASIC\\index{BASIC}, Pascal\\index{Pascal} und C\\index{C} erhältlich.\\/}
%
%
%\\bibitem[Solomon: Inside NT]{lit-solomon-inside-nt}{David A.\\ Solomon:\\\\ % Verfasser
%{\\em Inside Windows NT\\\\
%The Official Guide to the Architecture and Internals of Microsoft's
%Premier Operating System\\/}\\\\ % Untertitel
%Second Edition
%Microsoft Press 1998\\\\ % Verlag, Jahr
%ISBN 1-57231-677-2 % ggf.ISBN
%}
%
%\\bibitem[Solomon: Inside NT]{lit-solomon-inside-nt-dt} % Label fuer \\cite{...}
%{David A.\\ Solomon:\\\\ % Verfasser
%{\\em Inside Windows NT\\\\ % Titel
%Der offizielle Führer zur Architektur von Windows NT 4.0\\/}\\\\ % Untertitel
%Microsoft Press 1998\\\\ % Verlag, Jahr
%ISBN 3-86063-435-6% ggf.ISBN
%}
%
%\\bibitem[Solomon: Inside 2000 dt.]{lit-solomon-inside-zweitausend}{David A.\\ Solomon, Mark Russinovich:\\\\ % Verfasser
%{\\em Inside Microsoft Windows 2000\\\\ % Titel
%Der offizielle Leitfaden zur Architektur der Betriebssystemplattform
%Windows 2000\\/}\\\\ % Untertitel
%3. Auflage\\\\
%Microsoft Press \\\\ % Verlag, Jahr
%ISBN 3-86063-630-8
%}
%
%\\bibitem[Richter: Experten]{lit-richter-experten} % Label fuer \\cite{...}
%{Jeffrey Richter:\\\\ % Verfasser
%{\\em Microsoft Windows Programmierung für Experten\\\\ % Titel
%Profiwissen zur Programmierung von Anwendungen für Windows 98 und
%Windows 2000\\/}\\\\ % Untertitel
%Microsoft Press 2000\\\\ % Verlag, Jahr
%ISBN 86063-615-4% ggf.ISBN
%}
%
%\\bibitem[Sheldon: NT Sec.]{lit-sheldon-nt-security} % Label fuer \\cite{...}
%{Tom Sheldon:\\\\ % Verfasser
%{\\em Windows NT Security\\\\ % Titel
%Everything You Need to Protect Your Network\\/}\\\\ % Untertitel
%McGraw-Hill 1997\\\\ % Verlag, Jahr
%ISBN 0-07-882240-8% ggf.ISBN
%}
%
%\\bibitem[Bähring-Mikrorechner]{lit-baerhing-mikrorechner}
%{Helmut Bähring u.a.:\\\\ % Verfasser
%{\\em Mikrorechner-Systeme\\\\
%Mikroprozessoren, Speicher, Peripherie\\/}\\\\
%Springer-Verlag 1994\\\\
%ISBN 3-540-58362-9
%}
%
%
%\\bibitem[Krieg d.\\ Codes]{lit-krieg-der-codes} % Label fuer \\cite{...}
%{G.\\ P.\\ Zachary:\\\\ % Verfasser
%{\\em Der Krieg der Codes\\\\ % Titel
%Wie Microsoft ein neues Betriebssystem entwickelt.\\/}\\\\ % Untertitel
%1996\\\\
%ISBN 345511038X% ggf.ISBN
%}
%
%\\bibitem[MSDN]{lit-msdn}
%{Microsoft:\\\\ % Verfasser
%{\\em MS Developer Network}\\\\
%(Online-Dokumentation zu Developer Studio)
%}
%
%
%\\bibitem[Stev.:Adv.Prg.Unix]{lit-stevens-advanced-unix} % Label fuer \\cite{...}
%{W. Richard Stevens:\\\\ % Verfasser
%{\\em Advanced Programming in the Unix Environment\\/}\\\\ % Untertitel
%Addison Wesley 1993\\\\ % Verlag, Jahr
%ISBN 0-201-56317-7% ggf.ISBN
%}
%
%\\bibitem[Stevens:Sockets]{lit-stevens-sockets} % Label fuer \\cite{...}
%{W. Richard Stevens:\\\\ % Verfasser
%{\\em Unix Network Programming\\\\ % Titel
%Vol. 1: Networking APIs: Sockets and XTI\\/}\\\\ % Untertitel
%Prentice Hall 1997\\\\ % Verlag, Jahr
%ISBN 0-13-490012-X% ggf.ISBN
%}
%
%\\bibitem[Stevens:IPC]{lit-stevens-ipc} % Label fuer \\cite{...}
%{W. Richard Stevens:\\\\ % Verfasser
%{\\em Unix Network Programming\\\\ % Titel
%Vol. 2: Interprocess Communications\\/}\\\\ % Untertitel
%Second Edition\\\\
%Prentice Hall 1998\\\\ % Verlag, Jahr
%ISBN ISBN 0-13-081081-9 % ggf.ISBN
%}
%
%\\bibitem[Rago: Netw.Prog.]{citeRagoUNIXSVNetworkProgramming} % Label fuer \\cite{...}
%{Stephen A.\\ Rago:\\\\ % Verfasser
%{\\em UNIX System V Network Programming\\/}\\\\ % Untertitel
%Addison Wesley, 1993\\\\ % Verlag, Jahr
%ISBN 0-201-56318-5% ggf.ISBN
%}
%
%%{\\em Dieses Buch hat im Vorspann eine sehr übersichtliche und gut
%%verständliche Einführung in die Programmierung unter Unix; daher auch
%%sehr interessant, wenn man gar nichts mit Netzwerkprogrammierung zu
%%tun hat!
%%
%%Für Netzwerkprogrammierung selbst ist es eher uninteressant, weil der
%%Stoff nur unter System V R4 benutzbar ist (die
%%ganzen \\verb+t_+\\ldots-Funktionen
%%gemäß X/Open Transport Interface XTI).
%%Hier ist \\meinrefsiehe{Unix Network
%%Programming Vol. 1}{lit-stevens-sockets} geeigneter.\\/}
%
%
%\\bibitem[Riepe: Erbstücke]{lit-ix-riepe-erbstuecke} % Label fuer \\cite{...}
%{Michael Riepe:\\\\ % Verfasser
%{\\em Erbstücke\\\\ % Titel
%Umgang mit Shellvariablen\\/}\\\\ % Untertitel
%Heise Verlag iX August 2002\\\\ % Verlag, Jahr
%ISSN 0935-9680 % ggf.ISBN
%}
%
%\\bibitem[Riepe: Kreuz und quer]{lit-ix-riepe-kreuz-und-quer} % Label fuer \\cite{...}
%{Michael Riepe:\\\\ % Verfasser
%{\\em Kreuz und quer\\\\ % Titel
%Ein- und Ausgabeumlenkung in der Shell\\/}\\\\ % Untertitel
%Heise Verlag iX Oktober 2002\\\\ % Verlag, Jahr
%ISSN 0935-9680 % ggf.ISBN
%}
%
%%\\htmladdnormallink{http://www.codeguru.com/}{http://www.codeguru.com/}
%
%\\end{thebibliography}
\\end{document}
" abbrev-korrekt-latex-doc 0)
("Large" "{\\Large}" abbrev-korrekt-latex-large 0)
("sec" "\\section{}" abbrev-korrekt-latex-sec 0)
("tt" "{\\tt}" abbrev-korrekt-latex-em 0)
("gf" "\"`\"'" abbrev-korrekt-latex-gfuss 1)
("huge" "{\\huge}" abbrev-korrekt-latex-huge 0)
("ssec" "\\subsection{}" abbrev-korrekt-latex-sec 0)
("em" "{\\em\\/}" abbrev-korrekt-latex-em 7)
("large" "{\\large}" abbrev-korrekt-latex-large 0)
("sssec" "\\subsubsection{}" abbrev-korrekt-latex-sec 0)
("sf" "{\\sf}" abbrev-korrekt-latex-em 0)
("mrs" "\\meinrefsiehe" nil 0)
("verb" "\\verb" nil 5)
("LARGE" "{\\LARGE}" abbrev-korrekt-latex-large 0)
))
(define-abbrev-table 'lisp-mode-abbrev-table '(
))
(define-abbrev-table 'fundamental-mode-abbrev-table '(
))
(define-abbrev-table 'global-abbrev-table '(
))
Zurück zur Homepage
Erstellt: 07.12.2005
© Klaus Wachtler
