> For the complete documentation index, see [llms.txt](https://overleaf-pro.ayaka.space/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://overleaf-pro.ayaka.space/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md).
# Hvordan TeX-makroer egentlig fungerer: Del 3
[Del 1](/latex/no/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/no/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/no/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/no/flere-emner/24-how-tex-macros-actually-work-part-6.md)
## Tid for en pause!
Før vi går videre til neste del av denne historien, trenger vi en oppsummering: minne oss selv på hvor vi er på vei og samle tankene våre for å sikre at alle nøkkelideene er på plass. Bare en påminnelse: vårt gjennomarbeidede eksempel bygger på antakelsen om at TeX har lest en linje med tekst som inneholder `Hallo verden \\jobname` og at TeX setter dette for å bygge et avsnitt.
### Det endelige målet
Målet vårt er å utvikle en bedre (dypere) forståelse av hva TeX-makroer er og hvordan de fungerer. Men for å komme dit må vi først forstå hvordan TeX leser en inndatafil og behandler tegnene i den. Her er et sammendrag av temaene som er dekket så langt.
* TeX leser (skanner) hvert tegn i inndataen din, og for hvert tegn har TeX to opplysninger:
* **tegnkode**: et heltall som brukes til å identifisere det tegnet, for eksempel når det lagres i en .tex-inndatafil;
* **kategorikode**: et annet heltall, internt i TeX, som det bruker til å tildele mening til hvert tegn som leses fra inndataen.
* Så snart et tegn er lest inn av TeX, blir kategori-koden for hvert tegn *permanent* knyttet til det enkelte tegnet gjennom opprettelsen av en tegntoken:
* TeX bruker en enkel formel for å «pakke sammen» en tegnkode og den tilhørende kategori-koden til et heltall kalt en tegntoken.
* Du kan endre betydningen til ethvert tegn som TeX har *ennå ikke lest inn* ved å tildele en annen kategori-kode til et hvilket som helst tegn hvis oppførsel du ønsker å endre — altså modifisere måten TeX behandler det tegnet på.
* Å redefinere (omtilordne) kategori-koder gjøres ved hjelp av TeXs primitive `\catcode` kommandoen.
* Når TeX ser en kategori-kode på 0, går den over i en spesiell skanningsmodus og begynner å lete etter en kommando: enten et (potensielt) flerbokstavs *kontrollord* eller et enbokstavs *kontrollsymbol*.
Så langt har vi sett på TeXs innlesingsprosess når den identifiserer enkelttegn og bruker kategori-koden til hvert tegn for å finne ut hva som skal gjøres videre. Noen tegn er bare vanlige tekstbiter som skal settes (f.eks. kategori-kode 11), men vi har også sett mellomromstegn (kategori-kode 10) og escape-tegn (kategori-kode 0). Det finnes andre kategori-koder som vi av hensyn til korthet ikke har sett på — som kategori-kode 1 («start gruppe», f.eks., `{`), kategori-kode 2 («slutt gruppe», f.eks., `}`) og andre. Hver kategori-kode spiller sin egen rolle i TeXs innlesing av inndata og den påfølgende behandlingen av programvarens prosesser/algoritmer inne i TeX.
### Tokens: en rask gjennomgang
Begrepet «tokens» er sentralt i måten TeX fungerer på: du vil se «tokens» nevnt eller referert til gjennom TeX-relaterte bøker, artikler og nettmiljøer, så det er verdt å gå kort gjennom dette temaet — du finner mer detaljer i en tidligere publisert artikkel [Hva er et «TeX-token»?](/latex/no/dybdeartikler/53-what-is-a-tex-token.md)
Vi har allerede sett at TeX konverterer inndatategn til tokens ved å kombinere tegnkoden og kategori-koden til ett enkelt sammensatt heltall. TeX gjør noe lignende for kommandoer: ved å bruke navnet på kommandoen beregner det et heltall kalt en *kommando-token* (vi skal utforske dette mer detaljert). Som en veiledning kan du tenke på tokens som TeXs måte å «pakke inn» elementer det har lest fra inndataen, slik at de er klare til å sendes videre til neste trinn i TeXs behandling. Når alle elementer (tegn eller kommandoer) er pent pakket inn i én numerisk representasjon, blir det enklere å behandle dem videre i kjeden. For eksempel når TeX vil lagre noe av inndataen din for å bruke det senere, som en makrodefinisjon, trenger TeX bare å lagre makrodefinisjonen din, uansett hvor kompleks den er, som en sekvens av heltall, der hvert heltall er en token som representerer et tegn eller en kommando som utgjør en del av (er inneholdt i) makrodefinisjonen din.
## Så, hva nå?
I den siste delen av del 2 så vi hvordan et escape-tegn (kategori-kode 0) setter TeX inn i en spesiell behandlingsmodus der det leter etter navnet på en kommando. I vårt eksempel oppdaget TeX tegnstrengen `jobname` og vi avsluttet del 2 på punktet der TeX skulle «gjøre noe» med den tegnstrengen (navnet på en kommando). I denne delen skal vi se nærmere på hva TeX gjør videre.
Når TeX har identifisert at en bestemt sekvens av tegn i inndatafilen din representerer navnet på en kommando (her, `jobname`) må TeX, avhengig av hva den holder på med, kanskje utføre den kommandoen. Vi sier «kanskje må», fordi det finnes tilfeller der TeX ikke umiddelbart prøver å utføre en kommando: for eksempel når det definerer en makro (TeX bygger tokenlister) — temaer vi skal diskutere senere. Vi fortsetter imidlertid å følge eksemplet vårt der TeX setter et avsnitt og *vil*, i denne situasjonen, må utføre `\jobname`.
### Fra en tegnstreng til å kjøre en kommando: hvordan?
La oss først gå tilbake til figur 5b fra del 2, der TeX har identifisert at en bestemt tegnstreng i inndataen utgjør navnet på en kommando: `jobname`. Figur 5b indikerer at TeX må «sjekke interne tabeller...». Hva betyr det *egentlig*?
En annen, mer detaljert, beskrivelse av hvordan TeX «sjekker interne tabeller» for å gå fra å ha en tegnstreng (f.eks., `jobname`) til å finne ut nøyaktig hva kommandoen er, og hva den betyr, finner du i en tidligere artikkel [Hva er et «TeX-token»?](/latex/no/dybdeartikler/53-what-is-a-tex-token.md) Her oppsummerer vi hovedideene samtidig som vi prøver å unngå for mye gjentakelse.
La oss begynne med en analogi. Anta at du leser en bok og støter på et ukjent ord: hva gjør du? I dag er det nesten sikkert «søk på Google», men la oss anta at du foretrekker en eldre metode: du tar frem en ordbok som lister opp ord og gir betydningen deres. TeX har en tilsvarende mekanisme: en intern «ordbok» som lister opp alle kommandoene TeX kjenner til for øyeblikket — og «betydningen» av disse kommandoene. Med «betydning» mener vi hvilken type kommando det er: hva den gjør, pluss eventuell annen informasjon TeX kan trenge for å kjøre den kommandoen. Legg også merke til at begrepet «kommando» inkluderer alle TeX/LaTeX-makroer skrevet av brukere/TeX-programmerere og de [hundrevis av innebygde primitive kommandoer](/latex/no/flere-emner/46-tex-primitives-listed-by-tex-engine.md).
La oss fortsette med ordbok-analogien vår. Når vi som menneskelig leser trenger å slå opp betydningen av et ord, søker vi i ordboken ved hjelp av den alfabetiske ordlisten som ordboken gir — men TeX fungerer selvfølgelig ikke helt slik. Tilbake til vårt opprinnelige `jobname` eksempel: hvordan finner TeX «betydningen» av `jobname`— og hva gir egentlig den «betydningen» TeX?
I stedet for å gi en intern «alfabetisk liste» over alle kommandoene TeX kjenner til, gjør den noe litt annerledes. TeX konverterer hele tegnsekvensen — som finnes i navnet på en kommando — til et enkelt heltall, som brukes til å identifisere (representere) den kommandoen. Internt opprettholder TeX en stor «ordbok» over alle kjente kommandoer, der den lagrer *heltallene* beregnet fra kommandonavnene — merk at den ordboken ikke lagrer selve kommandonavnene som sekvenser av bokstaver (kalt *strenger*). TeX bruker den ordboken for alle de innebygde kommandoene sine (primitivene) *og* den vil bruke den til å lagre detaljer om enhver makro (kommando) som er opprettet av brukere: navnet på makroen din blir gjort om til et heltall, og det heltallet blir «registrert» inne i TeXs ordbok.
Hver gang TeX oppdager en kommando som brukes i inndataen din, og trenger å vite noe om den kommandoen, konverterer den tegnrekken i kommandonavnet til et «ekvivalent» heltall og bruker det heltallet til å slå opp kommandoen i sin «store ordbok». Programmører blant dere vil kanskje vite at TeX bruker en form for [hash-funksjon](https://en.wikipedia.org/wiki/Hash_function) hash-funksjon
### Figur 6: Fra tegn til kommandobetydning
Følgende figur viser reisen en kommando gjennomgår når TeX konverterer tegnstrengen til et ekvivalent heltall, som kalles **curcs**, og bruker det heltallet til å slå opp kommandens betydning i TeXs «store ordbok». Resultatet av det oppslaget er to opplysninger: to heltall, kalt **curcmd** og **curchr**, som TeX kan bruke til å finne ut nøyaktig hva kommandoen gjør og hvordan den deretter skal utføres.
Internt opprettholder TeX en variabel kalt **curcs** (**gjeld**ende **c**kontroll **s**sekvens) som brukes til å lagre heltallsverdien til kommandoen TeX for øyeblikket arbeider med — altså **curcs** lagrer heltallet som er beregnet fra navnet på kommandoen. Det er ikke helt hele historien, for det er én detalj til: hvis TeX nettopp har lest/behandlet et tegn, ikke en kommando, vil den sette **curcs** til verdien 0, for å huske at det siste som ble lest inn var et tegn, ikke en kommando.
### Hva kommandoer betyr for TeX
Hvis vi ser på settet av [innebygde kommandoer som tilbys av TeX-motorer](/latex/no/flere-emner/46-tex-primitives-listed-by-tex-engine.md) kan vi se at noen av disse kommandoene er nært beslektede: de utfører lignende oppgaver; for eksempel finnes det 4 primitive kommandoer som alle TeX-motorer bruker til å definere (opprette) makroer: `\def`, `\gdef`, `\edef`, `\xdef`. Disse 4 kommandoene definerer alle makroer, men selvfølgelig gjør hver av dem det litt forskjellig. Hvis vi tenker på dette fra et programmeringssynspunkt: her har vi 4 kommandoer for makrodefinisjon som i grove trekk gjør det samme, men vi må velge mellom dem for å ta hensyn til deres individuelle oppførsel.
For å håndtere dette tildeler TeX to verdier til hver kommando, og disse to verdiene er det TeX forstår som en kommandos «betydning» (dens rolle/hva den gjør) — disse to verdiene er interne i TeX, dypt inne i programvaren, og en del av det «indre maskineriet» som ikke er tilgjengelig for brukere. Hver TeX-kommando, enten det er en innebygd primitiv eller en brukerdefinert kommando, tildeles to verdier som for TeX definerer/klassifiserer dens oppførsel — hva den betyr for TeX. Når TeX bruker sin «store ordbok» til å slå opp en kommando, finner den disse to viktige opplysningene:
* **kommandokode**: en slags «generell klassifisering» som angir hva slags kommando det er — for eksempel en kommando for «makrodefinisjon» (en av `\def`, `\gdef`, `\edef`, `\xdef`); en kommando for å lage bokser (en av `\hbox`, `\vbox` eller `\vcenter`) og så videre for de hundrevis av kommandoene som TeX-motorer støtter. Makroer (brukerdefinerte kommandoer) tildeles også en kommandokode.
* **kommandomodifikator**: Dette er tilleggsinformasjon som gir TeX spesifikk informasjon om en kommando. Makroer (brukerdefinerte kommandoer) tildeles også en kommandomodifikator — men for makroer spiller kommandomodifikatoren en litt annen rolle enn den gjør for primitiver (for makroer indikerer kommandomodifikatoren hvor makrodefinisjonen er lagret i minnet).
Tatt sammen identifiserer kommandokoden og kommandomodifikatoren hver kommando unikt. Her er kommandokodene og kommandomodifikatorene for kommandoene for makrodefinisjon slik de brukes av Knuths opprinnelige TeX-programvare — merk at andre TeX-motorer kan bruke andre verdier, men de følger nøyaktig samme prinsipp:
| | | |
| ------------ | --------------------------------------------------------- | ---------------------------------------------------------------- |
| **Kommando** | Kommando
kode
| Kommando
modifikator
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Oppsummering: å få mening i alle disse variablene/verdiene
På dette punktet svømmer vi rundt i masse informasjon om verdier, variabler, kommandoverdier og all slags detaljer — det kan fort bli forvirrende, så la oss få oversikt over det vi vet. Når TeX leser noe fra inndataen din, er det enten et tegn eller en kommando. Hver gang TeX leser noe fra inndataen, må det lagre informasjon om det det nettopp har lest (skannet):
* For **tegn**: det må registrere tegnkoden og kategori-koden. Det må også opprette og lagre tokenverdien som TeX beregner ved hjelp av disse verdiene.
* For **kommandoer**: TeX må kjenne den numeriske ekvivalenten, **curcs**, som det beregnet fra kommandonavnet. Det kan også måtte lagre «betydningen» det hentet ved å slå opp kommandoen i TeXs «ordbok»: kommandokoden og kommandomodifikatoren. I tillegg må TeX også beregne en tokenverdi som representerer denne kommandoen.
Ja, det er forvirrende: mange variabler og tokenidéer som flyter rundt, så la oss prøve å få mening i dette.
Internt bruker TeX fire globale variabler til å lagre informasjon om det siste elementet TeX har lest inn (eller for øyeblikket «arbeider med») — vi skal ikke diskutere disse variablene i stor detalj, men det å kjenne til at de finnes, hjelper til å gi litt mer bakgrunn for å forstå hva som egentlig skjer:
* **curcmd**: (gjeldende kommando) en heltallsvariabel. Den brukes til å lagre *gjeldende kommando* verdien for kommandoen som behandles *eller* den lagrer den gjeldende *kategorikode* til tegnet som behandles;
* **curchr**: (gjeldende tegn) en heltallsvariabel, men hva den lagrer avhenger av hva TeX nettopp har lest fra inndataen sin:
* **tegnet**: Hvis det sist innleste elementet er et tegn, **curchr** lagrer den gjeldende *tegnkode*.
* **kommandoen**: Hvis det sist innleste elementet er en kommando, **curchr** lagrer den *kommandomodifikator*: tilleggsinformasjon TeX bruker for å støtte/klargjøre **curcmd**— fordi, som vi så ovenfor, deler noen kommandoer samme verdi av **curcmd**
* **curcs**: (gjeldende kontrollsekvens) en heltallsvariabel som lagrer verdien beregnet fra tegnstrengen i et kommandonavn. **curcs** = 0 hvis det siste elementet som ble lest var et enkelt tegn og ikke navnet på en kontrollsekvens (et kommandonavn);
* **curtok**: (gjeldende token) en heltallsvariabel som holder verdien til gjeldende token — som enten er en kommando-token eller en tegn-token.
Her er informasjonen ovenfor vist som en tabell:
| | | |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Global variabel brukt inne i TeX:** | **Når TeX skanner et tegn:** | **Når TeX skanner en kommando:** |
| **curcmd** | Lagrer kategori-koden til det gjeldende tegnet | Lagrer *kommandokode*— som identifiserer «typen» til den gjeldende kommandoen |
| **curchr** | Lagrer tegnkoden til det gjeldende tegnet | Lagrer tilleggsdata (kalt *kommandomodifikator*) som gir tilleggsinformasjon om den gjeldende kommandoen |
| **curcs** | 0 | Et ikke-null positivt heltall som beregnes (via en hash-funksjon) ved å bruke tegnstrengen som finnes i kommandonavnet. Det brukes til å få tilgang til TeXs «ordbok» for å slå opp den gjeldende betydningen av en kommando — for å hente ut kommandokoden og kommandomodifikatoren. |
| **curtok** | For 8-bits TeX-motorer beregnes en *tegn-token* ved hjelp av formelen: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ der $$\text{curcmd}$$ er tegnets kategori-kode og $$\text{curchr}$$ er tegnkoden | For 8-bits TeX-motorer beregnes en *kommando-token* ved hjelp av formelen: $$\text{curtok}=4095 + \text{curcs}$$ |
### Flere merknader om gjeldende token
For tegn oppnås den maksimale mulige tokenverdien ved å bruke den største kategori-koden (15) og den største tegnkoden som, for 8-bits TeX-motorer, er 255. I teorien (for 8-bits TeX-motorer) er den maksimale tegn-tokenverdien, $$\text{curtok}\_{\text{max}}$$, er:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Vi sier «i teorien» fordi kategori-kode 15 brukes til å representere et «ugyldig tegn» som får TeX til å generere en feil: et ugyldig tegn vil aldri komme seg gjennom TeXs innlesingsprosess og vil derfor aldri bli en tegn-token.
For kommandoer er gjeldende token ($$\text{curtok}$$) beregnet fra $$\text{curtok}=4095 + \text{curcs}$$ men for kommandoer $$\text{curcs}$$ er *alltid* ikke-null, slik at TeX enkelt kan avgjøre hva en token representerer:
* Hvis $$\text{curtok} > 4095$$ da er det en kommando-token;
* Hvis $$\text{curtok} < 4095$$ det er en tegn-token.
I praksis bruker TeX tokens, en enkel heltallsverdi, til å «pakke inn» all informasjonen den trenger å vite om et element som er lest fra inndataen.
## Del 4
I del 4 utforsker vi en rekke eksempelsmakroer for å demonstrere rollen og hensikten med en makros `` seksjon for å fungere som en «tokenmal» som kan konstrueres ved hjelp av avgrensningstokens.
[Del 1](/latex/no/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/no/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/no/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/no/flere-emner/24-how-tex-macros-actually-work-part-6.md)
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://overleaf-pro.ayaka.space/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.