Recover from microbel

This commit is contained in:
Kursmester 2025-03-05 11:47:46 +01:00 committed by h7x4
commit c16cef839f
Signed by: oysteikt
GPG Key ID: 9F2F7D8250F35146
5 changed files with 892 additions and 0 deletions

23
.gnus Normal file

@ -0,0 +1,23 @@
;; Eksempel på .gnus-fil.
(setq user-mail-address "user@example.org")
(setq user-full-name "Navnet Mitt")
(setq gnus-select-method '(nntp "news.ntnu.no"))
(setq gnus-secondary-select-methods
'((nnimap "imap.stud.ntnu.no"
(nnimap-authinfo-file "~/.authinfo")
(nnimap-stream ssl))
(nnimap "imap.pvv.ntnu.no"
(nnimap-authinfo-file "~/.authinfo")
(nnimap-stream ssl))))
;; Filen ~/.authinfo inneholder følgende tekst (der BRUKERNAVN
;; erstattes med det aktuelle brukernavnet):
;; machine imap.stud.ntnu.no login BRUKERNAVN port imap
;; machine imap.pvv.ntnu.no login BRUKERNAVN port imap
(setq smtpmail-default-smtp-server "smtp.pvv.ntnu.no")
(setq smtpmail-local-domain "localhost")
(setq smtpmail-sendto-domain "localhost")

9
README.txt Normal file

@ -0,0 +1,9 @@
Materiale fra PVVs Emacs-kurs 12. april 2012.
Innhold:
* emacs-kurs.txt: teksten som ble vist på kurset
* kurs.el: inneholder kurs-mode, som ble brukt til å vise emacs-kurs.txt
* kill-ring.el: eksempel på elisp-kode som ble vist på kurset
* .gnus: eksempel på konfigurasjonsfil for Gnus
http://wiki.pvv.ntnu.no/pvv/Kurs/Emacs_(2012)

698
emacs-kurs.txt Normal file

