Een introductie in programmeren in Emacs Lisp ¶

1.1 Lisp lijsten ¶

In Lisp ziet een lijst er zo uit: '(roos viool madelief boterbloem). Deze lijst wordt voorafgegaan door een enkele apostrof. Het kon net zo goed als volgt geschreven worden, wat meer lijkt op de soort van lijsten waar je waarschijnlijk bekend mee bent:

'(roos
  viool
  madelief
  boterbloem)

De elementen van deze lijst zijn de namen van vier verschillende bloemen, onderling gescheiden door witte ruimte en omgeven door haakjes, net als bloemen in een veld met een stenen muur er omheen.

• Getallen, lijsten binnen lijsten
• Lisp atomen
• Whitespace in lijsten
• GNU Emacs helpt je om lijsten te typen

'(deze lijst heeft (van binnen een lijst))

'(deze lijst bevat "tekst tussen aanhalingstekens.")

'(deze lijst
    lijkt op dit)

'(deze lijst lijkt op dit)

1.2 Draai een programma ¶

Een lijst in Lisp—elke lijst—is een programma om te draaien. Wanneer je het draait (wat in Lisp-jargon evalueren is), doet de computer een van deze drie dingen: doe niets behalve de lijst zelf teruggeven; een foutmelding geven; of het eerste symbool in de lijst behandelen als commando om iets te doen. (Meestal is dat laatste natuurlijk wat je echt wilt!)

De enkele apostrof, ', die ik aan de voorkant van enkele voorbeeld lijsten in de voorgaande hoofdstukken gebruikte, heten een quote. Wanneer die aan een lijst voorafgaan, dan vertelt dat Lisp om niets met de lijst te doen, anders dan te accepteren precies zoals die is geschreven. Maar wanneer er geen quote aan de lijst voorafgaat, dan is het eerste element in de lijst speciaal: het is een commando voor de computer om te gehoorzamen. (In Lisp, heten deze commando’s functies.) De eerder genoemde lijst (+ 2 2) is een instructie om iets met de rest van de lijst te doen: tel de getallen die volgen op.

Wanneer je dit binnen GNU Emacs in Info leest, dan kun je de lijst als volgt evalueren: ga met de cursor direct achter het rechtse haakje sluiten staan van de volgende lijst en typ vervolgens C-x C-e:

(+ 2 2)

Je ziet het getal 4 verschijnen in het echogebied ². (Wat je zojuist gedaan hebt is het evalueren van de lijst. Het echogebied is de regel aan de onderkant van het scherm dat de echotekst toont.) Probeer nu hetzelfde met een gequote lijst: plaats de cursor meteen achter de volgende lijst en type C-x C-e:

'(dit is een gequote lijst)

Je ziet (dit is een gequote lijst) in het echogebied verschijnen.

Wat je in beide gevallen deed is het geven van een commando aan een programma in GNU Emacs met de naam Lisp interpreter—de interpreter een commando geven om de expressie te evalueren. De naam van de Lisp interpreter komt van het woord voor de taak die een mens uitvoert die de betekenis van de expressie bedenkt—die het interpreteert.

Je kunt ook een atoom evalueren dat geen deel van een lijst is—een die niet door haakjes ingesloten is. Weer vertaalt de Lisp interpreter van de voor mensen leesbare expressie naar de taal van de computer. Maar voor we dit bespreken (zie Variabelen), bespreken we eerste wat de Lisp interpreter doet wanneer je een fout maakt.

1.3 Een foutmelding genereren ¶

Deels zodat je je geen zorgen hoeft te maken wanneer je het per ongeluk doet, geven we nu een commando aan de Lisp interpreter dat een foutmelding genereert. Dit is een onschuldige activiteit, en wij zullen inderdaad vaker proberen expres een foutmelding te genereren. Wanneer je eenmaal het jargon begrijpt, kunnen foutmeldingen informatief zijn. In plaats van “fout”-meldingen zouden ze “hulp”-meldingen moeten heten. Zij zijn als wegwijzers voor een reiziger in een vreemd land. Ze ontcijferen kan moeilijk zijn, maar wanneer je ze begrijpt wijzen ze je de weg.

De foutmelding wordt gegenereerd door een ingebouwde GNU Emacs debugger. Wij gaan de debugger binnen. Je verlaat de debugger met het typen van q.

Wat we gaan doen is het evalueren van een lijst die niet gequote is en niet een betekenisvol commando als eerste element heeft. Hier is een lijst die bijna gelijk is aan die we niet gebruikt hebben, maar zonder de voorafgaande enkele quote. Positioneer de cursor direct er achter en type C-x C-e:

(dit is een ongequote lijst)

Een *Backtrace* window opent waarin je het volgende zou moeten zien:

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function dit)
  (dit is een ongequote lijst)
  eval((dit is een ongequote lijst) nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

Je cursor staat in dit venster (mogelijk moet je een paar seconden wachten voordat het zichtbaar wordt). Om de debugger af te sluiten en het venster te laten verdwijnen, typ je:

q

Gelieve q nu te typen, zodat je zelfverzekerd de debugger weet te verlaten. Type vervolgens weer C-x C-e om er opnieuw in te gaan.

Gebaseerd op wat we al weten, kunnen we bijna deze foutmelding lezen.

Je leest de *Backtrace* buffer van beneden naar boven; het vertelt je wat Emacs deed. Toen je C-x C-e typte, maakte je een interactieve aanroep naar het commando eval-last-sexp. eval is een afkorting van “evalueer” en sexp is een afkorting voor “symbolische expressie”, de expressie vlak voor de cursor.

Elke regel er boven vertelt je wat de Lisp interpreter er na evalueerde. De meest recente actie staat bovenaan. Het buffer heet het *Backtrace* buffer omdat het je in staat stelt Emacs achterwaarts te volgen.

Bovenaan het *Backtrace* buffer zie je de regel:

Debugger entered--Lisp error: (void-function dit)

De Lisp interpreter probeerde het eerste atoom van de lijst te evalueren, het woord ‘dit’. Het is deze actie die de foutmelding ‘(void-function dit)’ genereerde.

De melding bevat de woorden ‘void-function’ en ‘dit’.

Het woord ‘functie’ is een keer eerder genoemd. Het is een erg belangrijk woord. Voor onze doeleinden kunnen we definiëren door te zeggen dat een ‘functie’ een verzameling instructies is die de computer vertellen iets te doen.

Nu beginnen we de foutmelding te begrijpen: ‘void-function dit’. De functie (het woord ‘dit’) heeft geen definitie van enige verzameling instructies voor de computer om uit te voeren.

Het ietwat vreemde woord ‘void-function’ is ontworpen voor de manier waarop Emacs Lisp is geïmplementeerd, dat is wat het doet wanneer een symbool geen functiedefinitie heeft waaraan het gekoppeld is, de plaats die de instructies zou moeten bevatten is leeg.

Aan de andere kant, omdat we in staat waren 2 plus 2 succesvol op te tellen door (+ 2 2) te evalueren, kunnen we afleiden dat het symbool + een verzameling instructies moet hebben voor de computer om te gehoorzamen en dat deze instructies het optellen van de getallen achter de + moeten zijn.

Het is mogelijk te voorkomen dat Emacs de debugger in gaat in situaties zoals deze. Hier leggen we niet uit hoe je dat doet, maar we vertellen hoe het resultaat er uit ziet, omdat je een vergelijkbare situatie kunt tegenkomen wanneer er een bug zit in de Emacs code die je gebruikt. In zulke gevallen zie je een foutmelding met maar een regel, het verschijnt in het echogebied en ziet er als volgt uit:

Symbol's function definition is void: dit

De melding gaat weg zodra je een toets aanslaat of zelfs de cursor verplaatst.

We kennen de betekenis van het woord ‘Symbool’. Het refereert naar de eerste atoom van de lijst, het woord ‘dit’. Het woord ‘functie’ refereert naar de instructies die de computer vertellen wat te doen. (Technisch gezien, vertelt het symbool de computer waar de instructies zijn te vinden, maar dit is een complicatie dit we op dit moment kunnen negeren.)

De foutmelding kan begrepen worden: ‘Symbol's function definition is void: dit’. Het symbool (het woord ‘dit’) mist instructies die de computer kan uitvoeren.

1.4 Symboolnamen en functiedefinities ¶

We kunnen een ander kenmerk van Lisp verwoorden op basis van wat we tot nu toe besproken hebben—en belangrijk kenmerk: een symbool, zoals +, is zelf geen verzameling van instructies die de computer kan uitvoeren. In plaats daarvan wordt het symbool gebruikt, misschien tijdelijk, als een manier om de instructies te lokaliseren. Namen van mensen werken op de zelfde manier. Ik kan worden gerefereerd als ‘Bob’. Ik ben echter niet de letters ‘B’, ‘o’ en ‘b’ maar ik ben of was het bewustzijn dat consequent met een bepaalde levensvorm wordt geassocieerd. De naam is niet mij, maar het kan worden gebruikt om naar mij te refereren.

In Lisp kan een enkele verzameling instructies meerdere namen hebben. De computer instructies om getallen op te tellen kan bijvoorbeeld zijn gekoppeld aan zowel het symbool plus als het symbool + (en zijn dat in sommige Lisp-dialecten). Onder mensen kan ik gerefereerd met zowel ‘Robert’ als met ‘Bob’ en ook nog andere woorden.

Aan de andere kant kan maar aan een functiedefinitie tegelijk zijn gekoppeld. Anders zou de computer in verwarring raken over welke definitie te gebruiken. Wanneer dit onder mensen het geval zou zijn, dan kan er in de hele wereld maar een persoon de naam ‘Bob’ hebben. Echter de functiedefinitie naar de naam naar refereert kan makkelijk worden aangepast. (Zie Installeer een functiedefinitie.)

Omdat Emacs erg groot is, is het gebruikelijk om de symbolen zo te benoemen dat zij het deel van Emacs waar zij thuishoren identificeren. Alle namen voor functies die met Texinfo te maken hebben beginnen met ‘texinfo-’ en die voor de functies die met e-mail lezen te maken hebben beginnen met ‘rmail-’.

1.5 De Lisp interpreter ¶

Op basis van wat we nu gezien hebben kunnen we beginnen te achterhalen wat de Lisp interpreter doet wanneer we de opdracht geven een lijst te evalueren. Eerst kijkt die of er een quote voor de lijst staat. Als die er is, dan geeft de interpreter ons slechts de lijst. Aan de andere kant, als er geen quote is, dan kijkt de interpreter naar het eerste element van de lijst om te zien of die een functiedefinitie heeft. Wanneer dat het geval is, dan voert de interpreter de instructies in de functiedefinitie uit. Zo niet, dan drukt de interpreter een foutmelding af.

Dit is hoe Lisp werkt. Simpel. Er zijn aanvullende complicaties waar we zo aan toe komen, maar dit zijn de basisprincipes. Om Lisp-programma’s te schrijven moet je natuurlijk weten hoe je functiedefinities schrijft en aan een naam koppelt, en hoe je dit doet zonder zelf of de computer in verwarring te brengen.

• Complicaties
• Byte compiling

1.6 Evaluatie ¶

Wanneer de Lisp interpreter een expressie verwerkt, dan is de term voor die activiteit evaluatie. We zeggen dat de interpreter “de expressie evalueert”. Ik heb deze term verschillende keren eerder gebruikt. Het woord komt van het gebruik in alledaagse taal, “de waarde vaststellen”, “taxeren”, volgens de Webster’s New Collegiate Dictionary.

• Hoe de Lisp interpreter acteert
• Geneste lijsten evalueren

(+ 2 (+ 3 3))

(+ 2 (+ 3 3))

1.7 Variabelen ¶

In Emacs Lisp kan een symbool een waarde aan zich gekoppeld hebben, net zoals het een functiedefinitie aan zich gekoppeld kan hebben. Die twee zijn verschillend. De functiedefinitie is een verzameling instructies die de computer zal gehoorzamen. Daartegenover is een waarde iets, zoals een getal of een naam die kan variëren (daarom wordt zo’n symbool een variabele genoemd). De waarde van een symbool kan elke expressie in Lisp zijn, zoals een symbool, getal, lijst of string. Een symbool die een waarde heeft wordt vaak een variabele genoemd.

Een symbool kan zowel een functiedefinitie als een waarde tegelijkertijd aan zich gekoppeld hebben. Of het kan slechts een van die tee hebben. De twee staan los van elkaar. Dit is ongeveer vergelijkbaar me de manier waarop Cambridge kan refereren naar een stad in Massachusetts en informatie aan de naam gekoppeld kan hebben, zoals “geweldig programmeercentrum”.

Een andere manier om hierover te denken is een symbool voor te stellen als een ladekast. De functiedefinitie wordt in de ene lade gestopt, de waarde in een andere, enzovoorts. Wat in de lade die de waarde bevat gestopt is kan worden veranderd zonder effect te hebben op de lade die de functiedefinitie bevat, en omgekeerd.

• fill-column, een voorbeeldvariabele
• Foutmelding voor een symbool zonder functie
• Foutmelding voor een symbool zonder waarde

fill-column

(fill-column)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
  (fill-column)
  eval((fill-column) nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

(+ 2 2)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
  eval(+)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------

1.8 Argumenten ¶

Laten we nog eens naar ons oude voorbeeld kijken om te zien hoe informatie tussen functies doorgegeven wordt, de optelling van twee plus twee. In Lisp schrijven we dit als volgt:

(+ 2 2)

Wanneer je deze expressie evalueert verschijnt het getal in je echogebied. Wat de Lisp interpreter doet is het optellen van de getallen die volgen na de +.

De getallen toegevoegd aan + heten de argumenten van de functie +. Deze getallen vormen de informatie die doorgegeven wordt aan de de functie.

Het woord “argument” komt van de manier waarop het gebruikt wordt in wiskunde en refereert niet naar een dispuut tussen twee mensen. In plaats daarvan refereert het naar de informatie gegeven aan een functie, in dit geval aan de +. In Lisp zijn de argumenten van een functie de atomen of lijsten die volgen op de functie. De waarde die de evaluatie van deze atomen of lijsten teruggeeft worden doorgegeven aan de functie. Verschillende functies vereisen een verschillend aantal argumenten, sommige functies vereisen er geen.³

• Data typen van argumenten
• Een argument als de waarde van een variabele of lijst
• Variabel aantal argumenten
• Het verkeerde object type als argument gebruiken
• De message functie

(concat "abc" "def")

(substring "The quick brown fox jumped." 16 19)

(+ 2 fill-column)

(concat "De " (number-to-string (+ 2 fill-column)) " rode vossen.")

(+)       ⇒ 0

(*)       ⇒ 1

(+ 3)     ⇒ 3

(* 3)     ⇒ 3

(+ 3 4 5) ⇒ 12

(* 3 4 5) ⇒ 60

(+ 2 'hello)

---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error:
         (wrong-type-argument number-or-marker-p hello)
  +(2 hello)
  eval((+ 2 'hello) nil)
  elisp--eval-last-sexp(t)
  eval-last-sexp(nil)
  funcall-interactively(eval-print-last-sexp nil)
  call-interactively(eval-print-last-sexp nil nil)
  command-execute(eval-print-last-sexp)
---------- Buffer: *Backtrace* ----------

(message "Dit bericht verschijnt in het echogebied!")

(message "De naam van dit buffer is: %s." (buffer-name))

(message "De waarde van fill-column is %d." fill-column)

(message "Er zijn %d %s in het kantoor!"
         (- fill-column 14) "paarse olifanten")

(message "He saw %d %s"
         (- fill-column 32)
         (concat "red "
                 (substring
                  "The quick brown foxes jumped." 16 21)
                 " leaping."))

1.9 De waarde van een variabele zetten ¶

Er zijn verschillende manieren waarop een variabele een waarde kan krijgen. Een van de manieren is het gebruik van de speciale vorm setq. Een andere manier is het gebruik van let (zie let). (Het jargon voor dit proces is bind een variabele aan een waarde.)

De volgende paragrafen beschrijven niet alleen hoe setq werkt maar illustreren tevens hoe argumenten worden doorgegeven.

• Gebruik van setq
• Tellen

(setq bloemen '(roos viool madelief boterbloem))

bloemen

'bloemen

(setq carnivoren '(leeuw tijger luipaard)

(setq bomen '(den spar eik esdoorn)
      herbivoren '(gazelle antiloop zebra)

(setq counter 0)                ; Laten wij dit de initialisator noemen.

(setq counter (+ counter 1))    ; Dit is de incrementer.

counter                         ; Dit is de teller.

1.10 Samenvatting ¶

Lisp leren is net zo iets als een heuvel beklimmen, waar het eerste deel het steilste is. Je hebt inmiddels het moeilijkste deel beklommen, wat overblijft wordt makkelijker naarmate je verder komt.

Samenvattend,

• Lisp programma’s zijn gemaakt van expressies, elke lijsten of enkelvoudige atomen zijn.
• Lijsten zijn gemaakt van nul of meer atomen of binnenliggende lijsten, gescheiden door witte ruimte en omgeven door haakjes. Een lijst kan leeg zijn.
• Atomen zijn multi-karakter symbolen, zoals forward-paragraph, enkele-karakter symboleen zoals +, strings of karakters tussen dubbele aanhalingstekens, of getallen.
• Een getal evalueert naar zichzelf.
• Een string tussen dubbele aanhalingstekens evalueert ook naar zichzelf.
• Wanneer je een symbool op zichzelf evalueert, wordt zijn waarde teruggegeven.
• Wanneer je een lijst evalueert, kijkt de Lisp interpreter naar het eerste symbool in de lijst en vervolgens naar de functiedefinitie die aan dat symbool gebonden is. Daarvan worden de instructies in de functiedefinitie uitgevoerd.
• Een enkele quote ‘'’ vertelt de Lisp interpreter dat het de daaropvolgende expressie moet teruggeven zoals die is geschreven, en niet evalueren alsof de quote er niet was.
• Argumenten vormen de informatie die aan een functie wordt doorgegeven. De argumenten voor een functie worden berekend door de rest van de elementen van de lijst te evalueren, waarvan de functie het eerste element is.
• Een functie geeft altijd een waarde terug wanneer die wordt geëvalueerd (tenzij het een fout krijgt). Ook kan die een actie uitvoeren dat een zij-effect is. In veel gevallen is het creëren van zij-effecten het primaire doel.

1.11 Oefeningen ¶

Enkele simpele oefeningen:

• Genereer een foutmelding door een geschikt symbool te evalueren dat niet tussen haakjes staat.
• Genereer een foutmelding door een geschikt symbool te evalueren dat tussen haakjes staat.
• Maak een teller die met twee verhoogt in plaats van een.
• Schrijf een expressie die een boodschap in het echogebied toont wanneer die wordt geëvalueerd.

2.1 Buffer namen ¶

De twee functies buffer-name en buffer-file-name tonen het verschil tussen een buffer en een bestand. Wanneer je volgende expressie evalueert, (buffer-name), verschijnt de naam van het buffer in het echogebied. Wanneer je (buffer-file-name) evalueert, verschijnt de naam van het bestand waar het buffer naar refereert in het echogebied. Meestal is de naam die (buffer-name) teruggeeft hetzelfde als de naam van het bestand waarnaar het refereert, en is de naam die (buffer-file-name) teruggeeft de volledige padnaam van het bestand.

Een bestand en een buffer zijn twee verschillende entiteiten. Een bestand is informatie permanent opgeslagen op de computer (tenzij je het verwijdert). Een buffer daarentegen is informatie binnen Emacs, die verdwijnt aan het einde van de editing sessie (of wanneer je het buffer killt). Meestal bevat een buffer informatie die je van een bestand gekopieerd hebt, we zeggen dat het buffer het bestand bezoekt. Deze kopie is waar je op werkt en wijzigt. Veranderingen in het buffer wijzigen het bestand niet, totdat je het buffer opslaat. Wanneer je het buffer opslaat, wordt het buffer gekopieerd naar het bestand en zo permanent opgeslagen.

Wanneer je dit in Info leest binnen Emacs, kan je elk van de volgende expressies evalueren door de cursor er achter te zetten en C-x C-e te typen.

(buffer-name)

(buffer-file-name)

Wanneer ik dit in Info doe, geeft evaluatie van (buffer-name) de waarde "*info*" terug, en is de waarde die de evaluatie van (buffer-file-name) teruggeeft nil.

Anderzijds, terwijl ik dit document schrijf is de waarde die het evalueren van (buffer-name) teruggeeft, "introduction.texinfo" en de waarde die de evaluatie van (buffer-file-name) teruggeeft "/gnu/work/intro/introduction.texinfo".

De eerste is de naam van het buffer en het tweede is de naam van het bestand. In Info is de naam van het buffer "*info*". Info wijst niet naar een bestand, waardoor nil het resultaat van de evaluatie (buffer-file-name) is. Het symbool nil is van het Latijnse woord voor “niets”, in dit geval betekent het dat het buffer met geen enkel bestand geassocieerd is. (In Lisp betekent nil ook “onwaar” en is synoniem voor de lege lijst, ().)

Wanneer ik schrijf is de naam van mijn buffer "introduction.texinfo". De naam van het bestand waar het naar wijst is "/gnu/work/intro/introduction.texinfo".

(In de expressies vertellen de haakjes aan de Lisp interpreter om buffer-name en buffer-file-name als functies te behandelen. Zonder de haakjes zou de interpreter proberen de symbolen als variabelen te behandelen. Zie Variabelen.)

Ondanks het onderscheid tussen bestanden en buffers zie je vaak dat mensen aan een bestand refereren wanneer ze een buffer bedoelen en andersom. Inderdaad zeggen de meeste mensen “ik edit een bestand” in plaats van “ik edit een buffer dat ik binnenkort naar een bestand ga saven”. Het is vrijwel altijd duidelijk van de context wat mensen bedoelen. Wanneer we met computerprogramma’s werken is het belangrijk het onderscheid in gedachten te houden, want computers zijn niet zo slim als mensen.

Overigens komt het woord “buffer” van de betekenis van het woord als een “kussen dat de kracht van een botsing opvangt”. In de eerste computers verzachtte een buffer de interactie tussen bestanden en de centrale verwerkingseenheid. De drums of tapes die het bestand bevatten en de centrale verwerkingseenheid waren onderdelen van de apparatuur die zeer verschillend van elkaar waren en op hun eigen snelheid werkten, in stoten. Uiteindelijk groeide het buffer van een intermediair, een tijdelijke opslagplaats uit naar de plaats waar het werk wordt gedaan. Deze transformatie is ongeveer zoals een kleine zeehaven uitgroeide naar een grote stad. Eens was het slechts de plaats waar lading tijdelijk in magazijnen werd opgeslagen voordat het op schepen werd verladen en daarna een zakelijk en cultureel centrum op zichzelf werd.

Niet alle buffers zijn geassocieerd met bestanden. Bijvoorbeeld een *scratch*-buffer bezoekt geen enkel bestand. Op dezelfde manier is het *Help*-buffer met geen enkel bestand geassocieerd.

Wanneer je vroeger geen ~/.emacs bestand had en een Emacs sessie startte door het typen van alleen het commando emacs, zonder enig bestand te noemen, startte Emacs met het *scratch* buffer zichtbaar. Tegenwoordig zie je een startscherm. Je kunt een van de commando’s volgen die op het startscherm gesuggereerd worden, een bestand bezoeken of op q drukken om het startscherm te sluiten en het *scratch*-buffer te bereiken.

Schakel over naar het *scratch*-buffer en typ (buffer-name), plaats de cursor direct er achter, en typ vervolgens C-x C-e om de expressie te evalueren. De naam "*scratch*" wordt teruggegeven en verschijnt in het echogebied. "*scratch*" is de naam van het buffer. Wanneer je (buffer-file-name) in het *scratch* buffer typt en dat evalueert, verschijnt nil in het echogebied, net zoals dat gebeurt wanneer je (buffer-file-name) in Info evalueert.

Overigens, als je in het *scratch* buffer bent en door een expressie teruggeven waarde in het *scratch* wilt laten verschijnen in plaats van het echogebied, typ je C-u C-x C-e in plaats van C-x C-e. Dit zorgt dat de teruggegeven waarde achter de expressie verschijnt. Het buffer ziet er zo uit:

(buffer-name)"*scratch*"

Je kunt dit niet in Info doen, omdat Info read-only is en je niet toestaat de inhoud van het buffer te wijzigen. Maar je kunt dit in elk buffer doen dat je kunt editen. Wanneer je code schrijft of documentatie (zoals dit boek), is deze eigenschap erg nuttig.

2.2 Buffers pakken ¶

De buffer-name-functie geeft de naam van het buffer. Om het buffer zelf te krijgen is een andere functie benodigd, de functie current-buffer. Wanneer je deze functie in code gebruikt krijg je het buffer zelf.

Een naam en het object of entiteit waar de naam aan refereert zijn van elkaar verschillend. Jij bent niet je naam. Je bent een persoon die anderen bij naam noemen. Wanneer je vraagt om met George te spreken en iemand geeft je een kaart met de letters ‘G’, ‘e’, ‘o’, ‘r’, ‘g’ en ‘e’, dan kan dat je amuseren, maar je zal er niet tevreden mee zijn. Je wilt niet met de naam spreken, maar met de persoon die met die naam genoemd is. Een buffer is vergelijkbaar: de naam van het scratch-buffer is *scratch*, maar de naam is niet het buffer. Om het buffer zelf te krijgen, heb je een functie nodig zoals current-buffer.

Er is echter een kleine complicatie: wanneer je current-buffer zelf evalueert in een expressie, zoals we hier gaan doen, dan wordt de de representatie van de naam van het buffer getoond zonder de inhoud van het buffer. Emacs werkt op deze manier wegens twee redenen: het buffer kan duizenden regels lang zijn—te lang om handig weer te geven, en een ander buffer kan dezelfde inhoud maar een andere naam hebben en het is belangrijk om onderscheid tussen hen te maken.

Hier is een expressie die de functie bevat:

(current-buffer)

Wanneer je deze expressie in Info in Emacs op de gebruikelijke manier evalueert, verschijnt #<buffer *info*> in het echogebied. Het speciale formaat geeft aan dat het buffer zelf is teruggegeven in plaats van slechts de naam.

Overigens, hoewel je een getal of symbool in een programma kunt typen, kan je dit niet doen met de getoonde representatie van een buffer: de enige manier om een buffer zelf te krijgen is met een functie zoals current-buffer.

Een gerelateerde functie is other-buffer. Deze geeft de meest recent geselecteerde buffer terug, anders dan degene waar je nu in bent, en niet de getoonde representatie van de naam. Wanneer je recentelijk heen en weer tussen het *scratch* buffer geschakeld hebt, dan zal other-buffer dat buffer teruggeven.

Dit zie je door de volgende expressie te evalueren:

(other-buffer)

Je zou #<buffer *scratch*> moeten zien verschijnen in het echogebied, of de naam van welk ander buffer je het meest recent van teruggeschakeld hebt. ⁶

2.3 Van buffer verwisselen ¶

De other-buffer-functie biedt eigenlijk een buffer wanneer het gebruikt wordt als een argument voor een functie die er een vereist. We zien dit door other-buffer en switch-to-buffer te gebruiken om naar een ander buffer te schakelen.

Maar eerst een korte introductie van de switch-to-buffer functie. Toen je heen en weer schakelde tussen Info en het *scratch*-buffer om (buffer-name) te evalueren, heb je hoogstwaarschijnlijk C-x b en daarna *scratch* getypt⁷ toen je in het minibuffer gevraagd werd naar de naam van het buffer waar naar toe te schakelen. De toetsaanslagen C-x b laten de Lisp interpreter de interactieve switch-to-buffer-functie evalueren. Zoals we eerder gezegd hebben, dit is hoe Emacs werkt: verschillende toetsaanslagen roepen verschillende functies aan of draaien die. Bijvoorbeeld C-f roept forward-char aan, M-e roept forward-sentence aan, enzovoorts.

Door switch-to-buffer in een expressie te schrijven en het een buffernaam te geven om naar te schakelen, kunnen we buffers schakelen op dezelfde manier zoals C-x b doet:

(switch-to-buffer (other-buffer))

Het symbool switch-to-buffer is het eerste element in de lijst, dus zal de Lisp interpreter het als een functie behandelen en de instructies uitvoeren die daaraan gekoppeld zijn. Maar voordat die dat doet, merkt de interpreter op dat other-buffer tussen haakjes staat en eerst dat symbool verwerkt. other-buffer is het eerste (en in dit geval enige) element in deze lijst, dus de Lisp interpreter roept of runt deze functie. Het geeft een ander buffer terug. Vervolgens runt de interpreter switch-to-buffer en geeft het andere buffer als argument door, waar Emacs naar zal omschakelen. Wanneer je dit in Info leest, probeer het dan nu direct. Evalueer de expressie. (Typ C-x b RET om terug te gaan.) ⁸

In de programmeervoorbeelden in volgende secties van dit document zie je de functie set-buffer vaker dan switch-to-buffer. Dit is wegens een verschil tussen computerprogramma’s en mensen: mensen hebben ogen en verwachten het buffer te zien waarop ze werken op hun computerterminals. Dit is zo voor de hand liggend, het spreekt bijna voor zich. Echter, programma’s hebben geen ogen. Wanneer een computerprogramma op een buffer werkt, dan hoeft dat buffer niet op het scherm zichtbaar te zijn.

switch-to-buffer is ontworpen voor mensen en doet twee verschillende dingen: het schakelt het buffer waar de aandacht van Emacs op is gevestigd en het schakelt het buffer dat getoond wordt in het venster naar een nieuw buffer. set-buffer anderzijds doet meer een enkel ding: het schakelt de aandacht van het computerprogramma naar een ander buffer. Het buffer op het scherm blijft onveranderd (uiteraard gebeurt er niets totdat het commando klaar is met lopen).

Ook hebben we net een ander jargon term geïntroduceerd, het woord aanroepen. Wanneer je een lijst evalueert waar het eerste symbool een functie is, dan roep je die functie aan. Het gebruik van deze term komt voort uit het begrip van de functie als entiteit dan iets voor je kan doen wanneer je het aanroept—net als een loodgieter een entiteit is die een lek kan repareren wanneer je hem of haar roept.

2.4 Buffergrootte en de locatie van point ¶

Laten wij tenslotte naar enkele nogal eenvoudige functies kijken, buffer-size, point, point-min en point-max. Deze geven informatie over de grootte van een buffer en de locatie van point daarin.

De functie buffer-size vertelt je hoe groot het huidige buffer is. Dit houdt in dat de functie de som van het aantal karakters in het buffer teruggeeft.

(buffer-size)

Je kunt dit op de gebruikelijke manier evalueren door de cursor achter de expressie te plaatsen en C-x C-e te typen.

In Emacs wordt de huidige positie van de cursor point genoemd. De expressie (point) geeft een getal terug dat je vertelt waar de cursor is gepositioneerd als een telling van het aantal karakters vanaf het begin van het buffer tot point.

Je kunt de karaktertelling voor point in dit buffer zien door het op de gebruikelijke manier evalueren van de volgende expressie:

(point)

Terwijl ik dit schrijf is de waarde van point 65724. De point functie wordt vaak gebruikt in sommige voorbeelden later in dit boek.

De waarde van point hangt natuurlijk af van zijn locatie in het buffer. Wanneer je point op deze plek evalueert, is het getal groter:

(point)

Voor mij is de waarde van point op deze plek 66043, wat betekent dat er 319 karakters (inclusief spaties) tussen de twee expressies zijn. (Ongetwijfeld zie je verschillende getallen, omdat ik dit heb geschreven heb na de eerste evaluatie van point.)

De functie point-min lijkt enigszins op point, maar het geeft de waarde van de minimum toegestane waarde van point in het huidige buffer. Dit is het getal 1 tenzij versmallen van toepassing is. (Versmallen is het mechanisme waarmee je jezelf of een programma beperkt tot operaties op slechts een deel van een buffer. Zie Versmallen en verbreden.) Evenzo geeft de functie point-max de maximum toegestane waarde van point in het huidige buffer.

2.5 Oefening ¶

Vindt een bestand waarmee je werkt en ga naar het midden. Vindt zijn buffernaam, bestandsnaam, lengte en je positie in het bestand.

3.1 De defun macro ¶

In Lisp heeft een symbool zoals mark-whole-buffer code aan zich gekoppeld die de computer vertelt wat te doen wanneer die functie wordt aangeroepen. Deze code heet de functiedefinitie en is gecreëerd door het evalueren van een Lisp expressie die start met het symbool defun (wat een afkorting is van definieer functie).

In volgende secties kijken we naar functiedefinities van de Emacs broncode, zoals mark-whole-buffer. In deze sectie beschrijven we een eenvoudige functiedefinitie zodat je kunt zien hoe die eruitzien. Dat voorbeeld gebruikt rekenkunde omdat het tot een eenvoudig voorbeeld leidt. Sommige mensen houden niet van voorbeelden met rekenkunde, echter wanneer je zo’n persoon bent, wanhoop niet. Nauwelijks enige code die we in de rest van deze introductie behandelen heeft met rekenkunde of wiskunde te maken. De voorbeelden hebben hoofdzakelijk op de een of andere manier met tekst te maken.

Een functiedefinitie bestaat uit maximaal vijf onderdelen volgend op het woord defun:

1. De naam van het symbool waaraan de functiedefinitie gekoppeld moet worden.
2. Een lijst met de argumenten die aan de functie zullen worden doorgegeven. Wanneer geen argumenten aan de functie zullen worden doorgegeven is dit een lege lijst, ().
3. Documentatie die de functie beschrijft. (Technisch optioneel, maar sterk aanbevolen.)
4. Optioneel een expressie die de functie interactief maakt zodat je die kunt gebruiken door M-x gevolgd door de naam van de functie te typen, of door het typen van een passende toets of toetscombinatie.
5. De code die de computer instrueert wat de doen de body van de functiedefinitie.

Het is nuttig om de vijf delen van een functiedefinitie te beschouwen als een sjabloon met vijf slots voor elk onderdeel:

(defun functienaam (argumenten...)
  "optionele-documentatie..."
  (interactive argument-doorgevende-info)     ; optioneel
  body...)

Als een voorbeeld is hier de code voor een functie die zijn argument met 7 vermenigvuldigt. (Het voorbeeld is niet interactief. Zie Een functie interactief maken, voor die informatie.)

(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))

Deze definitie begint met een haakje en het symbool defun, gevolgd door de naam van de functie.

De naam van de functie wordt gevolgd door een lijst die de argumenten bevat die aan de functie zullen worden doorgegeven. Deze lijst heet de argumentlijst. In dit voorbeeld heeft de lijst maar één element, het symbool getal. Wanneer de functie wordt gebruikt wordt het symbool gebonden aan de waarde die als argument van de functie is gebruikt.

In plaats van te kiezen voor het woord getal als naam van het argument had ik elke andere naam kunnen pakken. Bijvoorbeeld had ik kunnen kiezen voor het woord multiplicant. Ik pakte het woord “getal” omdat het vertelt wat voor soort waarde bedoeld is voor het slot, maar ik net zo goed het woord “multiplicant” kunnen kiezen om de rol aan te geven die de in dit slot geplaatste waarde speelt in de werking van de functie. Ik had het ook foogle kunnen noemen, maar dat zou een slechte keuze zijn omdat het niet aan mensen vertelt wat het betekent. De keuze van de naam is aan de programmeur en moet zo gekozen worden dat het de betekenis van de functie duidelijk maakt.

Je kunt inderdaad elke naam die je maar wilt kiezen voor een symbool in de argumentlijst, zelfs de naam van een symbool die in een andere functie gebruikt wordt: de naam die je gebruikt in de argumentlijst is privé voor die specifieke definitie. In die definitie refereert de naam naar een andere entiteit dan elk gebruik van de zelfde naam buiten de functiedefinitie. Stel je hebt de bijnaam “Kleintje” in je familie, dan refereren familieleden met “Kleintje” naar jou. Maar buiten jouw familie, bijvoorbeeld in een speelfilm, refereert de naam “Kleintje” naar iemand anders. Omdat de naam in de argumentlijst privé is voor de functiedefinitie kan je de waarde van zo’n symbool binnen de body van de functie wijzigen zonder de waarde buiten de functie te wijzigen. Het effect is vergelijkbaar met dat geproduceerd door de let-expressie. (Zie let.)

De argumentlijst wordt gevolgd door de documentatiestring die de functie beschrijft. Dat is wat je ziet als je C-h f en de naam van de functie typt. Overigens, wanneer je een documentatiestring als deze schrijft moet je van de eerste regel een complete zin maken, omdat sommige commando’s, zoals apropos, alleen de eerste regel tonen van een meerregelige documentatiestring. Ook moet je de tweede regel van een documentatiestring, wanneer die er is, niet laten inspringen, omdat dit er raar uitziet wanner je C-h f (describe-function) gebruikt. De documentatiestring is optioneel, maar is zo nuttig, dat die deel van vrijwel elke functie die je schrijft zou moeten zijn.

De derde regel van ons voorbeeld bestaat uit de body van de functiedefinitie. (De meeste functiedefinities zijn natuurlijk langer dan deze.) In dit voorbeeld is de body de lijst (* 7 getal), die zegt vermenigvuldig de waarde van getal met 7. (In Emacs Lisp, is * de functie voor vermenigvuldiging, net zoals + de functie voor optellen is.)

Wanneer je de functie vermenigvuldig-met-zeven gebruikt evalueert getal naar het daadwerkelijk getal dat je wilt gebruiken. Hier is een voorbeeld dat toont hoe je vermenigvuldig-met-zeven gebruikt, maar probeer het nu nog niet te evalueren!

(vermenigvuldig-met-zeven 3)

Het symbool getal, gespecificeerd in de functiedefinitie in de volgende sectie, is gebonden aan de waarde 3 in het daadwerkelijk gebruik van de functie. Merk op dat hoewel getal tussen haakjes in de functiedefinitie stond, het argument dat aan de functie vermenigvuldig-met-zeven wordt doorgegeven niet tussen haakjes staat. De haakjes worden in de functiedefinitie geschreven zodat de computer uit kan zoeken waar de argumentlijst eindigt en de rest van de functie begint.

Wanneer je dit voorbeeld evalueert, krijgt je waarschijnlijk een foutmelding. (Ga je gang, probeer het!) Dit is omdat we de functiedefinitie hebben geschreven maar de computer nog niet op de hoogte gebracht hebben van de definitie—wij hebben de functiedefinitie nog niet in Emacs geladen. Het installeren van een functie is het proces dat de Lisp interpreter op de hoogte brengt van de functie. Het installeren wordt in de volgende sectie beschreven.

3.2 Installeer een functiedefinitie ¶

Wanneer je dit binnen Info in Emacs leest, kan je de functie vermenigvuldig-met-zeven proberen door eerst de functiedefinitie te evalueren en daarna (vermenigvuldig-met-zeven 3) te evalueren. Een exemplaar van de functiedefinitie volgt. Plaats de cursor achter het laatste haakje van de functiedefinitie en typ C-x C-e. Wanneer je dit doet, verschijnt vermenigvuldig-met-zeven in het echogebied. (Wat dit betekent is dat wanneer een functiedefinitie wordt geëvalueerd, de waarde die het teruggeeft de naam van de gedefinieerde functie is.) Tegelijkertijd installeert deze actie de functiedefinitie.

(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))

Met het evalueren van deze defun heb je zojuist vermenigvuldig-met-zeven in Emacs geïnstalleerd. De functie is nu net zo goed onderdeel van Emacs als forward-word.(vermenigvuldig-met-zeven blijft geïnstalleerd totdat je Emacs afsluit. Om de code automatisch opnieuw te laden wanneer je Emacs start, zie Installeer code permanent.)

• Het effect van de installatie
• Wijzig een functiedefinitie

(vermenigvuldig-met-zeven 3)

vermenigvuldig-met-zeven is an interpreted-function.

(vermenigvuldig-met-zeven GETAL)
Vermenigvuldig-met-zeven GETAL met zeven.

(defun vermenigvuldig-met-zeven (getal)       ; Tweede versie.
  "Multiply GETAL by seven."
  (+ getal getal getal getal getal getal getal))

3.3 Een functie interactief maken ¶

Je maakt een functie interactief door een lijst die begint met de speciale vorm interactive direct achter de documentatie. Een gebruiker kan een interactieve functie starten door het typen van M-x en daarna de naam van de functie, of door het typen van de toetscombinatie waaraan die is gebonden, bijvoorbeeld door het typen van C-n voor next-line of C-x h voor mark-whole-buffer.

Het is interessant dat wanneer je een interactieve functie interactief aanroept, de teruggegeven waarde niet automatisch in het echogebied wordt getoond. Dit is omdat je vaak een interactieve functie aanroept wegens de zij-effecten, zoals een woord of regel verder gaan, en niet voor de teruggegeven waarde. Wanneer de teruggegeven waarde elke keer dat je een toets aanslaat in het echogebied getoond zou worden, zou dat erg afleiden.

• Een interactieve vermenigvuldig-met-zeven, een overzicht
• Een interactieve vermenigvuldig-met-zeven

(defun vermenigvuldig-met-zeven (getal)       ; Interactieve versie.
  "Vermenigvuldig GETAL met zeven."
  (interactive "p")
  (message "Het resultaat is %d" (* 7 getal)))

(defun vermenigvuldig-met-zeven (getal)       ; Interactieve versie.
  "Vermenigvuldig GETAL met zeven."
  (interactive "p")
  (message "Het resultaat is %d" (* 7 getal)))

(message "Het resultaat is %d" (* 7 getal))

(message "Het resultaat is %d" (* 7 5))

3.4 Verschillende opties voor interactive ¶

In het voorbeeld gebruikte vermenigvuldig-met-zeven "p" als argument voor interactive. Dit argument vertelde Emacs om door wat je typte, hetzij C-u gevolgd door een getal of META gevold door een cijfer, te interpreteren als een commando om dat getal door te geven aan de functie als zijn argument. Emacs heeft meer dan twintig karakters voorgedefinieerd om met interactive te gebruiken. In vrijwel alle gevallen maakt een van deze opties het je mogelijk de juiste informatie interactief aan een functie door te geven. (Zie Code Characters for interactive in The GNU Emacs Lisp Reference Manual.)

Beschouw de functie zap-to-char. De interactieve expressie daarvan is

(interactive "p\ncZap to char: ")

Het eerste deel van het argument van interactive is ‘p’, waarmee je al vertrouwd bent. Dit argument vertelt Emacs een prefix als getal te interpreteren om aan de functie door te geven. Je geeft het prefix op hetzij door C-u gevolgd door een getal te typen, of door het typen van META gevolgd door een cijfer. Het prefix is het aantal van het opgegeven karakter. Dus als je prefix drie is en het opgegeven karakter ‘x’, dan verwijder je alle tekst tot en met de derde volgende ‘x’. Wanneer je geen prefix gebruikt dan verwijder je alle tekst tot en met het gespecificeerde karakter, maar niet meer.

De ‘c’ vertelt de functie de naam van het karakter tot waar te verwijderen.

Meer formeel, een functie met twee of meer argumenten kan voor elk argument informatie doorgegeven krijgen door delen toe te voegen aan de string die volgt op interactive. Wanneer je dit doet is de informatie die doorgegeven wordt in dezelfde volgorde als gespecificeerd is de interactive lijst. In de string is elk deel gescheiden van het volgende deel door een ‘\n’, wat een nieuwe regel is. Bijvoorbeeld, je kunt ‘p’ opvolgen met een ‘\n’ en een ‘cZap to char: ’. Dit laat Emacs de waarde doorgeven van het prefix-argument (als er een is) en het karakter.

In dit geval ziet de functiedefinitie er als volgt uit, waarbij arg en char de symbolen zijn waaraan interactive het prefix-argument en het gespecificeerde karakter bindt:

(defun name-of-function (arg char)
  "documentation..."
  (interactive "p\ncZap to char: ")
  body-of-function...)

(De spatie achter de dubbele punt in de prompt maakt dat het er beter uitziet wanneer je wordt geprompt. Zie De definitie van copy-to-buffer, bijvoorbeeld.)

Wanneer een functie geen argumenten heeft, hoeft interactive er geen te hebben. Zo’n functie bevat de eenvoudige expressie (interactive). De functie mark-whole-buffer is er zo een.

Daarnaast kun je, wanneer de speciale letter-codes niet geschikt zijn voor jouw applicatie, je eigen argumenten als lijst doorgeven aan interactive.

Zie De definitie van append-to-buffer, voor een voorbeeld. Zie Using Interactive in The GNU Emacs Lisp Reference Manual, voor een meer complete uitleg over deze techniek.

3.5 Code permanent installeren ¶

Wanneer je een functiedefinitie installeert door het te evalueren, blijft het geïnstalleerd totdat je Emacs sluit. De volgende keer dat je een nieuwe sessie van Emacs start, is de functie niet geïnstalleerd tenzij je de functiedefinitie opnieuw evalueert.

Op een gegeven moment wil je de code automatisch geïnstalleerd hebben wanneer je een nieuwe Emacs sessie start. Er zijn verschillende manieren om dit te doen:

• Wanneer je code hebt die uitsluitend voor jezelf is, kan je de code voor de functiedefinitie opnemen in je .emacs initialisatiebestand.
• Een andere manier is de functiedefinities die je geïnstalleerd wilt hebben zelf in een of meer bestanden opnemen en de functie load gebruiken om Emacs ze te laten evalueren en daarmee elk van de functies in de bestanden installeren. Zie Bestanden laden.
• Ten derde, wanneer je code hebt die je systeem-breed wilt gebruiken, is het gebruikelijk die in een bestand op te nemen met de naam site-init.el, die wordt geladen wanneer Emacs wordt gebouwd. Dit maakt de code beschikbaar voor iedereen die jouw machine gebruikt. (Zie het bestand INSTALL dat onderdeel is van je Emacs distributie.)

Tenslotte, wanneer je code hebt die iedereen die Emacs gebruikt zou willen hebben, dan kun je het op een computernetwerk posten of een exemplaar naar de Free Software Foundation sturen. (Wanneer je dit doet, breng dan alsjeblieft de code en de bijbehorende documentatie onder een licentie die andere mensen toestaat het te draaien, kopiëren, bestuderen, aan te passen en verder te distribueren en die je beschermt tegen dat je werk van je afgenomen wordt.) Wanneer je een exemplaar van jouw code naar de Free Software Foundation stuurt, en jezelf en anderen juist beschermt, dan zou het in een volgende release van Emacs kunnen worden opgenomen. Dit is grotendeels hoe Emacs over de jaren gegroeid is, door donaties.

Zie Contributing to Emacs Development in The GNU Emacs Manual, over hoe bij te dragen met opname van je code in Emacs.

3.6 let ¶

De let expressie is een speciale vorm in Lisp die je in de meeste functiedefinities nodig hebt.

let wordt gebruikt om een symbool aan een variabele te koppelen of te binden op zo’n manier dat de Lisp interpreter het niet verwart met een variabele met dezelfde naam die geen onderdeel van de functie is.

Om te begrijpen waarom de speciale vorm let nodig is, beschouw de situatie waarin je in het algemeen aan jouw huis refereert als “het huis”, zoals in de zin “Het huis moet geverfd worden”. Wanneer je een vriend bezoekt en de gastheer refereert aan “het huis”, refereert hij waarschijnlijk aan zijn huis, niet het jouwe, dus aan een ander huis.

Wanneer je vriend naar zijn huis refereert en jij denkt dat hij naar jouw huis refereert, dan kan dat verwarrend zijn. Hetzelfde kan in Lisp gebeuren wanneer een variabele die binnen de ene functie gebruikt wordt dezelfde naam heeft als een variabele die binnen een andere functie gebruikt wordt, en de twee zijn niet bedoeld om naar dezelfde waarde te refereren. De speciale vorm let voorkomt dit soort verwarring.

• let voorkomt verwarring
• De delen van een let expressie
• Voorbeeld let expressie
• Ongeïnitialiseerde variabelen in een let statement
• Hoe let variabelen bindt

(let varlist body...)

(let ((variable value)
      (variable value)
      ...)
  body...)

(let ((zebra "strepen")
      (tijger "woest"))
  (message "Eén soort dieren heeft %s en de ander is %s."
           zebra tijger))

"Eén soort dieren heeft strepen en de ander is woest."

(let ((berk 3)
      spar
      den
      (eik 'enige))
  (message
   "Hier zijn %d variabelen met %s, %s, en %s waarde."
   berk spar den eik))

"Hier zijn 3 variabelen met nil, nil, en enige waarde."

;;; -*- lexical-binding: t -*-

;;; -*- lexical-binding: t -*-

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     ⇒ 1

;;; -*- lexical-binding: t -*-

(defvar x) ;; Gebruik dynamic binding voor 'x'.

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     ⇒ 2

3.7 De if speciale vorm ¶

Een andere speciale vorm is de conditionele if. Deze vorm wordt gebruikt om de computer te instrueren om beslissingen te nemen. Je kunt functiedefinities schrijven zonder if te gebruiken, maar het wordt vaak genoeg gebruikt en is belangrijk genoeg om het hier te behandelen. Het wordt bijvoorbeeld gebruikt in de code van de functie beginning-of-buffer.

Het basisidee achter if is, dat wanneer een test waar is, dan een expressie wordt geëvalueerd. Wanneer de test niet waar is, dan wordt de expressie niet geëvalueerd. Bijvoorbeeld zou je een beslissingen kunnen maken zoals “als het warm en zonnig is, dan ga ik naar het strand!”.

• if in meer detail
• De type-dier-functie in detail

(if waar-of-onwaar-test
    actie-uit-te-voeren-als-de-test-waar-is)

(if (> 5 4)                             ; wanneer-deel
    (message "5 is groter dan 4!"))     ; dan-deel

(defun type-dier (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  (if (equal karakteristiek "woest")
      (message "Het is een tijger!")))

(type-dier "woest")

(type-dier "gestreept")

(defun naam-van-de-functie (argument-list)
  "documentatie..."
  body...)

(defun type-dier  (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  body: de if expressie)

(if waar-of-onwaar-test
    uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-waar-teruggeeft)

  (if (equal karakteristiek "woest")
      (message "Het is een tijger!"))

(equal karakteristiek "woest")

3.8 If–then–else expressies ¶

Een if-expressie kan optioneel een derde argument hebben, het anders-deel. voor het geval de waar-of-onwaar-test onwaar teruggeeft. Wanneer dit gebeurt wordt het tweede argument, het dan-deel van de if-expressie niet geëvalueerd, maar wordt het derde deel, het anders-deel, wel geëvalueerd. Je kunt dit zien als het bewolkte dag alternatief voor de beslissing “als het warm en zonnig is, ga dan naar het strand, anders lees een boek!”.

In de Lisp-code wordt het woord “else” niet geschreven, het anders-deel van een if-expressie komt na het dan-gedeelte. In Lisp staat het anders-deel gebruikelijk op zichzelf op een nieuwe regel en minder ingesprongen dan het dan-deel:

(if waar-of-onwaar-test
    uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-waar-teruggeeft
  uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-onwaar-teruggeeft))

De volgende if-expressie bijvoorbeeld toont de boodschap ‘4 is niet groter dan 5!’ wanneer je het op de gebruikelijke manier evalueert:

(if (> 4 5)                               ; if-deel
    (message "4 valselijk groter dan 5!") ; dan-deel
  (message "4 is niet groter dan 5!"))    ; anders-deel

Merk op dat de verschillende niveaus van inspringen het makkelijk maken het dan-deel te onderscheiden van het anders-deel. (GNU Emacs heeft verschillende commando’s die automatisch if-expressies correct laat inspringen. Zie GNU Emacs helpt je om lijsten te typen.)

We kunnen de type-dier-functie uitbreiden met een anders-deel door eenvoudig een aanvullend deel in de if-expressie in te voegen.

Je kunt de consequenties hiervan zien wanneer je de volgende versie van de type-dier functiedefinitie installeert en daarna de twee volgende expressies evalueert om de verschillende argumenten aan de functie door te geven.

(defun type-dier (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  (if (equal karakteristiek "woest")
      (message "Het is een tijger!")
    (message "Het is niet woest!")))

(type-dier "woest")

(type-dier "gestreept")

Wanneer je (type-dier "woest") evalueert, zie je de volgende boodschap in het echogebied: "Het is een tijger!", maar wanneer je (type-dier "gestreept") evalueert zie je "Het is niet woest!".

(Wanneer de karakteristiek "zeer woest" is, dan wordt de boodschap "Het is niet woest!" getoond, en dat is misleidend!. Wanneer je code schrijft, moet je rekening houden met de mogelijkheid dat een dergelijk argument wordt getest door de code en je programma overeenkomstig schrijven.)

3.9 Waar en onwaarheid in Emacs Lisp ¶

Er is een belangrijk aspect aan de waarheidstest in een if-expressie. Tot nu toe hebben we gesproken over “waar” en “onwaar” als waarden van predicaten alsof het nieuwe soorten van Emacs Lisp objecten zijn. Feitelijk is “onwaar” onze oude vriend nil. Alles wat anders is—wat dan ook— is “waar”.

De expressie die de test op waar wordt geïnterpreteerd als waar wanneer het resultaat van de evaluatie een waarde ongelijk aan nil is. Met andere woorden, het resultaat van de test wordt geacht waar te zijn wanneer de teruggegeven waarde een getal is zoals 47, een string zoals "hallo" of een symbool (anders dan nil), zoals bloemen, of een lijst (zolang die niet leeg is) of zelfs een buffer!

• Een uitleg van nil

(if 4
    'waar
  'onwaar)

(if nil
    'waar
  'onwaar)

(> 5 4)

(> 4 5)

3.10 save-excursion ¶

De functie save-excursion is de laatste speciale vorm die we in dit hoofdstuk bespreken.

In Emacs Lisp programma’s voor editing is de functie save-excursion heel gebruikelijk. Het bewaart de locatie van point, voert de body van de functie uit en herstelt point naar zijn vorige positie indien zijn lokatie is gewijzigd. Het primaire doel is te voorkomen dat de gebruiker verrast en verstoord wordt door onverwachte verplaatsing van point.

• Point and Mark
• Sjabloon voor een save-excursion expressie

(save-excursion
  body...)

(save-excursion
  eerste-expressie-in-body
  tweede-expressie-in-body
  derde-expressie-in-body
   ...
  laatste-expressie-in-body)

(let varlist
  (save-excursion
    body...))

3.11 Terugblik ¶

In de laatste hoofdstukken introduceerden we een macro en een flink aantal functies en speciale vormen. Deze bespreken we hier in het kort, samen met enkele vergelijkbare functies die we nog niet behandeld hebben.

eval-last-sexp

Evalueer de laatste symbolische expressie voor de huidige lokatie van point. De waarde wordt getoond in het echogebied tenzij de functie met een argument is aangeroepen. In dat geval wordt de output in het huidige buffer getoond. Dit commando is gewoonlijk gebonden aan C-x C-e.

defun

Definieer functie. Deze macro heeft maximaal vijf onderdelen: de naam, een sjabloon voor de argumenten die aan de functie doorgegeven worden, documentatie, een optionele interactieve declaratie en de body van de definitie.

In Emacs is de functiedefinitie van bijvoorbeeld dired-unmark-all-marks als volgt:

(defun dired-unmark-all-marks ()
  "Remove all marks from all files in the Dired buffer."
  (interactive)
  (dired-unmark-all-files ?\r))

interactive

Verklaar de interpreter dat de functie interactief gebruikt kan worden. Deze speciale vorm kan worden gevolgd door een string met een of meer delen die op volgorde informatie aan de argumenten van de functie doorgeven. Deze delen kunnen de interactief ook om informatie vragen. Delen van de string zijn gescheiden door nieuwe regels, ‘\n’.

Gebruikelijke code karakters zijn:

b

De naam van een bestaand buffer

f

De naam van een bestaand bestand

p

Het numerieke prefix-argument. (Merk op dat dit de kleine letter p is)

r

Point en mark als twee numerieke argumenten, de kleinste eerst. Dit is de enige letter die twee opvolgende argumenten specificeert, in plaats van een.

Zie Code Characters for ‘interactive’ in The GNU Emacs Lisp Reference Manual, voor een complete lijst van code karakters.

let

Verklaar dat een lijst van variabelen wordt gebruikt binnen de body van de let en geef ze een initiële waarde, hetzij nil of een gespecificeerde waarde. Evalueer daarna de rest van de expressies in de body van de let en geef de waarde van de laatste terug. Binnen de body van de let ziet de Lisp interpreter de waarden niet van variabelen met dezelfde naam die gebonden zijn buiten de let.

Bijvoorbeeld,

(let ((foo (buffer-name))
      (bar (buffer-size)))
  (message
   "Dit buffer is %s en heeft %d karakters."
   foo bar))

save-excursion

Registreer de waarde van point en het huidige buffer voor het evalueren van de body van deze speciale vorm. Herstel achteraf de waarde van point en buffer.

Bijvoorbeeld,

(message "We zijn %d karakters in dit buffer."
         (- (point)
            (save-excursion
              (goto-char (point-min)) (point))))

if

Evalueer het eerste argument van de functie. Wanneer het waar is, evalueer het tweede argument, anders evalueer het derde argument, mits die er is.

De speciale vorm if heet een conditional. Er zijn andere conditionals in Emacs Lisp, maar if is waarschijnlijk de meest gebruikte.

Bijvoorbeeld,

(if (= 22 emacs-major-version)
    (message "Dit is versie 22 Emacs")
  (message "Dit is niet versie 22 Emacs"))

<

>

<=

>=

De functie < test of het eerste argument kleiner is dan het tweede argument. Een corresponderende functie, > test of het eerste argument groter is dan het tweede. Vergelijkbaar test <= of het eerste argument kleiner of gelijk is aan het tweede en >= test of het eerste argument groter of gelijk is aan het tweede. In alle gevallen moeten beide argumenten getallen zijn of markers (markers geven de positie in buffers aan).

=

De functie = test of twee argumenten, beide nummers of markers, gelijk zijn.

equal

eq

Test of twee objecten hetzelfde zijn. equal gebruikt een betekenis van “hetzelfde” en eq gebruikt een andere. equal geeft waar terug wanneer de twee objecten dezelfde structuur en inhoud hebben, zoals twee exemplaren van hetzelfde boek. Daarnaast geeft eq waar terug indien beide argumenten daadwerkelijk hetzelfde object zijn.

string<

string-lessp

string=

string-equal

De functie string-lessp test of het eerste argument kleiner is dan het tweede. Een kortere alternatieve naam voor dezelfde functie (een defalias) is string<.

De argumenten van string-lessp moeten strings of symbolen zijn, de volgorde is lexicografish, dus hoofd- of kleine letters is van belang. Het toont de namen van symbolen die worden gebruikt in plaats van de symbolen zelf.

Een lege string, ‘""’, is een string zonder karakters er in, en is kleiner dan elke andere string van karakters.

string-equal verschaft de corresponderende test voor gelijkheid. De kortere alternatieve naam is string=. Recente versies van Emacs bevatten string-greaterp, met string> als korter alternatief. Er zijn geen string test- functies die corresponderen met >= of <=.

message

Toon een boodschap in het echogebied. Het eerste argument is een string die ‘%s’, ‘%d’ of ‘%c’ kan bevatten om de waarde van argumenten te tonen die volgen op de string. Het voor ‘%s’ gebruikte argument moet een string of een symbool zijn, het voor ‘%d’ gebruikte argument moet een getal zijn. Het voor ‘%c’ gebruikte argument moet een ASCII codenummer zijn, het wordt getoond als het karakter met die ASCII-code. (Verschillende andere %-sequences zijn niet genoemd.)

setq

set

De speciale vorm setq stelt de waarde van zijn eerste argument in op de waarde van het tweede argument. Het eerste argument wordt automatisch gequote door setq. Het doet hetzelfde voor opvolgende argumentparen.

buffer-name

Zonder een argument, geeft de waarde van het buffer terug als een string.

buffer-file-name

Zonder een argument, geeft de naam van het bestand terug dat het buffer bezoekt.

current-buffer

Geeft het buffer waar Emacs actief is terug. Het is misschien niet het buffer dat zichtbaar op het scherm is.

other-buffer

Geeft het meest recent geselecteerde buffer (anders dan het buffer doorgegeven aan other-buffer als een argument en anders dan het huidige buffer).

switch-to-buffer

Selecteert een buffer voor Emacs om actief in te zijn en toon het in het huidige venster zodat de gebruiker het kan zien. Gebruikelijk gebonden aan C-x b.

set-buffer

Schakelt de aandacht van Emacs naar een buffer waarop programma’s gaan draaien. Verandert niet wat het venster toont.

buffer-size

Geeft het aantal karakters in het huidige buffer.

point

Geeft de waarde van de huidige positie van de cursor, als een integer, telt het aantal karakters vanaf het begin van het buffer.

point-min

Geeft de minimaal toegestane waarde van point in het huidige buffer. Dit is 1, behalve wanneer narrowing van toepassing is.

point-max

Geef de maximaal toegestane waarde van point in het huidige buffer. Dit is het einde van het buffer, tenzij narrowing van toepassing is.

3.12 Oefeningen ¶

• Schrijf een niet-interactieve functie die de waarde van zijn argument, een getal, verdubbelt. Maak die functie interactief.
• Schrijf een functie die test of de huidige waarde van fill-column groter is dan het argument dat wordt doorgegeven aan de functie, en zo ja, toon het als een passende boodschap.

4.1 Meer informatie vinden ¶

In deze rondleiding beschrijf ik elke nieuwe functie die we behandelen. Soms in detail en soms kort. Wanneer je geïnteresseerd bent vraag je op elk moment de volledige documentatie op van elke Emacs Lisp functie door C-h f te typen, en daarna de naam van de functie (gevolg met RET). Je kunt op ook de volledige documentatie van een variabele opvragen met het typen van C-h v, en daarna de naam van de variabele (gevolg met RET).

describe-function vertelt je ook de locatie van de functie.

Plaats point in de naam van het bestand dat de functie bevat en druk op de RET-toets. In dit geval betekent RET push-button in plaats van “return” of “enter”. Emacs neemt je meteen naar de functiedefinitie.

Meer in het algemeen, wanneer je de functie in het originele bronbestand wilt zien, spring je met de functie xref-find-definitions er heen. xref-find-definitions werkt met een brede variëteit van talen, niet alleen Lisp en C, en het werkt ook met non-programming tekst. xref-find-definitions springt bijvoorbeeld naar de verschillende nodes in de Texinfo broncode van dit document (onder voorwaarde dat je het etags-hulpprogramma alle nodes van alle handleidingen de met Emacs komen hebt laten registeren zie Create Tags Table in The GNU Emacs Manual).

Type M-. (dus druk op de punt-toet terwijl je de META-toets ingedrukt houdt, of typ anders de ESC gevold door de punt-toets) om het commando xref-find-definitions te gebruiken, en vervolgens, na de prompt, de naam van de functie wiens broncode je wilt zien, zoals mark-whole-buffer en typ daarna RET. (Wanneer het commando geen prompt geeft, roep het dan met een argument: C-u M-.). zie Verschillende opties voor interactive.) Emacs schakelt buffers en toont de broncode van de functie op je scherm¹¹ Om naar je buffer terug te keren type je type M-, of C-x b RET. (Op sommige toetsenborden, heeft de META-toets het label ALT.)

Overigens worden de bestanden die Lisp code bevatten gewoonlijk bibliotheken genoemd. De metafoor is afgeleid van een gespecialiseerde bibliotheek, zoals een juridische bibliotheek of een technische bibliotheek, in plaats van een algemene bibliotheek. Elke bibliotheek, of bestand, bevat functies die aan bepaald onderwerp of activiteit gerelatieerd zijn, zoals abbrev.el voor het afhandelen van afkortingen en andere snelkoppelingen voor het typen, en help.el for hulp. (Soms verschaffen verschillende bestanden code voor een enkele activiteit, zoals de diverse rmail… bestanden code voor het lezen van e-mail verschaffen.) In The GNU Emacs Manual zie je zinnen zoals “het C-h p commando laat je de standaard Emacs lisp bibliotheken doorzoeken op onderwerp sleutelwoorden.”

4.2 Een versimpelde beginning-of-buffer definitie ¶

De beginning-of-buffer is een goede functie om mee te starten omdat je er waarschijnlijk al bekend mee bent en makkelijk te begrijpen is. Gebruikt als een interactief commando verplaatst beginning-of-buffer de cursor naar het begin van het buffer, en zet de mark op de vorige positie. Het is gewoonlijk gebonden aan M-<.

In deze sectie bespreken we een verkorte versie van de functie die laat zien hoe het meestal gebruikt wordt. De verkorte functie werkt, maar heeft geen code voor een complexe optie. In een andere sectie zullen we de volledige code bespreken. (Zie Complete definitie van beginning-of-buffer.)

Voordat we naar de code kijken staan we stil bij wat de functiedefinitie moet bevatten: het moet een expressie bevatten die de functie interactief maakt zodat het kan worden aangeroepen met typen van M-x beginning-of-buffer of door het typen van een toetscombinatie zoals M-<. Het moet code bevatten om de mark op de originele positie te plaatsen en het moet code bevatten om de cursor naar het begin van het buffer te verplaatsen.

Hier is de complete text van de verkorte versie van de functie:

(defun versimpelde-beginning-of-buffer ()
  "Verplaats point naar begin van het buffer;
plaats mark op de vorige positie."
  (interactive)
  (push-mark)
  (goto-char (point-min)))

Zoals alle functiedefinities heeft deze definitie de vijf delen volgens de macro defun:

1. De naam: in dit voorbeeld versimpelde-beginning-of-buffer.
2. Een lijst met argumenten, in dit voorbeeld een lege lijst, ().
3. De documentatiestring
4. De interactive expressie
5. De body

In deze functiedefinitie is de argumentlijst leeg, dit betekent dat de functie geen argumenten vereist. (Wanneer we naar de definitie van de complete functie kijken zien we dat deze een optioneel argument kan krijgen.)

De interactive expressie vertelt Emacs dat de functie bedoeld is voor interactief gebruik. In dit voorbeeld heeft interactive geen argumenten omdat versimpelde-beginning-of-buffer die niet nodig heeft.

De body van de functie bestaat uit twee regels:

(push-mark)
(goto-char (point-min))

De eerste van de twee regels is de expressie (push-mark). Wanneer de Lisp interpreter deze expressie evalueert stelt het de mark op de huidige positie van de cursor in, wat die ook is. De positie van deze mark wordt bewaard in de mark-ring.

De volgende regel is (goto-char (point-min)). Deze expressie springt de cursor naar het minimum punt in het buffer, dat is het begin van de buffer (of het begin van het bereikbare deel van de buffer wanneer is het versmald. Zie Versmallen en verbreden.)

Het push-mark commando zet de mark op de plaats waar de cursor was voordat het door de (goto-char (point-min)) expressie naar het begin van de buffer werd verplaatst. Daardoor kan je, als je dat wilt, terug gaan naar de plek waar je oorspronkelijk was door C-x C-x te typen.

Dat is alles wat er is voor deze functiedefinitie!

Wanneer je code zoals deze leest en een onbekende functie tegenkomt zoals goto-char, kan je met het describe-function commando ontdekken wat die doet. Typ C-h f gevold door de naam van de functie en toets daarna RET om dit commando te gebruiken. Het describe-function commando toont de documentatiestring van de functie in een *Help*-venster. Bijvoorbeeld de documentatie voor goto-char is:

Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).

Het enige argument van de functie is de gewenste positie.

De prompt voor describe-function stelt je het symbool onder of voorafgaand aan de cursor voor, zodat je minder hoeft te typen door de cursor boven of meteen achter de functie te plaatsen en dan C-h f RET te typen.)

De functiedefinitie van end-of-buffer is op dezelfde manier geschreven als de beginning-of-buffer-definitie, belalve dat de body van de functie de expressie (goto-char (point-max)) bevat in plaats van (goto-char (point-min)).

4.3 De definitie van mark-whole-buffer ¶

De functie mark-whole-buffer is niet lastiger te begrijpen dan de versimpelde-beginning-of-buffer-functie. In dit geval kijken we echter naar de complete functie en niet naar een verkorte versie.

De functie mark-whole-buffer wordt minder vaak gebruikt dan de functie beginning-of-buffer, maar is toch zinvol: het markeert de hele buffer als region door de point aan het begin en de mark aan het einde van de buffer te plaatsen. Het is gebruikelijk gebonden aan C-x h.

• Een overzicht van mark-whole-buffer
• Body van mark-whole-buffer

(defun mark-whole-buffer ()
  "Put point at beginning and mark at end of buffer.
You probably should not use this function in Lisp programs;
it is usually a mistake for a Lisp function to use any subroutine
that uses or sets the mark."
  (interactive)
  (push-mark (point))
  (push-mark (point-max) nil t)
  (goto-char (point-min)))

(defun naam-van-de-functie (argument-list)
  "documentatie..."
  (interactive-expression...)
  body...)

(push-mark (point))
(push-mark (point-max) nil t)
(goto-char (point-min))

(push-mark (point-max) nil t)

4.4 De definitie van append-to-buffer ¶

Het append-to-buffer commando is complexer dan het mark-whole-buffer commando. Wat het doet is de region (dat is het deel van het buffer tussen point en mark) van het huidige buffer kopiëren naar een specifiek buffer.

• Een overzicht van append-to-buffer
• De append-to-buffer interactieve expressie
• De body van append-to-buffer
• save-excursion in append-to-buffer

(defun append-to-buffer (buffer start end)
  "Voeg tekst van de region toe aan het gespecificeerde buffer.
Het wordt voor de point in dat buffer ingevoegd.

Geef bij het aanroepen vanuit een programma drie argumenten:
BUFFER (of buffernaam), START en END.
START en END specificeren het te kopiëren deel van het huidige buffer."
  (interactive
   (list (read-buffer "Append to buffer: " (other-buffer
                                            (current-buffer) t))
         (region-beginning) (region-end)))

  (let ((oldbuf (current-buffer)))
    (save-excursion
      (let* ((append-to (get-buffer-create buffer))
             (windows (get-buffer-window-list append-to t t))
             point)
        (set-buffer append-to)
        (setq point (point))
        (barf-if-buffer-read-only)
        (insert-buffer-substring oldbuf start end)
        (dolist (window windows)
          (when (= (window-point window) point)
            (set-window-point window (point))))))))

(defun append-to-buffer (buffer start end)
  "documentatie..."
  (interactive ...)
  body...)

 (list (read-buffer
        "Append to buffer: "
        (other-buffer (current-buffer) t))
       (region-beginning)
       (region-end)))

(other-buffer (current-buffer) t)

(interactive "BAppend to buffer: \nr")

(defun append-to-buffer (buffer start end)
  "documentatie..."
  (interactive ...)
  (let ((variable value))
        body...))

(oldbuf (current-buffer))

(let ((oldbuf (current-buffer)))
  ... )

(defun ...
  ...
  ...
  (let...
    (save-excursion
      ...

(let ((oldbuf (current-buffer)))
  (save-excursion
    ...
    (set-buffer ...)
    (insert-buffer-substring oldbuf start end)
    ...))

(save-excursion
  eerste-expressie-in-body
  tweede-expressie-in-body
   ...
  laatste-expressie-in-body)

(let* ((append-to (get-buffer-create buffer))
       (windows (get-buffer-window-list append-to t t))
       point)
  BODY...)

(set-buffer (get-buffer-create buffer))

(set-buffer append-to)

(insert-buffer-substring oldbuf start end)

(let (bind-oldbuf-to-value-of-current-buffer)
  (save-excursion                       ; Bijhouden van het buffer.
    change-buffer
    insert-substring-from-oldbuf-into-buffer)

  schakel-terug-naar-oorspronkelijke-buffer-indien-gereed
laat-de-lokale-betekenis-van-oldbuf-verdwijnen-indien-gereed

4.5 Terugblik ¶

Hier is een korte samenvatting van de verschillende in dit hoofdstuk besproken functies.

describe-function

describe-variable

Toon de documentatie voor een functie of variabele. Gewoonlijk gebonden aanC-h f en C-h v.

xref-find-definitions

Vindt het bestand dat de broncode voor een functie of variabele bevat en schakel buffers daar naar toe en plaats point aan het begin van dat item. Gewoonlijk gebonden aan M-. (dat is een punt volgend op de META toets).

save-excursion

Bewaar de lokatie van point en herstel zijn waarde nadat de argumenten van save-excursion zijn geëvalueerd. Onthoud ook het huidige buffer en keer daar naar terug.

push-mark

Stel mark in op een lokatie en bewaarde waarde van voorgaande mark op de mark-ring. De mark is een lokatie in het buffer dat zijn relatieve positie behoudt, zelfs wanneer in het buffer tekst is toegevoegd of verwijderd.

goto-char

Zet point op de lokatie gespecificeerd door de waarde van het argument, dat een getal kan zijn, een marker, of een expressie die ene getal of een positie teruggeeft, zoals (point-min).

insert-buffer-substring

Kopieer een region met tekst van een buffer dat als argument is doorgegeven aan de functie en voeg de region in het huidige buffer in.

mark-whole-buffer

Markeer het gehele buffer als region. Normaal gebonden aan C-x h.

let*

Declareer een lijst met variabelen en geef die een initiële waarde. Evalueer de rest van de expressies in de body van let*. De waarden van de variabelen kunnen gebruikt worden om daaropvolgende variabelen in de lijst te binden.

set-buffer

Richt de aandacht van Emacs op een ander buffer, maar wijzig het getoonde venster niet. Wordt gebruikt wanneer een programma in plaats van een mens op een ander buffer werkt.

get-buffer-create

get-buffer

Vindt een genoemd buffer of maak er een wanneer een buffer met die naam nog niet bestaat. De functie get-buffer geeft nil terug wanneer het genoemde buffer niet bestaat.

4.6 Oefeningen ¶

• Schrijf je eigen versimpelde-beginning-of-buffer functiedefinitie. Test daarna om te kijken of het werkt.
• Gebruik if en get-buffer om een functie te schrijven die een boodschap toon die aangeeft of een buffer wel of niet bestaat.
• Zoek met xref-find-definitions de bron voor de functie copy-to-buffer.

5.1 De definitie van copy-to-buffer ¶

Wanneer je begrijpt hoe append-to-buffer werkt, is het eenvoudig copy-to-buffer te begrijpen. Deze functie kopieert tekst naar een buffer, maar in plaats van het aan het tweede buffer toe te voegen vervangt het alle voorgaande tekst in het tweede buffer.

De body van copy-to-buffer ziet er zo uit.

...
(interactive "BCopy to buffer: \nr")
(let ((oldbuf (current-buffer)))
  (with-current-buffer (get-buffer-create buffer)
    (barf-if-buffer-read-only)
    (erase-buffer)
    (save-excursion
      (insert-buffer-substring oldbuf start end)))))

De functie copy-to-buffer heeft een simpeler interactive expressie dan append-to-buffer.

De definitie zegt daarna:

(with-current-buffer (get-buffer-create buffer) ...

Kijk ten eerste naar de vroegste binnenste expressie, die wordt het eerste geëvalueerd. De expressie start met get-buffer-create buffer. De functie vertelt de computer het buffer te gebruiken met de naam gespecificeerd als diegene waarnaar je wilt kopiëren, of die aan te maken als die niet bestaat. Daarna evalueert de functie with-current- buffer zijn body met dat als tijdelijk huidige buffer, waarna het terugschakelt naar de buffer waar wij nu zijn¹².

(Dit demonstreert een andere manier om de aandacht van de computer maar niet die van de gebruiker te schakelen. De functie append-to-buffer toonde dit te doen met save-excursion and set-buffer. with-current-buffer is een nieuwer en misschien zelfs makkelijker mechanisme.)

De functie barf-if-buffer-read-only stuurt je een foutmelding die zegt dat het buffer read-only is wanneer je het niet mag wijzigen.

De volgende regel heeft de functie erase-buffer als enige inhoud. Het wist het buffer.

De laatste twee regels tenslotte bevatten de save-excursion expressie met insert-buffer-substring als body. De insert-buffer-substring expressie kopieert de tekst van het buffer waar je nu in bent (en je hebt niet gezien dat de computer zijn aandacht verplaatst heeft, waardoor je niet weet dat dit buffer nu oldbuf heet.)

Overigens is dit wat bedoeld wordt met “vervanging”. Om tekst te vervangen wist Emacs de vorige tekst en voegt daarna de nieuwe tekst in.

In hoofdlijnen ziet de body van copy-to-buffer er zo uit:

(let (bind-oldbuf-aan-de-waarde-van-current-buffer)
    (met-het-buffer-waarheen-je-kopieert
      (maar-wis-of-kopieer-niet-naar-een-read-only-buffer)
      (erase-buffer)
      (save-excursion
        insert-substring-van-oldbuf-in-buffer)))

5.2 De definitie van insert-buffer ¶

insert-buffer is weer een andere buffer-gerelateerde functie. Het commando kopieert een ander buffer naar het huidige buffer. Het is het omgekeerde van append-to-buffer of copy-to-buffer, deze kopiëren immers tekst van het huidige buffer naar een ander buffer.

Hier is een bespreking gebaseerd op de originele code. De code is vereenvoudigd in 2003 en is moeilijker te begrijpen.

(Zie Nieuwe body voor insert-buffer, voor een bespreking van de nieuwe body.

Daarnaast illustreert deze code het gebruik van interactive met een buffer dat read-only zou kunnen zijn en het belangrijke onderscheid tussen de naam van een object en het object waar daadwerkelijk aan gerefereerd wordt.

• De code voor insert-buffer
• De interactieve expressie in insert-buffer
• De body van de insert-buffer functie
• insert-buffer met een if in plaats van een or
• De or in de body
• De let expresse in insert-buffer
• Nieuwe body voor insert-buffer

(defun insert-buffer (buffer)
  "Insert after point the contents of BUFFER.
Puts mark after the inserted text.
BUFFER may be a buffer or a buffer name."
  (interactive "*bInsert buffer: ")

  (or (bufferp buffer)
      (setq buffer (get-buffer buffer)))
  (let (start end newmark)
    (save-excursion
      (save-excursion
        (set-buffer buffer)
        (setq start (point-min) end (point-max)))

      (insert-buffer-substring buffer start end)
      (setq newmark (point)))
    (push-mark newmark)))

(defun insert-buffer (buffer)
  "documentatie..."
  (interactive "*bInsert buffer: ")
  body...)

(defun insert-buffer (buffer)
  "documentatie..."
  (interactive "*bInsert buffer: ")
  (or ...
      ...

  (let (varlist)
      body-of-let... )

(if (not (gast-vasthouden))
    (vind-en-neem-gast-bij-de arm))

(if (not (bufferp buffer))              ; if-deel
    (setq buffer (get-buffer buffer)))  ; dan-deel

(not (bufferp buffer))

(or (bufferp buffer)
    (setq buffer (get-buffer buffer)))

(or (heeft-arm-van-gast) (vind-en-neem-de-arm-van-de-gast))

(save-excursion
  (set-buffer buffer)
  (setq start (point-min) end (point-max)))

(save-excursion
  (binnenste-save-excursion-expressie
     (ga-naar-nieuw-buffer-en-zet-start-en-end)
  (insert-buffer-substring buffer start end)
  (setq newmark (point)))

(let (start end newmark)
  (save-excursion
    (save-excursion
      (set-buffer buffer)
      (setq start (point-min) end (point-max)))
    (insert-buffer-substring buffer start end)
    (setq newmark (point)))
  (push-mark newmark))

  (push-mark
   (save-excursion
     (insert-buffer-substring (get-buffer buffer))
     (point)))

   nil

5.3 Complete definitie van beginning-of-buffer ¶

De basisstructuur van de functie beginning-of-buffer hebben we eerder besproken. (Zie Een versimpelde beginning-of-buffer definitie.) Deze sectie beschrijft het complexe deel van de definitie.

Wanneer beginning-of-buffer zonder argument wordt aangeroepen plaatst het, zoals eerder beschreven, de cursor naar het begin van het buffer (eerlijk gezegd, het begin van het bereikbare deel van het buffer), en laat de mark op de voorgaande positie. Echter, wanneer het commando wordt aangeroepen met een getal tussen één en tien, dan beschouwt de functie dat getal als een fractie van de lengte van het buffer, gemeten in tienden, en verplaatst Emacs de cursor die fractie vanaf het begin van het buffer. Dus je kunt de functie aanroepen met het commando M-<, wat de cursor naar het begin van het buffer verplaatst, of met een toets commando zoals C-u 7 M-< wat de cursor op een punt 70% in het buffer plaatst. Bij gebruik van een getal groter dan tien als argument gaat het naar het einde van het buffer.

De functie beginning-of-buffer kan met of zonder argument worden aangeroepen. Het gebruik van een argument is optioneel.

• Optionele argumenten
• beginning-of-buffer met een argument
• De complete beginning-of-buffer

(defun beginning-of-buffer (&optional arg)

(defun beginning-of-buffer (&optional arg)
  "documentatie..."
  (interactive "P")
  (or (is-het-argument-een-cons-cel arg)
      (and zijn-zowel-transient-mark-mode-als-mark-active-waar)
      (push-mark))
  (let (stel-grootte-vast-en-stel-in)
    (goto-char
      (als-er-een-argument-is
          zoek-uit-waar-heen-te-gaan
        anders-ga-naar
        (point-min))))
  wees-beleefd

(if (> (buffer-size) 10000)
    ;; Avoid overflow for large buffer sizes!
    (* (prefix-numeric-value arg)
       (/ size 10))
  (/
   (+ 10
      (* size
         (prefix-numeric-value arg)))
   10))

(if (buffer-is-groot
    deel-buffer-grootte-door-10-en-vermenigvuldig-met-arg
  anders-gebruik-alternatieve-berekening

(if (> size 10000)

(*
  (prefix-numeric-value arg)
  (/ size 10))

(* numerieke-waarde-van-het-prefix-arg
   aantal-karakters-in-een-tiende-van-het-bereikbare-buffer)

(goto-char (* (prefix-numeric-value arg)
              (/ size 10)))

(/ (+ 10 (* size (prefix-numeric-value arg))) 10)

  (/
   (+ 10
      (*
       size
       (prefix-numeric-value arg)))
   10)

(* size (prefix-numeric-value arg))

(defun beginning-of-buffer (&optional arg)
  "Move point to the beginning of the buffer;
leave mark at previous position.
With \\[universal-argument] prefix,
do not set mark at previous position.
With numeric arg N,
put point N/10 of the way from the beginning.

If the buffer is narrowed,
this command uses the beginning and size
of the accessible part of the buffer.

Don't use this command in Lisp programs!
\(goto-char (point-min)) is faster
and avoids clobbering the mark."
  (interactive "P")
  (or (consp arg)
      (and transient-mark-mode mark-active)
      (push-mark))

  (let ((size (- (point-max) (point-min))))
    (goto-char (if (and arg (not (consp arg)))
                   (+ (point-min)
                      (if (> size 10000)
                          ;; Avoid overflow for large buffer sizes!
                          (* (prefix-numeric-value arg)
                             (/ size 10))
                        (/ (+ 10 (* size (prefix-numeric-value arg)))
                           10)))
                 (point-min))))
  (if (and arg (not (consp arg))) (forward-line 1)))

\\[universal-argument]

(if (and arg (not (consp arg))) (forward-line 1))

5.4 Terugblik ¶

Hier is een korte samenvatting van enkele van de onderwerpen in dit hoofdstuk.

or

Evalueer elk argument op volgorde, en geef de waarde van het eerste argument dat niet nil is. Wanneer niet een van hen een waarde ongelijk aan nil teruggeeft, geef dan nil terug. In het kort, geef de eerste waarde van de argumenten die waar is terug, geef een waarde waar terug wanneer een of meer van de andere waar zijn.

and

Evalueer elk argument op volgorde, en als er een nil is, geef dan nil terug. Als niet een van hen nil is, geef dan de waarde van het laatste argument terug. In het kort, geef een waarde waar terug uitsluitend wanneer alle argumenten waar zijn, geef een waarde waar terug wanneer een en alle andere waar zijn.

&optional

Een sleutelwoord dat aangeeft dat een argument van een functiedefinitie optioneel is, dit betekent dat de functie desgewenst zonder dit argument kan worden geëvalueerd,

prefix-numeric-value

Converteer het ongewijzigde prefix-numeric-value geproduceerd door (interactive "P") naar een numerieke waarde.

forward-line

Verplaats point voorwaarts naar het begin van de volgende regel, of wanneer het argument groter is dan één, dat aantal regels voorwaarts. Wanneer het niet zo ver voorwaarts kan als het bedoeld is, gaat forward-line zo ver mogelijk voorwaarts en geeft vervolgens het aantal terug van de extra regels die het bedoeld was te verplaatsen maar dat niet kon.

erase-buffer

Verwijder de gehele inhoud van het huidige buffer.

bufferp

Geef t terug wanneer het argument een buffer is, zo niet geef nil terug.

5.5 optioneel argument oefening ¶

Schrijf een interactieve functie met een optioneel argument dat test of het argument, een getal, groter of gelijk is aan, dan wel kleiner is dan de waarde van fill-column, en je in een boodschap vertelt welke het geval is. Wanneer je echter geen argument aan de functie doorgeeft, gebruik dan 56 als standaard waarde.

6.1 De speciale vorm save-restriction ¶

In Emacs Lisp gebruik je de speciale vorm save-restriction om bij te houden welke versmalling van toepassing is. Wanneer de Lisp interpreter save-restriction tegenkomt, voert het de code in de body van de save-restriction expressie uit en maakt de eventuele wijzigingen die het in de versmalling heeft aangebracht ongedaan. Wanneer bijvoorbeeld het buffer versmald is en de code die volgt op save-restriction de versmalling weghaalt, herstelt save-restriction na afloop het buffer naar zijn versmalde region. In het what-line commando wordt de versmalling die het buffer mogelijk heeft ongedaan gemaakt met het widen commando, dat onmiddellijk volgt op het save-restriction. De eventuele oorspronkelijke versmalling wordt hersteld vlak voor het beëindigen van de functie.

Het sjabloon voor een save-restriction expressie is eenvoudig:

(save-restriction
  body... )

De body van de save-restriction bestaat uit een of meer expressies die de Lisp interpreter op volgorde evalueert.

Tenslotte, een punt om op te merken: wanneer je zowel save-excursion en save-restriction gebruikt, de een na de ander, dan moet je save-excursion als de buitenste gebruiken. Wanneer je ze in omgekeerde volgorde schrijft, kan het bijhouden van de versmalling in het buffer waar Emacs naar toe schakelt na het aanroepen van save-excursion fout gaan. Wanneer je daarom samen gebruikt, schrijf je save-excursion en save-restriction als volgt:

(save-excursion
  (save-restriction
    body...))

In andere omstandigheden, waar ze niet samen gebruikt worden, schrijf je de speciale vormen save-excursion en save-restriction in de volgorde die past bij de functie.

Bijvoorbeeld,

  (save-restriction
    (widen)
    (save-excursion
    body...))

6.2 what-line ¶

Het what-line commando vertelt het je het regelnummer waarop de cursor staat. De functie illustreert het gebruik van de save-excursion en save-restriction commando’s. Hier is de oorspronkelijke tekst van de functie.

(defun what-line ()
  "Print the current line number (in the buffer) of point."
  (interactive)
  (save-restriction
    (widen)
    (save-excursion
      (beginning-of-line)
      (message "Line %d"
               (1+ (count-lines 1 (point)))))))

(In moderne versies van GNU Emacs is de functie what-line uitgebreid zodat het zowel het regelnummer in het versmalde buffer als het regelnummer in het verbrede buffer vertelt. De moderne versie is complexer dan de versie die we hier laten zien. Wanneer je een avontuurlijke bui hebt, kan je er naar kijken nadat je uitgezocht hebt hoe deze versie werkt. Je hebt daar waarschijnlijk C-h f (describe-function) bij nodig.) De nieuwere versie gebruikt een conditional om vast te stellen of het buffer is versmald.

Verder maakt de moderne versie van what-line gebruik van line-number-at-pos, die net als andere eenvoudige expressies, zoals (goto-char (point-min)), (forward-line 0) in plaats van beginning-of-line gebruikt om point naar het begin van de huidige regel te verplaatsen.

De functie what-line zoals hier getoond heeft zoals je zou verwachten een documentatieregel en is interactief. De volgende twee regels gebruiken de functies save-restriction en widen.

De speciale vorm save-restriction noteert eventuele versmalling die van kracht is in het huidige buffer en herstelt de versmalling nadat de code in de body van save-restriction is geëvalueerd.

De speciale vorm save-restriction wordt gevolgd door widen. Deze functie maakt eventuele versmalling in het huidige buffer ongedaan voor zover die er was toen what-line werd aangeroepen. (De versmalling die daar was is de versmalling die save-restriction onthoudt.) Deze verbreding maakt het voor de commando’s die de regels tellen mogelijk om vanaf het begin van het buffer te tellen. Anders zouden ze beperkt zijn tot het tellen binnen het bereikbare gebied. Eventuele oorspronkelijke versmalling wordt hersteld vlak voor de voltooiing van de functie door de speciale vorm save-restriction.

De aanroep van widen wordt gevolgd door save-excursion die de locatie van de cursor (dus van point) bewaart, en herstelt die nadat de code in de body van de save-excursion de functie beginning-of-line gebruikt om point te verplaatsen.

(Merk op dat de (widen) expressie tussen de speciale vormen save-restriction en de save-excursion staat. Wanneer je de twee save- … expressies opeenvolgend schrijft, zet je save-excursion als buitenste.)

De laatste twee regels van de functie what-line zijn functies die het aantal regels in het buffer tellen en daarna dat aantal in het echogebied tonen.

(message "Line %d"
         (1+ (count-lines 1 (point)))))))

De functie message toont een eenregelige boodschap onderaan het Emacs scherm. Het eerste argument staat tussen aanhalingstekens en wordt getoond als een string karakters. Het mag echter een ‘%d’ expressie bevatten om het volgende argument te tonen. ‘%d’ toont het argument als een decimaal getal, zodat de boodschap iets als ‘Line 243’ zegt.

Het getal dat getoond wordt op de plek van de ‘%d’ wordt berekend door de laatste regel van de functie:

(1+ (count-lines 1 (point)))

Wat dit doet is het tellen van de regels vanaf de eerste positie van het buffer, aangegeven door de 1, tot de (point) en telt daar vervolgens één bij op. (De functie 1+ telt één bij zijn argument op.) We tellen één er bij op omdat regel 2 maar één regel voor zich heeft, en count-lines alleen de regels voor de huidige regel telt.

Nadat count-lines zijn werk heeft gedaan en de boodschap in het echogebied is getoond, herstelt save-excursion point naar zijn oorspronkelijke positie en herstelt save-restriction de eventuele oorspronkelijke versmalling.

6.3 Oefening met versmalling ¶

Schrijf een functie dat de eerste 60 karakters van het huidige buffer toont, zelfs wanneer je het buffer hebt versmald naar zijn tweede helft zodat de eerste regel onbereikbaar is. Herstel point, mark en de versmalling. Gebruik voor deze oefening de gehele potpourri van functies, inclusief save-restriction, widen, goto-char, point-min, message en buffer-substring.

(buffer-substring is een eerder ongenoemde functie die je zelf moet onderzoeken, of misschien moet je gebruik maken van . buffer-substring-no-properties of filter-buffer-substring …, nog meer andere functies. Teksteigenschappen zijn een eigenschap die overigens hier niet besproken wordt. Zie Text Properties in The GNU Emacs Lisp Reference Manual.)

Daarnaast, heb je goto-char of point-min echt nodig? Of kan je de functie zonder hen schrijven?

7.1 car en cdr ¶

De CAR van een lijst is, vrij eenvoudig, het eerste item in de lijst. Dus de CAR van de lijst (roos viool madelief boterbloem) is roos.

Wanneer je dit in Info in GNU Emacs leest kan je dit door het volgende te evalueren:

(car '(roos viool madelief boterbloem))

Na het evalueren van de expressie verschijnt roos in het echogebied.

car verwijdert het eerste element van de lijst niet, het vertelt alleen wat het is. Nadat car op een lijst is toegepast is de lijst nog steeds hetzelfde. car is “niet-destructief”, in het jargon. Deze eigenschap blijkt belangrijk te zijn.

De CDR van een lijst is de rest van de lijst, dat wil zeggen dat de CDR het deel van de lijst dat volgt op het eerste item. Dus terwijl de CAR van de lijst '(roos viool madelief boterbloem) roos is, is de rest van de, de waarde die de functie cdr teruggeeft, is (viool madelief boterbloem).

Je ziet door het volgende op de gebruikelijke manier te evalueren:

(cdr '(roos viool madelief boterbloem))

Wanneer je dit evalueert, verschijnt (viool madelief boterbloem) in het echogebied.

Net als car verwijdert cdr geen elementen uit de lijst—het vertelt aleen wat het de tweede en volgende elementen zijn.

Overigens in het voorbeeld is de lijst met bloemen gequote. Wanneer dat niet zo was zou de Lisp interpreter de lijst proberen te evalueren door roos als een functie aan te roepen. In dit voorbeeld willen we dat niet.

Voor het werken met lijsten zouden de namen first en rest logischer zijn dan de namen car en cdr. Sommige programmers definieren inderdaad first en rest als aliassen voor car en cdr en gebruiken daarna first en rest in de rest van hun code.

Lijsten in Lisp worden echter gebouwd met een onderliggende structuur bekend als “cons cells” (zie Hoe lijsten zijn geïmplementeerd), waarin niet zo iets als “eerste” of “rest” bestaat, en de CAR en de CDR symmetrisch zijn. Lisp probeert niet het bestaan van cons cellen te verstoppen en programma’s gebruiken ze ook voor andere dingen dan lijsten. Om deze reden helpen de namen de programmers te herinneren dat car en cdr symmetrisch zijn, ondanks de asymmetrische manier waarop ze in lijsten gebruikt worden.

Wanneer car en cdr worden toegepast op lijsten van symbolen, zoals de lijst (den spar eik esdoorn), is het element van de lijst dat de functie car teruggeeft het symbool den, zonder haakjes er omheen. den is het eerste symbool in de lijst. De CDR van de lijst is echter een list op zichzelf, (spar eik esdoorn), zoals je ziet door de volgende expressie op de gebruikelijke manier te evalueren:

(car '(den spar eik esdoorn))

(cdr '(den spar eik esdoorn))

Anderzijds is in een lijst van lijsten het eerste element op zichzelf een lijst. car geeft het eerste element als lijst terug. De volgende lijst bijvoorbeeld bevat drie sublijsten, een lijst van carnivoren, een lijst van herbivoren en een lijst van zeezoogdieren:

(car '((leeuw tijger cheeta)
       (gazelle antiloop zebra)
       (walvis dolfijn zeehond)))

In dit voorbeeld is het eerste element of de CAR van de lijst de lijst met carnivoren, (leeuw tijger cheeta) en is de rest van de lijst (gazelle antiloop zebra) (walvis dolfijn zeehond).

(cdr '((leeuw tijger cheeta)
       (gazelle antiloop zebra)
       (walvis dolfijn zeehond)))

Het is het waard nog een keer te zeggen dat car en cdr niet-destructief zijn, zij wijzigen de lijsten waarop worden toegepast niet. Dit is erg belangrijk voor hoe ze worden gebruikt.

Daarnaast zei ik bij de bespreking van atomen in het eerste hoofdstuk dat in Lisp sommige soorten atomen, zoals een array, in delen gescheiden kunnen worden maar dat het mechanisme om dit te doen afwijkt van het mechanisme om een lijst te splijten. Voor zover het Lisp aangaat, zijn de atomen van lijsten onsplijtbaar. (Zie Lisp atomen.) De functies car en cdr worden gebruikt om lijsten te splijten en worden als fundamenteel voor Lisp beschouwd. Aangezien zij een array niet kunnen splijten of toegang krijgen tot de delen van een array, wordt een array beschouwd als een atoom. Omgekeerd kan de andere fundamentele functie cons gebruikt worden om een lijst samen te stellen, maar niet een array. (Arrays worden behandeld met array-specifieke functies Zie Arrays in The GNU Emacs Lisp Reference Manual.)

7.2 cons ¶

De cons functie construeert lijsten. Het is de inverse van car en cdr. cons kan bijvoorbeeld gebruikt worden om de lijst van vier elementen te maken van een lijst met drie elementen, bijvoorbeeld (spar eik esdoorn):

(cons 'den '(spar eik esdoorn))

Na evaluatie van de lijst zie je

(den spar eik esdoorn)

in het echogebied verschijnen. cons veroorzaakt de creatie van een nieuwe lijst waarin het element wordt gevolgd door de elementen van de oorspronkelijke lijst.

We zeggen vaak dat cons een nieuw element aan het begin van de lijst plaatst, of dat het een element aan de lijst vastmaakt of pusht, maar deze formulering is misleidend, omdat cons geen bestaande lijst verandert, maar een nieuwe maakt.

Like car and cdr, cons is non-destructive.

• Bouw een lijst
• Achterhaal de lengte van een lijst: length

(cons 'boterbloem ())
     ⇒ (boterbloem)

(cons 'madelief '(boterbloem))
     ⇒ (madelief boterbloem)

(cons 'viool '(madelief boterbloem))
     ⇒ (violet madelief boterbloem)

(cons 'roos '(viool madelief boterbloem))
     ⇒ (roos viool madelief boterbloem)

(length '(boterbloem))
     ⇒ 1

(length '(madelief boterbloem))
     ⇒ 2

(length (cons 'viool '(madelief boterbloem)))
     ⇒ 3

(length ())
     ⇒ 0

(length )

Lisp error: (wrong-number-of-arguments length 0)

7.3 nthcdr ¶

De functie nthcdr is geassocieerd met de functie cdr. Wat het doet is dat het herhaaldelijk de CDR van een lijst neemt.

Wanneer je de CDR van de lijst (den spar eik esdoorn) neemt, krijg je de lijst (spar eik esdoorn). Wanneer je dit herhaalt op wat je terugkreeg, krijg je de lijst (eik esdoorn) terug. (Als je herhaaldelijk de CDR van de originele lijst neemt, dan krijg je natuurlijk de originele CDR terug, omdat deze functie de lijst niet verandert. Je moet de CDR van de CDR nemen, enzovoort.) Wanneer je hiermee doorgaat, dan krijg je uiteindelijk de lege lijst terug, welke in dit geval in plaats van () getoond wordt als nil.

Ter beoordeling is hier een lijst van herhaaldelijke CDR’s, de tekst volgend op ‘⇒’ toont wat wordt teruggegeven.

(cdr '(den spar eik esdoorn))
     ⇒ (spar eik esdoorn)

(cdr '(spar eik esdoorn))
     ⇒ (eik esdoorn)

(cdr '(eik esdoorn))
     ⇒ (esdoorn)

(cdr '(esdoorn))
     ⇒ nil

(cdr 'nil)
     ⇒ nil

(cdr ())
     ⇒ nil

Het is ook mogelijk meerdere CDR’s te doen zonder de waarden er tussen te tonen.

(cdr (cdr '(den spar eik esdoorn)))
     ⇒ (eik esdoorn)

in dit voorbeeld evalueert de Lisp interpreter eerst de binnenste lijst. De binnenste lijst is gequote, en geeft dus de lijst zoals die is door aan de binnenste cdr. Deze cdr geeft de lijst, bestaande uit het tweede en volgende elementen van de lijst door aan de buitenste cdr, die de lijst produceert die bestaat uit het derde en volgende elementen van de oorspronkelijke lijst. In dit voorbeeld wordt de cdr herhaald en geeft een lijst terug die bestaat uit de oorspronkelijke lijst zonder de eerste twee elementen.

De functie nthcdr doet hetzelfde als een herhaalde aanroep van cdr. In het volgende voorbeeld wordt het argument 2 doorgegeven aan de functie nthcdr, samen met de lijst, en de teruggegeven waarde is de lijst zonder de eerste twee elementen, wat exact hetzelfde is als twee keer cdr herhalen op de lijst.

(nthcdr 2 '(den spar eik esdoorn))
     ⇒ (eik esdoorn)

Je kunt met de oorspronkelijke lijst van vier elementen zien wat gebeurt wanneer je verschillende numerieke argumenten doorgeeft aan nthcdr, waaronder 0, 1 en 5:

;; Houd de lijst zoals die was.
(nthcdr 0 '(den spar eik esdoorn))
     ⇒ (den spar eik esdoorn)

;; Geef een exemplaar terug zonder eerste element.
(nthcdr 1 '(den spar eik esdoorn))
     ⇒ (spar eik esdoorn)

;; Geef een exemplaar terug zonder drie elementen.
(nthcdr 3 '(den spar eik esdoorn))
     ⇒ (esdoorn)

;; Geef een exemplaar terug waar alle vier elementen ontbreken.
(nthcdr 4 '(den spar eik esdoorn))
     ⇒ nil

;; Geef een exemplaar terug zonder alle elementen.
(nthcdr 5 '(den spar eik esdoorn))
     ⇒ nil

7.4 nth ¶

De functie nthcdr neemt herhaaldelijk de CDR van een lijst. De functie nth neemt de CAR van het resultaat dat door nthcdr wordt teruggegeven. Het geeft het N-de element van de lijst terug.

Dus, als het, in verband met de snelheid, niet in C zou zijn gedefinieerd zou dit de definitie van nth zijn:

(defun nth (n list)
  "Returns the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned."
  (car (nthcdr n list)))

(Oorspronkelijk was nth gedefinieerd in Emacs Lisp in subr.el, maar de definitie was in de jaren tachtig opnieuw gedaan in C.)

De functie nth geeft een enkel element van een lijst terug. Dit kan erg handig zijn.

Merk op de de elementen vanaf nul zijn genummerd, niet een. Dat wil zeggen dat het eerste element van een lijst, zijn CAR, is het nulde element. Deze nul-gebaseerde telling is lastig voor mensen die gewend zijn die gewend zijn dat het eerste element in een lijst nummer een is, wat een-gebaseerd is.

Bijvoorbeeld:

(nth 0 '("een" "twee" "drie"))
    ⇒ "een"

(nth 1 '("een" "twee" "drie"))
    ⇒ "twee"

Het is waardevol op te merken dat nth, net als nthcdr en cdr, de oorspronkelijke lijst niet verandert—de functie is niet-destructief. Dit is in scherp contrast met de functies setcar en setcdr.

7.5 setcar ¶

Zoals je wellicht door hun namen vermoedt, stellen de functies setcar en setcdr de CAR of de CDR van een lijst in op een nieuwe waarde. Zij wijzigen echt de oorspronkelijke lijst, in tegenstelling tot car en cdr die de oorspronkelijke lijst laten zoals die was. Een manier om te ontdekken hoe dit werkt is door te proberen. Wij beginnen met de functie setcar.

Eerst maken we een lijst en stellen die met de speciale vorm setq als de waarde in van een variabele. Omdat we van plan zijn setcar te gebruiken om de lijst te wijzigen, moet deze setq geen gebruik van de gequote vorm '(antiloop giraf leeuw tijger) maken, omdat dit een lijst oplevert die onderdeel van het programma is en slechte dingen zouden kunnen gebeuren wanneer we proberen een deel van het programma te wijzigen terwijl dat loopt. In het algemeen moeten de componenten van een Emacs Lisp programma constant zijn (of ongewijzigd) terwijl het programma loopt. In plaats daarvan construeren we daarom als volgt een lijst met de functie list:

(setq dieren (list 'antiloop 'giraf 'leeuw 'tijger))

Wanneer je dit in Info binnen GNU Emacs leest kan je deze expressie op de gebruikelijke manier evalueren, door de cursor achter de expressie te plaatsen en C-x C-e te typen. (Ik doe dat meteen hier terwijl ik dit schrijft. Dat is een van de voordelen van een in je computer omgeving ingebouwde interpreter Overigen, wanneer is niets op de regel na het laatste haakje staat, zoals commentaar, kan point ook de volgende regel staan. Dus als point op de eerste kolom van de regel staat, hoef je die niet te verplaatsten. Emacs staat zelfs een willekeurige hoeveelheid witte ruimte achter het laaste haakje toe.)

Wanneer we de variabele dieren evalueren dan zien we dat die gebonden is aan de lijst (antiloop giraf leeuw tijger):

dieren
     ⇒ (antiloop giraf leeuw tijger)

Anders gezegd, de variabele dieren wijst naar de lijst (antiloop giraf leeuw tijger).

Vervolgens evalueren we de functie setcar terwijl we daar twee argumenten aan doorgeven, de variabele dieren en het geqoute symbool nijlpaard. Dit doen we door de lijst van drie elementen (setcar dieren 'nijlpaard) te schrijven en die dan op de gebruikelijke manier te evalueren.

(setcar dieren 'nijlpaard)

Na het evalueren van deze expressie, evalueer je de variabele dieren nogmaals. Je zult zien dat de lijst gewijzigd is:

dieren
     ⇒ (nijlpaard giraf leeuw tijger)

Het eerste element van de lijst, antiloop is vervangen met nijlpaard.

We zien dus dat setcar geen nieuw element aan de lijst heeft toegevoegd, wat cons gedaan zou hebben, maar het verving antiloop met nijlpaard. Het wijzigde de lijst.

7.6 setcdr ¶

De functie setcdr is vergelijkbaar met de functie setcar, behalve dat de functie de tweede en volgende elementen van een lijst vervangt in plaats van het eerste element.

(Kijk vooruit naar De kill-new functie om te zien hoe het laatste element van een list te wijzigen. De kill-new functie gebruikt de nthcdr en de setcdr functies.)

Om de zien hoe dit werkt stel je waarde van de variabele in op een lijst van gedomesticeerde dieren door de volgende expressie te evalueren:

(setq gedomesticeerde-dieren (list 'paard 'koe 'schaap 'gijt))

Wanneer je nu de lijst evalueert, krijg je de lijst (paard koe schaap gijt) terug.

gedomesticeerde-dieren
     ⇒ (paard koe schaap gijt)

Evalueer vervolgens setcdr met twee argumenten, de naam van de variabele die een lijst als waarde heeft, en de lijst waarop we de CDR van de eerste lijst willen instellen:

(setcdr gedomesticeerde-dieren '(kat hond))

Wanneer je deze expressie evalueert verschijnt de lijst (kat hond) in het echogebied. Dit is de waarde die de functie teruggaf. Het resultaat waar wij in geïnteresseerd zijn is in het zij-effect, wat we kunnen zien wanneer we de variabele gedomesticeerde-dieren evalueren:

gedomesticeerde-dieren
     ⇒ (paard kat hond)

Inderdaad is de lijst gewijzigd van (paard koe schaap gijt) naar (paard kat hond). De CDR van de lijst is gewijzigd van (koe schaap gijt) naar (kat hond).

7.7 Oefening ¶

Construeer een lijst met vier vogels door verschillende expressies met cons te evalueren. Ontdek wat gebeurt wanneer je een lijst met zichzelf const-t. Vervang het eerste element van de lijst met vier vogels met een vis. Vervang de rest van de lijst met een lijst van andere vissen.

8.1 zap-to-char ¶

Laten we naar de interactieve functie zap-to-char kijken.

• De complete zap-to-char implementatie
• De interactive expressie
• De body van zap-to-char
• De functie search-forward
• De speciale vorm progn
• zap-to-char samengevat

(defun zap-to-char (arg char)
  "Kill up to and including ARG'th occurrence of CHAR.
Case is ignored if `case-fold-search' is non-nil in the current buffer.
Goes backward if ARG is negative; error if CHAR not found."
  (interactive "p\ncZap to char: ")
  (if (char-table-p translation-table-for-input)
      (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point) (progn
                         (search-forward (char-to-string char)
                                         nil nil arg)
                         (point))))

(interactive "p\ncZap to char: ")

(if (char-table-p translation-table-for-input)
    (setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
                       (search-forward (char-to-string char) nil nil arg)
                       (point)))

(search-forward (char-to-string char) nil nil arg)

(search-forward "doel-string"
                zoeklimiet
                wat-te-doen-als-zoeken-faalt
                aantal-herhalingen)

(progn
  body...)

8.2 kill-region ¶

De functie zap-to-char gebruikt de kill-region. Deze functie clipt de tekst van een region en kopieert die tekst naar de killring, van waar het kan worden opgehaald.

De Emacs 22 versie van die functie gebruikt condition-case en copy-region-as-kill die wij beide uitleggen. condition-case is een belangrijke speciale vorm.

De functie kill-region in essentie roept condition-case aan, die drie argumenten verwacht. Het eerste argument deze functie doet niets. Het tweede argument bevat de code die het werk doet als alles goed gaat. Het derde argument bevat de code die aangeroepen wordt in het geval van een fout.

• De complete kill-region definitie
• condition-case
• Lisp macro

(defun kill-region (beg end)
  "Kill (\"cut\") text between point and mark.
This deletes the text from the buffer and saves it in the kill ring.
The command \\[yank] can retrieve it from there. ... "

  ;; • Omdat volgorde belangrijk is, geeft eerst point door.
  (interactive (list (point) (mark)))
  ;; • En vertel ons wanneer we geen tekst kunnen snijden.
  ;; 'unless' is een 'if' zonder een dan-deel.
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))

  ;; • 'condition-case' verwacht drie argumenten.
  ;;    Wanneer het eerste argument nil is, zoals hier,
  ;;    wordt information over het fout signaal niet
  ;;    bewaard voor gebruik in een andere functie.
  (condition-case nil

      ;; • Het tweede argument van 'condition-case' vertelt de
      ;;    Lisp interpreter wat te doen als alles goed gaat.

      ;;    Het start met een 'let' functie die de string extraheert
      ;;    en test of die bestaat. Zo ja (dat is wat de
      ;;    'when' checkt), roept het een 'if' functie aan die vaststelt
      ;;    of het vorige commando een andere aanroep was van
      ;;    'kill-region'; zo ja, wordt de nieuwe tekst achter de
      ;;    vorige tekst geplakt; zo niet dan wordt een andere functie,
      ;;    'kill-new', aangeroepen.

      ;;    De 'kill-append' functie plakken de nieuwe string en
      ;;    de oude aan elkaar. De 'kill-new' functie voegt tekst in als een
      ;;    nieuw item in de killring.

      ;;    'when' is een 'if' zonder een dan-deel.  De tweede 'when'
      ;;    controleert opnieuw of de bestaande string bestaat;
      ;;    daarnaast, controleert het of het vorige commando een
      ;;    andere aanroep van 'kill-region' was.  Wanneer een van beide
      ;;    condities waar zijn, dan stelt het het huidige commando in
      ;;    op 'kill-region'.

      (let ((string (filter-buffer-substring beg end t)))
        (when string                    ;STRING is nil if BEG = END
          ;; Voeg die string op of andere manier aan de killring toe.
          (if (eq last-command 'kill-region)

              ;;    − 'yank-handler' is een optional argument van
              ;;    'kill-region' dat aan de functies 'kill-append' en
              ;;    'kill-new' hoe om te gaan met eigenschappen toegevoegd
              ;;    aan de tekst, zoals 'bold' of 'italics'.
              (kill-append string (< end beg) yank-handler)
            (kill-new string nil yank-handler)))
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        nil)

    ;;  • Het derde argument van 'condition-case' vertelt de interpreter
    ;;    hoe om te gaan met een fout.

    ;;    Het derde argument heeft een condities deel en een body deel.
    ;;    Wanneer aan de condities is voldaan (in dit geval,
    ;;             wanneer tekst of buffer read-only zijn)
    ;;    dan wordt de body uitgevoerd.

    ;;    The first part of the third argument is the following:
    ((buffer-read-only text-read-only) ;; the if-part
     ;; ...  the then-part
     (copy-region-as-kill beg end)

     ;;    Vervolgens, dus als deel van het dan-deel, zet this-command, zodat
     ;;    het wordt gebruikt in geval van een fout
     (setq this-command 'kill-region)
     ;;    Tenslotte, in het dan-deel, stuur een boodschap wanneer je de
     ;;    tekst niet naar de the killring kan kopiëren zonder een fout te signaleren
     ;;    maar doe dat niet als je het niet mag.

     (if kill-read-only-ok
         (progn (message "Read only text copied to kill ring") nil)
       (barf-if-buffer-read-only)
       ;; Als het buffer niet read-only is, is de tekst.
       (signal 'text-read-only (list (current-buffer)))))))

(condition-case
  var
  bodyform
  error-handler...)

If geen errors, voer alleen deze code uit
    maar, if errors, voer deze andere code uit.

(if (eq last-command 'kill-region)
    (kill-append string (< end beg) yank-handler)
  (kill-new string nil yank-handler))

(kill-append string (< end beg) yank-handler)

8.3 copy-region-as-kill ¶

De functie copy-region-as-kill kopieert een region met tekst van een buffer en (via hetzij kill-append of kill-new) bewaart het in de kill-ring.

Wanneer je copy-region-as-kill meteen na een kill-region commando aanroept, plakt Emacs de nieuw gekopieerde tekst aan de voorgaande gekopieerde tekst. Dit betekent dat als je de tekst terug-yankt, je alles krijgt, van zowel deze als de voorgaande operatie. Anderzijds, wanneer een ander commando aan de copy-region-as-kill voorafging, dan kopieert de functie de tekst in een separaat item in de killring.

• De complete copy-region-as-kill functiedefinitie
• De body van copy-region-as-kill

(defun copy-region-as-kill (beg end)
  "Save the region as if killed, but don't kill it.
In Transient Mark mode, deactivate the mark.
If `interprogram-cut-function' is non-nil, also save the text for a window
system cut and paste."
  (interactive "r")

  (if (eq last-command 'kill-region)
      (kill-append (filter-buffer-substring beg end) (< end beg))
    (kill-new (filter-buffer-substring beg end)))

  (if transient-mark-mode
      (setq deactivate-mark t))
  nil)

(defun copy-region-as-kill (argument-list)
  "documentatie..."
  (interactive "r")
  body...)

  (if (eq last-command 'kill-region)
      ;; dan-deel
      (kill-append  (filter-buffer-substring beg end) (< end beg))
    ;; anders-deel
    (kill-new  (filter-buffer-substring beg end)))

(defun kill-append (string before-p &optional yank-handler)
  "Append STRING to the end of the latest kill in the kill ring.
If BEFORE-P is non-nil, prepend STRING to the kill.
... "
  (let* ((cur (car kill-ring)))
    (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)
                  (equal yank-handler
                         (get-text-property 0 'yank-handler cur)))
              yank-handler)))

(if before-p                            ; if-deel
    (concat string cur)                 ; dan-deel
  (concat cur string))                  ; anders-deel

(concat string cur)

(concat cur string))

(concat "abc" "def")
     ⇒ "abcdef"

(concat "nieuw "
        (car '("eerste element" "tweede element")))
     ⇒ "nieuw eerste element"

(concat (car
        '("eerste element" "tweede element")) " aangepast")
     ⇒ "eerste element aangepast"

(defun kill-new (string &optional replace yank-handler)
  "Make STRING the latest kill in the kill ring.
Set `kill-ring-yank-pointer' to point to it.
If `interprogram-cut-function' is non-nil, apply it to STRING.
Optional second argument REPLACE non-nil means that STRING will replace
the front of the kill ring, rather than being added to the list.
..."

  (if (> (length string) 0)
      (if yank-handler
          (put-text-property 0 (length string)
                             'yank-handler yank-handler string))
    (if yank-handler
        (signal 'args-out-of-range
                (list string "yank-handler specified for empty string"))))

  (if (fboundp 'menu-bar-update-yank-menu)
      (menu-bar-update-yank-menu string (and replace (car kill-ring))))

  (if (and replace kill-ring)
      (setcar kill-ring string)
    (push string kill-ring)
    (if (> (length kill-ring) kill-ring-max)
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))

  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

Make STRING the latest kill in the kill ring.

  (if (and replace kill-ring)
      ;; dan
      (setcar kill-ring string)

    ;; anders
    (push string kill-ring)

    (if (> (length kill-ring) kill-ring-max)
        ;; voorkom een te lange kill ring
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))

  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

(setcar kill-ring string)

(push string kill-ring)

(setq kill-ring (cons string kill-ring))

(add-to-list kill-ring string)

(setq voorbeeldlijst '("hier is een clausule" "andere clausule"))

voorbeeldlijst
     ⇒ ("hier is een clausule" "andere clausule")

(push "een derde clausule" voorbeeldlijst)

voorbeeldlijst
     ⇒ ("een derde clausule" "hier is een clausule" "andere clausule")

(if (> (length kill-ring) kill-ring-max)
    (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))

(setq bomen (list 'esdoorn 'eik 'spar 'berk))
      ⇒ (esdoorn eik spar berk)

(setcdr (nthcdr 2 bomen) nil)
     ⇒ nil

bomen
      ⇒ (esdoorn eik spar)

(setq kill-ring-yank-pointer kill-ring)

  (if (fboundp 'menu-bar-update-yank-menu)
       (menu-bar-update-yank-menu string (and replace (car kill-ring))))

  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))

8.4 Uitwijding naar C ¶

De functie copy-region-as-kill function (zie copy-region-as-kill) gebruikt de functie filter-buffer-substring, die op zijn beurt de functie delete-and-extract-region gebruikt. Het verwijdert de inhoud van een region en die kun je niet terugkrijgen.

In tegenstelling tot andere code die we hier besproken hebben, is de functie delete-and-extract-region niet in Emacs Lisp geschreven, het is geschreven in C en is een van de primitieven van het GNU Emacs systeem. Omdat het erg eenvoudig is, dwaal ik even af van Lisp en beschrijf het hier.

Net als veel van de andere Emacs primitieven, is delete-and-extract-region geschreven als een C macro, een macro die een sjabloon voor code is. De complete macro ziet er zo uit:

DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
       Sdelete_and_extract_region, 2, 2, 0,
       doc: /* Delete the text between START and END and return it.  */)
  (Lisp_Object start, Lisp_Object end)
{
  validate_region (&start, &end);
  if (XFIXNUM (start) == XFIXNUM (end))
    return empty_unibyte_string;
  return del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);
}

Zonder verder op de details van het schrijven van macro’s in te gaan, wil ik er op wijzen dat de macro start met het woord DEFUN. Het woord DEFUN was gekozen omdat de code hetzelfde doel dient als defun in Lisp. (De C macro DEFUN is gedefinieerd in emacs/src/lisp.h.)

Het woord DEFUN wordt gevolgd door zeven delen binnen haakjes:

• Het eerste deel is de naam die de functie in Lisp krijgt, delete-and-extract-region.
• Het tweede deel is de naam van de functie in C, Fdelete_and_extract_region. Volgens de conventie begint die met een ‘F’. Omdat C geen streepjes in namen gebruikt, zijn in plaats daarvan underscores gebruikt.
• Het derde deel is de naam van de C constant structure die informatie over de deze functie opslaat voor intern gebruik. Het is de naam van de functie in C maar begint met een ‘S’ in plaats van een ‘F’.
• Het vierde en vijfde deel specificeren het minimum en maximum aantal argumenten dat de functie kan krijgen. Deze functie vereist precies 2 argumenten.
• Het zesde deel is bijna hetzelfde als het argument dat volgt op de interactive declaratie in een functie geschreven in Lisp: een letter, misschien gevold door een prompt. Het enige verschil met Lisp is wanneer de macro zonder argumenten wordt aangeroepen. Dan schrijf je een 0 (wat een null-string is) zoals in deze macro.

  Wanneer je argumenten specificeert, dan zet je die tussen aanhalingstekens. De C macro voor goto-char bevat "NGoto char: " op deze plek om aan te gevne dat de functie een raw prefix verwacht, in dit geval een numerieke lokatie in het buffer, en een prompt verschaft.

• Het zevende deel is een documentatiestring, net zoals voor een functie geschreven in Emacs Lisp. Dit is geschreven als C commentaar. (Wanneer je Emacs bouwt extraheert het programma lib-src/make-docfile deze commentaren en gebruikt die om de documentatie te maken.)

In een C macro komen de formele parameters daarna, met een statement over het soort object dat ze zijn, gevolgd door de body van de macro. Voor delete-and-extract-region bestaat de body uit de volgende vier regels:

validate_region (&start, &end);
if (XFIXNUM (start) == XFIXNUM (end))
  return empty_unibyte_string;
return del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);

De functie validate_region controleert of de waarden die als begin en eind zijn doorgegeven, van het juiste type en binnen de range zijn.

De functie del_range_1 verwijdert daadwerkelijk de tekst. Het is een complexe functie waar we niet naar kijken. Het update het buffer en doet andere dingen. Echter het is het waard te kijken naar de twee argumenten die doorgeven worden aan del_range_1. Dit zijn XFIXNUM (start) en XFIXNUM (end).

Wat de C-taal betreft, zijn start en end twee vage waarden die het begin en eind van de te verwijderen region markeren. Meer precies, en met meer expertise genodigd om te begrijpen, zijn de twee waarden van het type Lisp_Object, wat een C-pointer kan zijn, of een C-integer, of een C-struct. Het kan de C code normaalgesproken niet schelen hoe Lisp_Object is geïmplementeerd.

De breedte van Lisp_Object hangt af van de machine, en is typisch 32 of 64 bits. Enkele van de bits worden gebruikt om het type informatie te specificeren, de resterende bits voor de inhoud.

‘XFIXNUM’ is een C macro die de relevante integer uit de langere collectie bits extraheert. De type-bits worden genegeerd.

Het commando in delete-and-extract-region ziet het zo uit:

del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);

Het verwijdert de region tussen de beginpostitie, start, en de eindpositie, end.

Vanuit het gezichtspunt van de persoon die Lisp schrijft, is Emacs heel eenvoudig, maar eronder is een grote hoeveelheid compliciteit verborgen die het allemaal laat werken.

8.5 Initialiseer een variabele met defvar ¶

De functie copy-region-as-kill is in Emacs Lisp geschreven. Twee functies in het, kill-append en kill-new, kopiëren een region in een buffer en bewaren het in een variabele met de naam kill-ring. Deze sectie beschijft hoe de kill-ring met de speciale vorm defvar is gecreëerd en geïnitialiseerd.

(Opnieuw merken we op dat de term kill-ring een misleidende naam is. De tekst die uit het buffer is geknipt kan teruggehaald worden. Het is niet een ring van lijken, maar een ring van herleefbare tekst.)

In Emacs Lisp wordt een variabele zoals kill-ring met de speciale vorm gecreëerd en van een initiële waarde voorzien. De naam komt van “define variable”.

De speciale vorm defvar stelt de waarde van een variabele in, net als setq. Het verschilt van setq op drie manieren: ten eerste markeert het de variabele als “speciaal” zodat het altijd dynamisch gebonden is, zelfs wanneer lexcial-binding t is (zie Variabelen). Ten tweede, het stelt alleen de waarde van de variabele in wanneer de variabele nog geen waarde heeft. Wanneer de variabele al een waarde heeft, overschrijft defvar de bestaande waarde niet. Ten derde, defvar heeft een documentatiestring.

(Er is een gerelateerde macro, defcustom, gemaakt voor variabelen die mensen customizen. Het heeft meer eigenschappen dan defvar. (Zie Variabelen specificeren met defcustom.)

• De huidige waarde van een variabele zien
• defvar en een sterretje

Documentation:
List of killed text sequences.
Since the kill ring is supposed to interact nicely with cut-and-paste
facilities offered by window systems, use of this variable should

interact nicely with `interprogram-cut-function' and
`interprogram-paste-function'.  The functions `kill-new',
`kill-append', and `current-kill' are supposed to implement this
interaction; you may want to use them instead of manipulating the kill
ring directly.

(defvar kill-ring nil
  "List of killed text sequences.
...")

(defvar shell-command-default-error-buffer nil
  "*Buffer name for `shell-command' ... error output.
... ")

8.6 Terugblik ¶

Hier is een korte samenvatting van sommige recent geïntroduceerde functies.

car

cdr

car geeft het eerste element van een lijst terug. cdr geeft het tweede en volgende elementen van de lijst terug.

Bijvoorbeeld:

(car '(1 2 3 4 5 6 7))
     ⇒ 1
(cdr '(1 2 3 4 5 6 7))
     ⇒ (2 3 4 5 6 7)

cons

cons construeer een lijst door het eerste element voor het tweede te zetten.

Bijvoorbeeld:

(cons 1 '(2 3 4))
     ⇒ (1 2 3 4)

funcall

funcall evalueert het eerste argument als functie. Het geeft de resterende argumenten door aan het eerste argument.

nthcdr

Geeft het resultaat van n keer CDR nemen van een lijst. De “rest van de rest” als het ware.

Bijvoorbeeld:

(nthcdr 3 '(1 2 3 4 5 6 7))
     ⇒ (4 5 6 7)

setcar

setcdr

setcar wijzigt het eerste element van een lijst, setcdr wijzigt het tweede en volgende elementen van een lijst.

Bijvoorbeeld:

(setq triple (list 1 2 3))

(setcar triple '37)

triple
     ⇒ (37 2 3)
(setcdr triple '("foo" "bar"))

triple
     ⇒ (37 "foo" "bar")

progn

Evalueer achtereenvolgens elk argument en geef de waarde van de laatste terug.

Bijvoorbeeld:

(progn 1 2 3 4)
     ⇒ 4

save-restriction

Bewaar de versmalling die eventueel actief is in het huidige buffer en herstel die versmalling na het evalueren van de argumenten.

search-forward

Zoek voor een string, en wanneer die string gevonden is, verplaats point. Met een reguliere expressie gebruik de vergelijkbare re-search-forward. (Zie Reguliere expressie zoekopdrachten, voor een uitleg van reguliere expressies patronen en zoekopdrachten.)

search-forward en re-search-forward hebben vier argumenten:

1. De string of reguliere expressie om naar te zoeken.
2. Optioneel, de limiet van de zoekopdracht.
3. Optioneel, wat te doen als de zoekopdracht mislukt, geef nil terug of een fout.
4. Optioneel, hoeveel keer de zoekopdracht te herhalen. Wanneer negatief, zoek achterwaarts.

kill-region

delete-and-extract-region

copy-region-as-kill

kill-region verwijdert de tekst tussen point en mark uit het buffer en bewaart die tekst in de killring, zodat je die met yanken terug kunt krijgen.

copy-region-as-kill kopieert de tekst tussen point en mark naar de killring, van waar je het met yanken terug kunt krijgen. De functie verwijdert de tekst niet uit het buffer.

delete-and-extract-region verwijdert de tekst tussen point en mark uit het buffer en gooit het weg. Je kunt het niet terug krijgen. (Dit is geen interactief commando).

8.7 Zoek-oefeningen ¶

• Schrijf een interactieve functie die naar een string zoekt. Wanneer de string gevonden is, plaats point er achter en toon een boodschap die zegt “Gevonden!”. (Maak geen gebruik van search-forward als naam van deze functie, wanneer je dat doet overschrijf je de bestaande versie van search-forward die bij Emacs hoort. Gebruik in plaats daarvan een naam zoals test-zoeken.)
• Schrijf een functie die het derde element van de killring toont in het echogebied als dat element er is. Wanneer de killring geen derde element heeft, toon dat een passende boodschap.

9.1 Symbolen als een ladekast ¶

In een eerdere sectie suggereerde ik dat je een symbool kunt voorstellen als een ladekast. De functiedefinitie wordt in een lade gestopt, de waarde in een andere, enzovoorts. Wat in de lade die de waarde bevat gestopt is, kan worden gewijzigd zonder de inhoud van de waarde die de functiedefinitie bevat te wijzigen, en andersom.

Wat eigenlijk in elke lade gestopt wordt, is het adres van de waarde of de functiedefinitie. Het is alsof je een oude kast op de zolder gevonden hebt, en in een van de lades een kaart vond die de route beschrijft naar waar de begraven schat ligt.

Naast zijn naam, symbooldefinitie en variabele naam, heeft een symbool een lade voor een property list die kan worden gebruikt om andere informatie op te slaan. Property lists bespreken we hier niet, zie Property Lists in The GNU Emacs Lisp Reference Manual.)

Hier is een fantasierijke weergave:

9.2 Oefening ¶

Stel bloemen in op viool en boterbloem. Cons twee andere bloemen aan deze lijst en zet deze lijst op meer-bloemen. Zet de CAR van bloemen op een vis. Wat bevat de lijst meer-bloemen nu?

10.1 Killring overzicht ¶

De killring is een lijst van tekstuele strings. Dit is hoe die er uit ziet:

("wat tekst" "een ander stuk tekst" "nog meer tekst")

Wanneer dit de inhoud van mijn killring is en ik sla C-y aan, dan wordt de karakterstring ‘wat tekst’ in dit buffer op de cursorlokatie ingevoegd.

Het yank commando wordt ook gebruikt om tekst te dupliceren door het te kopiëren. De gekopieerde tekst wordt niet uit het buffer verwijderd, maar een kopie er van is in de killring geplaatst en onmiddellijk ingevoegd door het terug te yanken.

Drie functies worden gebruikt om de tekst uit de killring terug te halen: yank, dat normaalgesproken gebonden is aan C-y. yank-pop, dat normaalgesproken gebonden is aan M-y, en rotate-yank-pointer dat door de twee andere functies gebruikt wordt.

Deze functies refereren aan de killring via de variabele met de naam kill-ring-yank-pointer. Inderdaad, de invoegcode van zowel de functie yank als yank-pop is:

(insert (car kill-ring-yank-pointer))

(Nou, niet meer. In GNU Emacs 22 is de functie vervangen door insert-for-yank, die herhaaldelijk insert-for-yank-1 aanroept voor elk yank-handler segment. insert-for-yank-1, op zijn beurt, stript de tekst eigenschappen van de ingevoegde tekst in overeenstemming met yank-excluded-properties. Anders dat dat, is het gewoon als insert. Wij houden het bij de insert, dit is makkelijker te begrijpen.)

Om te beginnen te begrijpen hoe yank en yank-pop werken, is het eerst nodig naar de variabele kill-ring-yank-pointer te kijken.

10.2 De variabele kill-ring-yank-pointer ¶

kill-ring-yank-pointer is een variabel, net zoals kill-ring een variabele is. Het wijst naar iets dat is gebonden aan de waarde van waar het naar wijst, net als elke andere Lisp variabele.

Dus, als de waarde van de killring is:

("wat tekst" "een ander stuk tekst" "nog meer tekst")

en de kill-ring-yank-pointer wijst naar de tweede clausule, dan is de waarde van kill-ring-yank-pointer:

("een ander stuk tekst" "nog meer tekst")

Zoals in het vorige hoofdstuk (zie Hoe lijsten zijn geïmplementeerd) uitgelegd, bewaart de computer geen twee verschillende exemplaren van de tekst waar zowel de kill-ring als de kill-ring-yank-pointer naar wijzen. De woorden “een ander stuk tekst” en “nog meer tekst” worden niet gedupliceerd. In plaats daarvan wijzen de twee Lisp variabelen naar hetzelfde stuk tekst. Hier is een diagram:

Zowel de variabele kill-ring als de variabele kill-ring-yank-pointer zijn pointers. Maar de killring zelf wordt meestal beschreven alsof het is wat het van gemaakt is. De killring wordt beschreven alsof het een lijst is in plaats van dat het naar de lijst wijst. Omgekeerd, de kill-ring-yank-pointer is beschreven alsof het wijst naar een lijst.

Deze twee manieren om over het zelfde ding te spreken klinken op het eerste gezicht verwarrend maar zijn bij nader inzien logisch. De killring wordt algemeen beschouwd als de complete structuur van data die de informatie bevat van wat recentelijk uit de buffers is geknipt. De kill-ring-yank-pointer anderzijds dient om aan te geven—dat wil zeggen, te wijzen naar—dat deel van de killring waarvan het eerste element (the CAR) zal worden ingevoegd.

10.3 Oefeningen met yank en nthcdr ¶

• Kijk met C-h v (describe-variable) naar je killring. Voeg verschillende items aan je killring toe en kijk opnieuw naar zijn waarde. Ga met M-y (yank-pop) helemaal rond in de killring. Hoeveel items waren in je killring? Vind de waarde van kill-ring-max. Was je killring vol, of had je nog meer blokken tekst kunnen bewaren?
• Construeer met nthcdr en car een reeks expressies om het eerste, tweede, derde en vierde element van een lijst terug te geven.