@ -0,0 +1,698 @@
((Emacs-kurs))
((Installere Emacs.))
aptitude install emacs emacs23-el
(Erstatt «23» med nyeste versjon i pakkesystemet ditt.)
Debian-brukere bør i tillegg gjøre
aptitude install emacs23-common-non-dfsg
(Emacs-manualen er ikke fri nok for Debian.)
Windows-brukere bør installere Linux. Eller gå til
http://ftp.gnu.org/pub/gnu/emacs/windows/
De som bruker FreeBSD, NetBSD, Plan 9 eller andre rariteter finner ut
av dette på egen hånd.
((Starte Emacs.))
Skriv «emacs» på kommandolinjen, eller bruk pek-og-klikk-teknologi.
Hvis du ikke vil ha et X-vindu, skriv «emacs -nw» isteden.
((Tastekombinasjoner.))
Modifikatorer: C er control, M er meta (ofte merket «alt»).
`M-x' betyr «hold inne meta og trykk x».
`C-x k' betyr «hold inne control og trykk på x, slipp opp control,
trykk k».
`C-x C-s' betyr «hold inne control og trykk x, hold inne control og
trykk s» (det er ikke nødvendig å slippe control i mellomtiden).
((Åpne og lagre filer.))
`C-x C-f' (find-file). Kommando for å åpne en fil. (Filen trenger
ikke eksistere fra før).
`C-x C-s' (save-buffer). Lagre filen du holder på å redigere.
(Prøv dette nå).
((Funksjoner og kommandoer.))
Emacs består av mange funksjoner.
Noen av funksjonene er /interaktive/ funksjoner, også kjent som
/kommandoer/. Disse får man direkte tilgang til når man bruker Emacs.
(Andre funksjoner er hjelpefunksjoner for kommandoene.)
find-file og save-buffer er eksempler på kommandoer.
((Kjøring av kommandoer. Tastebindinger.))
Kommandoen `M-x' (execute-extended-command) kan brukes til å kjøre en
vilkårlig kommando.
For eksempel kan vi si `M-x find-file' for å kjøre kommandoen
find-file. (Prøv dette nå).
Men det er slitsomt. Derfor er de mest brukte kommandoene bundet til
taster. For eksempel er find-file bundet til `C-x C-f'.
Vi kan endre tastebindingene etter eget forgodtbefinnende. Dette skal
vi se på senere.
((Litt om minibufferet.))
Kommandoer som vil ha argumenter fra brukeren leser inn disse via
minibufferet. For eksempel må find-file vite hvilken fil som skal
åpnes.
Iblant kommer det også nyttige meldinger i minibufferet. For eksempel
får vi en bekreftende melding der når en fil er lagret.
Når vi holder på å skrive inn en tastekombinasjon vises det vi har
skrevet så langt i minibufferet. Hvis vi for eksempel tar en pause
mitt i inntastingen av `C-x C-s' ser vi at `C-x-' vises.
((Hjelp!))
Emacs er flink til å svare hvis man spør om hjelp.
Hjelpekommandoene er bundet til tastekombinasjoner som begynner med `C-h'.
De to nyttigste:
`C-h t' (help-with-tutorial): Emacs-tutorialen. Fint sted å starte.
`C-h k' (describe-key): Spør om hva en tast gjør. (Prøv dette, for
eksempel med `C-x C-s').
((Mer hjelp.))
`C-h f' (describe-function): Spør om hva en funksjon gjør. (Prøv
dette, for eksempel med find-file).
`C-h w' (where-is): Spør om hvilken tast en kommando er bundet til.
(Prøv dette, for eksempel med find-file).
`C-h a' (apropos-command): Søk etter kommando.
((Info.))
Emacs har en innebygd leser for dokumentasjon i info-format.
Tilfeldigvis er Emacs-manualen skrevet i info.
`C-h i' (info): Start info-leseren.
I info kan man si `mEmacs' for å åpne Emacs-manualen.
((Stopp! Stopp!))
Noen ganger har man lyst til å avbryte det Emacs holder på med.
For eksempel har vi trykket `C-x C-f' (find-file), og Emacs ber om et
filnavn, men vi finner ut at vi ikke ville åpne en fil allikevel. Vi
har et kjempeproblem!
Heldigvis finnes det en redning. Den heter `C-g' (keyboard-quit), og
er meget anvendelig.
((Stopp! Stopp! (forts.)))
Så:
* Hvis du vil avbryte tastekombinasjonen du er i ferd med å skrive,
* hvis Emacs ber om noe i minibufferet og du bare vil få det vekk,
* hvis Emacs bruker altfor lang tid på å kjøre en kommando,
* hvis du har trykket på noe rart og det skjer skumle ting,
* hvis du bare vil forsikre deg om at Emacs ikke driver med noe
muffens;
* * * trykk `C-g'! * * *
((Sammendrag; det viktigste vi har lært til nå.))
Dette er de to tastekombinasjonene man må huske:
`C-g' (keyboard-quit): Avbryt det som skjer.
`C-h k' (describe-key): Vis hva en tastekombinasjon gjør.
Alt annet kan glemmes. Man kan alltid bruke `C-h k' når man for
eksempel er usikker på om `C-d' er bundet til delete-char eller til
destroy-universe-and-reboot, og man kan (ofte) redde dagen med `C-g'
når man har tabbet seg ut.
((Tekstredigering.))
Point er stedet i teksten der den blinkende (eller ikke blinkende)
firkanten er. Vi kan flytte point med piltaster eller
`C-p' (previous-line)
`C-b' (backward-char) `C-f' (forward-char)
`C-n' (next-line)
Mark er en annen posisjon i teksten. Den blir værende hvor den er
selv om vi flytter point. Vi kan sette mark til der point er med
`C-SPC' (set-mark-command).
Regionen er området mellom point og mark. Mange redigeringskommandoer
opererer på regionen.
Hvis transient-mark-mode er på vises regionen med bakgrunnsfarge.
((Drap og gjenoppliving.))
`C-w' (kill-region): Drep teksten i regionen. Død tekst blir borte
fra bufferet, men kan gjenopplives senere på andre steder.
(«cut»).
`C-y' (yank): Sett inn den forrige teksten som ble drept.
(«paste»).
`M-w' (kill-ring-save): Som kill-region, men teksten blir ikke borte.
(«copy»).
`C-k' (kill-line): Drep teksten fra point til slutten på linjen.
((Kill ring.))
Drept tekst legges i «kill ring»-en. Denne inneholder all teksten som
er blitt drept.
Ved å si `C-y' får vi det som ble drept sist. Hvis vi deretter sier
`M-y' (yank-pop) får vi isteden det som ble drept nest sist.
Ved å gjenta `M-y' kan vi bla gjennom hele kill ringen til vi finner
det vi leter etter.
((Undo.))
`C-_' (undo): Reverser siste endring.
Det å undo-e kan også undo-es. Dette er forvirrende.
To (eller flere) undo-kall på rad vil fortsette å undo-e ting som ble
gjort tidligere, men så snart man har gjort en annen kommando enn undo
(for eksempel bare flyttet point) blir undo-operasjonene også ting som
kan undo-es. Dette er forvirrende.
((Søk.))
`C-s' (isearch-forward): Søk forover i teksten. Emacs begynner å søke
mens vi skriver inn søketeksten, og søkeresultatene oppdateres hele
tiden.
`C-r' (isearch-backward): Søk bakover, som med isearch-forward.
Mens vi holder på å søke kan vi trykke `C-s' eller `C-r' for å hoppe
til neste eller forrige treff.
((Søk/erstatt.))
`M-%' (query-replace): Erstatt en tekststreng med en annen. For hvert
treff på søkestrengen (fra point og fremover) kan vi velge mellom
`SPC' (erstatt denne og gå til neste) og `n' (hopp til neste uten å
erstatte denne), eller `!' for å erstatte alle.
((Søk/erstatt med regulære uttrykk.))
Generell regel: Bruk en ekstra modifikatortast for å gjøre om vanlige
søkekommandoer til søkekommandoer som bruker regulære uttrykk.
`C-M-s' (isearch-forward-regexp).
`C-M-%' (query-replace-regexp).
((Gjenta kommandoer.))
Vi kan sende et numerisk argument til en kommando ved å si `C-(tall)'
foran kommandoen. Mange kommandoer tolker et slikt argument som et
antall ganger de skal gjenta seg selv.
For eksempel kan vi si
`C-8 C-n' for å gå 8 linjer ned (`C-n' er next-line),
`C-1 C-2 A' for å skrive AAAAAAAAAAAA,
`C-3 C-0 C-0 )' for å sette inn 300 sluttparenteser.
(Det sistnevnte kan være nyttig i lange Lisp-programmer).
((Annen bruk av numerisk argument.))
Enkelte kommandoer tolker det numeriske argumentet som noe annet enn
et antall ganger de skal gjenta seg selv.
Et par eksempler:
`C-l' (recenter-top-bottom) skroller slik at linjen vi står på kommer
midt i, øverst, eller nederst i vinduet (avhengig av hvor mange ganger
man har trykket på den). Med numerisk argument gjør den noe annet:
argumentet tolkes som hvor langt ned i vinduet linjen skal vises.
`C-0 C-l': vis linjen vi står på øverst
`C-5 C-l': vis linjen vi står på som sjette linje
`C-- C-2 C-l': vis linjen vi står på som den andre nedenfra
`C-v' (scroll-up) flytter teksten opp én skjerm (dette er ellers kjent
som «page down»). Med numerisk argument flytter den isteden teksten
opp så mange linjer som argumentet sier.
((Buffere.))
Teksten vi redigerer i Emacs lever i et buffer.
Emacs har ett buffer for hver åpen fil, pluss noen spesielle buffere
som ikke har noen fil knyttet til seg.
Vi kan skifte hvilket buffer som vises med kommandoen `C-x b'
(switch-to-buffer).
Vi kan trykke `C-x C-b' for å få et nytt buffer med en liste over alle
bufrene.
((Modi.))
Hvert buffer har en modus. Modusen bestemmer hvordan teksten vises og
hva de forskjellige tastene gjør.
Det finnes tre hovedtyper modi:
(1) Modi for tekst, for eksempel rene tekstfiler, HTML eller TeX.
(2) Modi for programmering, en for hvert språk (C, Lisp, Python, Perl etc).
(3) Modi for spesielle bufre som ikke redigeres. For eksempel er det
egne modi for bufrene med hjelpeinformasjon (fra `C-h k' e.l.)
bufferliste (fra `C-x C-b') etc.
((Primær- og sekundærmodi.))
Modiene vi beskrev over kalles primærmodi (engelsk: major modes).
Et buffer har til enhver tid eksakt en primærmodus.
Det finnes også sekundærmodi (engelsk: minor modes). Hvert buffer kan
ha vilkårlig mange (0 eller flere) sekundærmodi.
Primærmodusen er knyttet til hva slags tekst som er i bufferet og
hvordan den skal behandles. Sekundærmodi er små (eller store)
«features» som kan skrus av og på.
((Noen sekundærmodi.))
* column-number-mode: Vis kolonnenummer
* linum-mode: Viser linjenummer foran hver linje.
* flyspell-mode: Automatisk stavekontroll.
`C-h i mEmacs mMinor Modes'
((Moduslinjen.))
Den nest nederste linjen kalles moduslinjen og inneholder mye
spennende informasjon om bufferet som vises.
-CS:CH- BUF POS LINE (MAJOR MINOR)------
BUF: bufferets navn
POS: hvor i bufferet vi er (Top/Bot/nn%).
LINE: linjenummeret point er på
MAJOR MINOR: modiene til bufferet
CS (ett tegn) beskriver tegnkodingen for bufferet:
'-': ingen spesiell tegnkoding
'U': UTF-8
'1': Latin-1
CH (to tegn) beskriver hvorvidt bufferet kan endres og/eller er
endret:
'--': kan endres, ikke endret siden forrige lagring
'**': kan endres og er endret siden forrige lagring
'%%': kan ikke endres (read-only)
'%*': kan ikke endres, men er endret allikevel
((Eksempel på moduslinje.))
-U:**- emacs-kurs.txt 58% L418 (Text)-------
Dette betyr at:
* vi er på linje 418 i bufferet emacs-kurs.txt.
* omtrent 58% av bufferet er over det vi ser.
* bufferet bruker primærmodusen Text.
* bufferet kodes i UTF-8.
* bufferet er endret siden forrige lagring.
((Vinduer.))
Vi kan splitte opp skjermen i vinduer og vise ett buffer i hvert
vindu.
`C-x 2' (split-window-vertically): Lag to vinduer under hverandre.
`C-x 3' (split-window-horizontally): Lag to vinduer ved siden av
hverandre.
`C-x o' (other-window): Hopp til det andre vinduet (eller det neste,
hvis det er flere enn to).
`C-x 0' (delete-window): Fjern dette vinduet.
`C-x 1' (delete-other-windows): Fjern alle de andre vinduene.
((Modi for tekst.))
.txt-filer åpnes i text-mode. Kommandoene som brukes her kan også
brukes i modi for HTML og LaTeX, og mange av dem kan brukes i
programmeringsmodi også.
Emacs antar at man bruker punktum og to mellomrom for å separere
setninger, og to linjeskift for å separere avsnitt.
((Tekstmoduskommandoer.))
Man kan operere på ord, setninger og avsnitt:
`M-f' (forward-word), `M-b' (backward-word), `M-d' (kill-word).
`M-t' (transpose-words): bytter ord om to.
`M-a' (backward-sentence), `M-e' (forward-sentence), `M-k' (kill-sentence).
`M-{' (backward-paragraph), `M-}' (forward-paragraph),
`M-h' (mark-paragraph).
((Flere tekstmoduskommandoer.))
`M-q' (fill-paragraph): Bryt om linjene slik at dette avsnittet får
passe lange linjer. En meget praktisk kommando.
`C-x C-l' (downcase-region): gjør alle bokstavene i regionen små.
`C-x C-u' (upcase-region): GJØR ALLE BOKSTAVENE I REGIONEN STORE.
((ASCII-tabeller.))
`M-x table-insert'
+---+---+---+
|foo|bar|baz|
+---+---+---+
|3 |4 |5 |
+---+---+---+
Endre cellebredde: `C-<', `C->'
Endre cellehøyde: `C-{', `C-}'
((Programmering.))
Emacs velger riktig programmeringsmodus etter filendelsen.
Hvis font-lock-mode er på (skriv (global-font-lock-mode 1) i .emacs
for å skru den på) får man mange fine farger.
Fra manualen:
The existing programming language major modes include Lisp, Scheme (a
variant of Lisp) and the Scheme-based DSSSL expression language, Ada,
ASM, AWK, C, C++, Delphi (Object Pascal), Fortran, Icon, IDL (CORBA),
IDLWAVE, Java, Metafont (TeX's companion for font creation), Modula2,
Objective-C, Octave, Pascal, Perl, Pike, PostScript, Prolog, Python,
Ruby, Simula, Tcl, and VHDL. An alternative mode for Perl is called
CPerl mode. Modes are available for the scripting languages of the
common GNU and Unix shells, VMS DCL, and MS-DOS/MS-Windows `BAT'
files. There are also major modes for editing makefiles, DNS master
files, and various sorts of configuration files.
((Indentering.))
`TAB' (c-indent-command, lisp-indent-line etc): Fiks innrykket til
linjen point er på. Fungerer uansett hvor på linjen man er og om den
allerede er rykket inn riktig.
`C-M-\' (indent-region): Fiks innrykket til alle linjene i regionen.
For å fikse indenteringen i hele bufferet: `C-x h C-M-\'.
(`C-x h' er mark-whole-buffer).
`C-j' (newline-and-indent): Lag en ny linje og rykk inn passe mye.
((Kompilering, debugging.))
`M-x compile': Kjører make i den nåværende katalogen.
`M-x gdb': Start gdb.
((SLIME.))
SLIME: Superior Lisp Interaction Mode for Emacs.
SLIME forandrer Emacs fra en fantastisk editor til et fantastisk
utviklingsmiljø for Common Lisp.
Vi får innebygd dokumentasjon av funksjoner og variabler, et REPL vi
kan kommunisere med, direktelinker til Hyperspecen, en vakker
animasjon og mye annet fint.
For å starte herligheten: `M-x slime'
(Installer først pakken 'slime', samt en Common Lisp-implementasjon
hvis du ikke allerede har det.)
((Tastemakroer.))
Noen ganger har vi lyst til å gjenta den samme sekvensen med taster
flere ganger. Da kan vi ta den opp og spille den av.
`C-x (' (kmacro-start-macro): Begynn å ta opp makro.
`C-x )' (kmacro-end-macro): Avslutt opptak.
`C-x e' (kmacro-end-and-call-macro): Kjør makroen.
Etter `C-x e' kan vi hakke på `e' for å gjenta makroen vilkårlig mange
ganger.
((Ymse praktiske ting: Åpne filer via SSH.))
Når vi bruker `C-x C-f' (find-file) kan vi skrive
/ssh:maskin:fil
istedenfor en lokal fil.
((Ymse praktiske ting: Bokmerker.))
`C-x r m mjau <RET>': Sett bokmerket «mjau» her.
`C-x r b mjau <RET>': Hopp til bokmerket «mjau».
`C-x r l': Vis alle bokmerkene.
`M-x bookmark-save': Lagre bokmerkene.
((Emacs har alt.))
A novice of the temple once approached the Master Programmer with a
question: "Master, does Emacs have the Buddha nature?" the novice
asked.
The Master Programmer had been in the temple for many years and
could be relied upon to know these things. He thought for several
minutes before replying: "I don't see why not. It's bloody well got
everything else."
((Emacs har alt (forts.)))
* dired: Katalogeditor.
* calendar: Kalender.
* calc: Meget avansert RPN-kalkulator.
* shell: Kjør et eksternt skall (f.eks. bash).
* eshell: Skall skrevet i elisp.
* Gnus: Usenet- og epost-klient.
* ERC: IRC-klient.
((Emacs har alt, inkludert spill og annet fjas.))
* tetris
* doctor
* life
* dunnet
((Konfigurering og utvidelser.))
For å konfigurere Emacs: Skriv elisp-kode i ~/.emacs
For å utvide Emacs: Skriv elisp-kode i ~/.emacs
(Større utvidelser bør plasseres i egne filer, med endelse .el).
((Dått emacs.))
Vi kan konfigurere Emacs ved å sette variabler, kalle funksjoner som
gjør spennende ting, definere egne funksjoner, binde taster til
funksjoner etc.
Noen eksempler:
;; forteller SLIME hvor lispen vi vil bruke bor:
(setq inferior-lisp-program "/usr/bin/sbcl")
;; skrur på font-lock-mode (fine farger):
(global-font-lock-mode 1)
;; Binder taster til kommandoer jeg liker:
(global-set-key (kbd "C-M-y") 'clipboard-yank)
(global-set-key (kbd "C-M-<") 'bs-cycle-previous)
(global-set-key (kbd "C-M-z") 'bs-cycle-next)
((Elisp.))
Emacs Lisp (elisp) er en Lisp-dialekt. Den er litt gammeldags og rar
(blant annet har den ikke leksikalsk skop), men for øvrig et meget
godt språk å skrive teksteditorer i.
*scratch*-bufferet fungerer som en REPL: Trykk `C-j' på slutten av en
linje for å evaluere den.
Vi kan også (i *scratch* og andre elisp-bufre) si `C-M-x' for å
evaluere toppnivåuttrykket rundt point. For å laste inn en hel fil,
bruk `M-x load-file'.
Sammen med den innebygde hjelpefunksjonaliteten (`C-h k', `C-h f' med
venner) gjør dette Emacs til et utmerket utviklingsmiljø for
elisp-kode.
((Eksempel på elisp-kode))
kill-ring.el
slutt.

25
kill-ring.el Normal file

@ -0,0 +1,25 @@
;; Eksempel på elisp-kode.
(defun show-kill-ring ()
"Shows the contents of the kill ring in another window."
(interactive)
(let ((buf (get-buffer-create "*kill ring*"))
(i 0))
(save-excursion
(set-buffer buf)
(delete-region (point-min) (point-max))
(dolist (item kill-ring)
(setq i (1+ i))
(insert (format "%d: %s\n" i
(replace-regexp-in-string
"\n" "\\\\n"
(cut-string item 70 "..."))))))
(display-buffer buf)))
(defun cut-string (str len ellipsis)
(if (> (length str) len)
(concat (substring str 0 (- len (length ellipsis)))
ellipsis)
str))
(global-set-key (kbd "C-x C-y") 'show-kill-ring)

137
kurs.el Normal file

@ -0,0 +1,137 @@
;; Modus for Emacs-kurs.
;; Last inn denne filen med `M-x load-file <RET>' og si `M-x
;; kurs-mode' i emacs-kurs.txt.
(defface kurs-overskrift-face
`((((type tty) (class color))
(:foreground "blue"))
(((type tty) (class mono))
(:inverse-video t))
(((class color) (background dark))
(:foreground "lightblue" :weight bold :height 200))
(((class color) (background light))
(:foreground "darkblue" :weight bold :height 200))
(t (:foreground "blue" :weight bold :height 200)))
"Kurs-overskrift")
(defvar kurs-tittel "kurs")
(defvar kurs-mode-map nil)
(setq kurs-mode-map (make-sparse-keymap))
(define-key kurs-mode-map " " 'kurs-neste-side)
(define-key kurs-mode-map "n" 'kurs-neste-side)
(define-key kurs-mode-map "p" 'kurs-forrige-side)
(define-key kurs-mode-map (kbd "<DEL>") 'kurs-forrige-side)
(define-key kurs-mode-map "g" 'kurs-hopp)
(define-key kurs-mode-map "<" 'kurs-topp)
(define-key kurs-mode-map ">" 'kurs-bunn)
(define-key kurs-mode-map "\M-?" 'kurs-info)
(defun kurs-neste-side (&optional arg)
"Gå til neste side i kurset.
Med prefiksargument N, N sider forover."
(interactive "p")
(when (> (point) (point-min))
;; avoid moving two pages when point is at end of page
(backward-char))
(widen)
(forward-page arg)
(narrow-to-page))
(defun kurs-forrige-side (&optional arg)
"Gå til forrige side i kurset.
Med prefiksargument N, N sider bakover."
(interactive "p")
(widen)
(backward-page)
(backward-page arg)
(narrow-to-page))
(defun kurs-topp ()
"Gå til første side."
(interactive)
(widen)
(goto-char (point-min))
(narrow-to-page))
(defun kurs-bunn ()
"Gå til siste side."
(interactive)
(widen)
(goto-char (point-max))
(narrow-to-page))
(defun kurs-sidenr ()
"Returnerer nåværende sidenummer."
(save-restriction
(widen)
(save-excursion
(let ((sidenr 1)
(pt (point)))
(goto-char 1)
(while (re-search-forward page-delimiter pt t)
(setq sidenr (1+ sidenr)))
sidenr))))
(defun kurs-antall-sider ()
"Returnerer antall sider i bufferet."
(save-restriction
(widen)
(save-excursion
(goto-char (point-max))
(kurs-sidenr))))
(defun kurs-hopp (n)
"Gå til en bestemt side."
(interactive "nHopp til side: ")
(let ((hopp-pt
(save-restriction
(widen)
(save-excursion
(let ((sidenr 1)
(pt (point)))
(goto-char 1)
(while (and (< sidenr n)
(re-search-forward page-delimiter))
(setq sidenr (1+ sidenr)))
(point))))))
(widen)
(goto-char hopp-pt)
(narrow-to-page)))
(defun kurs-info ()
"Vis nåværende sidenummer og antall sider."
(interactive)
(message "Side %d av %d" (kurs-sidenr) (kurs-antall-sider)))
(setq kurs-mode-font-lock-keywords
'(("^((.*))$" . 'kurs-overskrift-face)))
(defun kurs-finn-tittel ()
(save-excursion
(goto-char (point-min))
(search-forward-regexp "((\\(.*\\)))")
(buffer-substring-no-properties
(match-beginning 1)
(match-end 1))))
(define-derived-mode kurs-mode fundamental-mode "kurs"
"Durmodus for Emacs-kurs.
Begrenser vist tekst til én side av gangen. Bruk `n' og `p' for
å skifte side. For å se alle sidene, si `C-x n w' (widen). Bruk
`M-?' for å finne ut hvor i filen du er."
(setq mode-name "kurs")
(setq font-lock-defaults '(kurs-mode-font-lock-keywords))
(make-local-variable 'kurs-tittel)
(setq kurs-tittel (kurs-finn-tittel))
(setq header-line-format
'((:eval kurs-tittel)
": side "
(:eval (number-to-string (kurs-sidenr)))
" av "
(:eval (number-to-string (kurs-antall-sider)))))
(narrow-to-page))
(provide 'kurs-mode)