> 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/da/flere-emner/18-how-overleaf-created-the-tex-primitive-reference-data.md).

# Hvordan Overleaf oprettede reference البيانات for TeX-primitiver

Denne artikel beskriver de metoder og teknikker, der blev brugt til at producere de to krydsreference-tabeller over TeX-primitive kommandoer:

* [TeX-primitivekommandoer listet efter TeX-motor](/latex/da/flere-emner/46-tex-primitives-listed-by-tex-engine.md) og;
* [TeX-primitivekommandoer listet efter CJK TeX-motor](/latex/da/flere-emner/45-tex-primitives-listed-by-cjk-tex-engine.md).

Denne information er tiltænkt læsere, der er interesserede i de finere detaljer, men er ikke en forudsætning for at bruge selve krydsreference-tabellen. For at imødekomme forskellige læseres behov giver vi en meget kort opsummeringsversion sammen med en længere forklaring til dem, der ønsker at dykke dybere ned i emnerne.

## Kort opsummerings-/oversigtsversion

For at opbygge krydsreference-tabellen behandlede Overleaf kildekoden til 9 TeX-motorer for at udtrække listen over primitive kommandoer, som hver enkelt understøtter: den proces gav 9 tekstfiler (1 fil pr. TeX-motor). Disse 9 sæt primitive kommandoer blev kombineret for at skabe en “hovedliste”, som i praksis var en union af de enkelte sæt primitive kommandoer: hvilket gav i alt omkring 1000 unikke primitive kommandoer fordelt på de forskellige motorer. For hver motor blev dens egen liste over primitive kommandoer sammenlignet med hovedfilen (sættet af alle kommandoer) for at afgøre, hvilke af disse \~1000 kommandoer den understøttede: disse sammenligninger er tabelleret i de følgende to tabeller:

* [Krydsreference-data for TeX-primitive kommandoer](/latex/da/flere-emner/46-tex-primitives-listed-by-tex-engine.md)
* [Krydsreference-data for TeX-primitive kommandoer (for CJK-motorer)](/latex/da/flere-emner/45-tex-primitives-listed-by-cjk-tex-engine.md)

## “At bygge software” 101: Hvad betyder det?

Gennem resten af denne artikel henviser vi til begrebet “at bygge TeX-motorer”, hvilket kan være et ukendt koncept, hvis du ikke er programmør eller ikke programmerer i kompilerede sprog som C eller C++. I vores sammenhæng er det at bygge software—dvs. TeX-motorer—processen med at skabe et eksekverbart TeX-program ud fra dets bestanddele—kildekodefilerne skrevet i det programmeringssprog, der bruges til at udvikle programmet.

## Fuld version: Vil du have detaljerne? Læs videre...

Hver TeX-baseret satsningsmotor understøtter en “dialekt” af TeX-sproget: et bestemt sæt primitive kommandoer, som styrer hver motors satsningsfunktioner og udgør byggestenene til at skabe/definere makroer: brugerdefinerede sekvenser af kommandoer. Hver makro, uanset om den er skrevet til LaTeX, plain TeX eller et andet makropakke, er i sidste ende konstrueret af primitive kommandoer—selv om du måske skal grave ganske langt ned gennem lag af yderligere makroer, før du når ned til TeX-primitivekommandoernes “grundfjeldslag”. Det sæt af 9 TeX-motorer, der blev analyseret for at producere reference-dataene for primitive kommandoer, har naturligvis mange kommandoer til fælles, men hver TeX-motor har også sine egne primitive kommandoer, tilføjet af deres udviklere, for at understøtte de funktioner, der er specifikke for den pågældende “version” af TeX.

En TeX-motors primitive kommandoer er indbygget i den eksekverbare TeX-software: primitive kommandoer er ikke makroer konstrueret af brugere, de er fundamentale, udelelige/atomare instruktioner, der bruges til at styre hver motors satsningsadfærd. Derfor er den mest pålidelige måde at skabe en definitiv liste over primitive kommandoer, som enhver TeX-motor understøtter, at undersøge den faktiske kildekode, hvorfra de eksekverbare TeX-programmer bygges (kompileres), og udtrække listen over primitive kommandoer, der er defineret i kildekoden. Det lyder, som om det burde være let, ikke? Men på grund af TeX’s 40 år lange udviklingshistorie er det ikke særlig ligetil at udforske/undersøge kildekodefilerne for TeX-motorer (undtagen LuaTeX). Årsagen til disse kompleksiteter ligger i de værktøjer, det programmeringssprog (Pascal) og den metode (litterær programmering), som Knuth brugte til at skrive den oprindelige TeX-kildekode—hvorfra alle andre motorer i sidste ende nedstammer.

Vi bemærker en undtagelse for LuaTeX, fordi dens kernekode til motoren blev omskrevet i C for at fjerne brugen af Pascal og andre ældre kompleksiteter beskrevet nedenfor (Web2C); derfor er LuaTeX’s kildekode, selv om den er omfattende, langt mere forståelig i den måde, den er “pakket” og distribueret på, sammenlignet med andre TeX-motorer. Derfor, og baseret på de arbejdsgange/processer, der bruges til at bygge dem fra kildekode, er det praktisk at gruppere TeX-motorer i to kategorier:

1. LuaTeX: brugerdefineret (mere moderne) byggeproces
2. Alle andre motorer: ældre (Web2C) byggeproces

## Konteksten for ældre kode: Hvorfor det er komplekst at bygge (de fleste) TeX-motorer

Som vi vil udforske nedenfor, udgav Knuth sin oprindelige TeX-kildekode som en enkelt, monolitisk fil kaldet `tex.web` som Knuth fortsætter med at opdatere én gang hvert 7. år for at rette eventuelle tilbageværende fejl—der tilføjes aldrig nye funktioner, det er udelukkende en fejlrettelsesøvelse.

TeX’s filendelse for kildekode (`.web`) er næppe velkendt, og du undrer dig måske over, hvilket sprog Knuth brugte til at skrive TeX? Svaret er Pascal, men `.web` endelsen kræver lidt mere forklaring. Knuth udviklede en programmeringsmetode, som han kaldte [litterær programmering](https://en.wikipedia.org/wiki/Literate_programming) hvor et programs kildekode og dokumentation kombineres og udgives som en enkelt sammensat fil (kode plus dokumentation) med endelsen `.web`: denne filtype kaldes en WEB-fil. Vi forklarer WEB-filer lidt mere detaljeret nedenfor.

### At skabe nye TeX-motorer: Knuths forbehold

Selv om Knuth for længe siden har gjort sin TeX-kildekode (`tex.web`) frit tilgængelig for alle, stillede han som sin absolutte ret en vigtig betingelse: at hans (`tex.web`) kildekode ikke måtte redigeres/modificeres direkte og distribueres igen med programnavnet “TeX”. I kildekoden skriver han:

```
% Dette program er ophavsretligt beskyttet (C) 1982 af D. E. Knuth; alle rettigheder forbeholdes.
% Kopiering af denne fil er kun tilladt, hvis (1) du er D. E. Knuth, eller hvis
% (2) du absolut ikke foretager nogen ændringer i din kopi. (WEB-systemet giver
% mulighed for ændringer via en hjælpefil; hovedfilen bør forblive intakt.)
```

og også:

```
Hvis dette program ændres, bør det resulterende system ikke kaldes
`\TeX'; det officielle navn `\TeX' alene er forbeholdt
for softwaresystemer, der er fuldt kompatible med hinanden.
En særlig testpakke kaldet ``\.{TRIP} test'' er tilgængelig for
at hjælpe med at afgøre, om en bestemt implementering fortjener at blive
kendt som `\TeX' [jf.~Stanford Computer Science report CS1027,
November 1984].
```

I bund og grund: foretag ikke ændringer ved at redigere og distribuere modificerede versioner af den originale TeX-kildekode og fortsæt med at kalde den `tex.web`. Hvis du ønsker at foretage ændringer, f.eks. tilføje nye primitive kommandoer osv., skal du anvende disse ændringer ved at lave “ændringer via en hjælpefil” og give dit “afledte TeX”-program et navn, der skelner det fra “TeX”, som i sat form ($$\mathrm\TeX$$), er et varemærke tilhørende American Mathematical Society.

### Arven fra det gamle

Selv om der har været forsøg på helt at omskrive TeX ved hjælp af moderne programmeringssprog og metoder—såsom de to Java-baserede initiativer [New Typesetting System](https://en.wikipedia.org/wiki/New_Typesetting_System) og [εχTEX](http://www.extex.org/) og andre såsom [et i Clojure](https://www.infoq.com/news/2015/01/implementing-tex-in-clojure), har ingen været fuldstændigt succesfulde. Historien om projekter og initiativer, der er designet til at videreudvikle TeX, er et interessant emne, og læsere kan måske ønske at [besøge UK TeX FAQ](https://texfaq.org/FAQ-enginedev) for yderligere information.

De ikke-LuaTeX-initiativer, som også har været succesfulde, såsom e-TeX, pdfTeX, XeTeX og andre motorer, er bygget *direkte oven på* Knuths oprindelige kode: de tager hans kildekode og “anvender ændringer” for at aflede en ny motor med yderligere egenskaber—såsom at tilføje nye primitive kommandoer, producere PDF-output, understøtte UTF-8-tekstinput og så videre. Selvom den vej har ført til bemærkelsesværdige succeser, betyder det også, at disse afledte motorer arver den ældre kode og de udviklingsteknikker, som Knuth skabte for 40 år siden.

Det vigtigste her er, at bortset fra LuaTeX oprettes de fleste TeX-motorer, der er afledt af Knuths oprindelige kildekode, ved at tage en enkelt monolitisk fil (typisk `tex.web`) og anvende ændringer, som genererer endnu en enkelt monolitisk fil, der indeholder den nye motors kernekildekode. Erfarne læsere vil måske springe frem til de kvalificerende [noter om pdfTeX og XeTeX](#aside-xetex-and-pdftex).

### Lidt ekstra TeX-historie/baggrund

TeX’s øjeblik af tilblivelse blev [registreret i Knuths dagbog som 30. marts 1977](/latex/da/dybtgaende-artikler/55-what-s-in-a-name-a-guide-to-the-many-flavours-of-tex.md#the-genesis-of-tex-a-brief-history), nu for over 40 år siden. Internt er TeX et ekstraordinært komplekst program, hvis kildekode Knuth gjorde sig stor umage for at [dokumentere i enestående detaljer](https://www.amazon.co.uk/Computers-Typesetting-TeX-Program-TEX/dp/0201134373). Til det udviklede Knuth en programmeringsstil, som han kaldte [litterær programmering](https://en.wikipedia.org/wiki/Literate_programming) hvor et programs kildekode og dokumentation kombineres og udgives som en sammensat fil med endelsen `.web` (kaldet en WEB-fil). Knuth valgte Pascal som programmeringssprog til at skrive sin TeX-software og brugte, ikke overraskende, TeX-satsningssproget til at skrive den endelige dokumentation. Følgelig udgives hovedkildekoden til Knuths TeX som en enkelt, monolitisk fil kaldet `tex.web`: en blanding af Pascal-kildekode og TeX-satsningskode til dokumentationen.

Hvis et program er skrevet ved hjælp af Knuths stil/metode for litterær programmering (som TeX, MetaFont, BibTeX og andre er), skal du forbehandle WEB-filen for at udtrække dokumentationen eller kildekoden. For at få adgang til programmets dokumentation behandler du WEB-filen (f.eks. `tex.web`) med et hjælpeprogram kaldet [WEAVE](http://tug.org/texinfohtml/web2c.html#weave-invocation) som producerer dokumentationen som en `.tex` fil, som du kan sætte op. For at udtrække kildekoden i Pascal bruger du et andet hjælpeprogram kaldet [TANGLE](http://tug.org/texinfohtml/web2c.html#tangle-invocation) som udsender en fil med endelsen `.p` der indeholder Pascal-kildekode.

På skrivende tidspunkt (begyndelsen af 2019) er den nyeste version af Knuths TeX 3.14159265, dateret januar 2014. Bemærk igen, at Knuths TeX-kildekode kun er indeholdt i en enkelt fil med omkring 25.000 linjer TeX/Pascal-kode!

### Fra Pascal til C

I de 40+ år, der er gået siden TeX’s tilblivelse, faldt Pascal ud af mode, og i dag overvejer få, hvis nogen?, at bygge TeX ud fra den oprindelige Pascal-kildekode. For at omgå Knuths brug af Pascal blev der designet en arbejdsgang kaldet [Web2C](http://tug.org/texinfohtml/web2c.html) cirka 1987), hvor TeX’s Pascal-kildekode mekanisk (dvs. via software) konverteres til sin ækvivalent i C-kode, som derefter bruges til at kompilere TeX og bygge det eksekverbare program. Det fungerer godt, men den eneste ulempe er, at den mekanisk genererede C-kildekode ikke er beregnet til afslappet menneskelig gennemlæsning: den er *ekstremt* ordrig og næsten uigennemtrængelig, og er bestemt for kompilatorer, ikke mennesker—her er et skærmbillede, der viser et lille fragment af C-koden genereret fra TeX’s Pascal-kilde:

![](/files/023888951b7045532474bceb78deee0ecfb3576c)

### Endnu en Knuthisme: WEB-ændringsfiler

Som nævnt ovenfor er det at bygge videre på Knuths oprindelige kildekode at “anvende ændringer” eller, med Knuths ord, lave “ændringer via en hjælpefil”: men hvad betyder det egentlig? Her kommer *mekanismen med ændringsfiler*.

### Ændringsfiler: mekanismen til at skabe nye TeX-motorer

Udviklere, der ønsker at udvide Knuths TeX på en eller anden måde, dvs. bygge videre på Knuths oprindelige arbejde, ønsker typisk at skabe en helt ny “version” af TeX eller levere en *udvidelse* der kan føjes til enhver TeX-motor. Eksempler på udvidelser omfatter [SyncTeX](https://github.com/jlaurens/synctex) og [EncTeX](https://ctan.org/pkg/enctex?lang=en)—SyncTeX er for eksempel en meget nyttig udvidelse, som nu er inkluderet i alle TeX-motorer. Behovet for EncTeX er i høj grad blevet overhalet af udviklingen af Unicode-bevidste TeX-motorer—men bemærk, at EncTeX er indbygget i pdfTeX.

Uanset om ønsket er at producere en ny “version” af TeX (dvs. en afledning af Knuths oprindelige TeX) eller at skabe en udvidelse, starter udviklerne med Knuths oprindelige kildekode og anvender de nødvendige ændringer for at skabe en ny TeX-motor (eller en tilføjelsesudvidelse). Men som nævnt ovenfor skal enhver, der ønsker at ændre TeX’s adfærd, gøre det ved hjælp af “ændringer via en hjælpefil”, fordi disse ændringer/modifikationer ikke må udføres ved at *direkte* redigere Knuths oprindelige kildekode: udviklere er nødt til at bruge det såkaldte WEB *mekanismen med ændringsfiler*. Koden til at ændre Knuths TeX skrives i WEB-“sproget” og gemmes i en eller flere kodefiler (kaldet *ændringsfiler*) som derefter *sammenflettet* med Knuths oprindelige, urørte, hovedkildekode. Denne sammenfletningsproces skaber en ny sammensat WEB-fil, som nu indeholder den *kerne* kildekode til den nye/modificerede TeX-baserede software. *Ændringsfiler* har ofte endelsen `.ch` men i praksis kan de have enhver endelse, som udviklerne ønsker.

#### Hvordan bruger/anvender man ændringsfiler?

I dag er den nemmeste måde at anvende ændringsfiler og modificere en “hoved”-WEB-fil på med et hjælpeprogram kaldet [TIE](https://ctan.org/pkg/tie). Forestil dig for eksempel, at du ville ændre Knuths TeX ved at tilføje, lad os sige, et par nye primitive kommandoer, eller at du ville ændre adfærden af en eksisterende (standard) TeX-primitive kommando. Du ville skrive din kode (i Pascal!) ved hjælp af WEB-systemet til litterær programmering og gemme den i en fil kaldet, lad os sige, `myprim.ch`. Næste trin er at flette din kode (i `myprim.ch`) sammen med Knuths hovedkildefil `tex.web` og producere en ny, sammensat WEB-fil, der repræsenterer det, vi vil kalde `mytex.web`. For at gøre dette skal du blot køre TIE-programmet sådan her:

```
tie -m mytex.web tex.web myprim.ch
```

Hvis sammenfletningen lykkes, vil dette resultere i en ny WEB-fil, `mytex.web`og Knuths hovedkildefil efterlades `tex.web` helt uændret, som krævet.

Lad os nu antage, at en anden kan lide de ændringer, du har lavet, og ønsker at ændre dit arbejde for at tilføje sine ændringer oven på, eller ud over, det du har gjort. I stedet for at distribuere din modificerede version af TeX (`mytex.web`) beslutter du kun at udgive/dele ændringsfilen, `myprim.ch`. Enhver, der ønsker at bygge videre på dit arbejde, kan nu oprette og dele sin ændringsfil kaldet, lad os sige, `moreprim.ch` som på en eller anden måde udvider din kode. Enhver anden, der ønsker at drage fordel af begge ændringsfiler, kan nu generere en ny sammensat WEB-fil ved at flette *begge* ændringsfiler ind i Knuths oprindelige for at generere endnu et TeX-program kaldet, lad os sige, `newmytex.web`:

```
tie -m newmytex.web tex.web myprim.ch moreprim.ch
```

### Virkelige TeX-systemer: flere ændringsfiler

Ovenstående beskrivelse af TIE ligger faktisk meget tæt på den måde, hvorpå mange TeX-motorer bygges i praksis: de starter med Knuths `tex.web` og tilføjer en række ændringsfiler for at generere WEB-kildefilen til den pågældende motor. Hver TeX-motor kræver sit eget særlige sæt ændringsfiler, som skal anvendes/behandles (sammenflettes) i en streng rækkefølge: får man rækkefølgen forkert, vil sammenfletningsprocessen mislykkes, fordi hver ændringsfil i en sekvens er afhængig af ændringer, der er indført af ændringsfiler tidligere i kæden.

Her er en prøvekørsel af TIE, der anvender flere ændringsfiler på Knuths `tex.web` for at generere `ktex.web`—den sammensatte WEB-fil med ændringer til Knuths TeX, som gør den klar (egnet) til konvertering til C via Web2C-processen. Bemærk også følgende:

* `tex.ch` er en meget stor ændringsfil, som blandt meget andet ændrer TeX til at bruge Kpathsea;
* SyncTeX-udvidelsen tilføjes via flere ændringsfiler.

```
tie -m ktex.web tex.web tex.ch enctex.ch synctex-def.ch0 synctex-mem.ch0 synctex-mem.ch2 synctex-rec.ch0 synctex-rec.ch1 synctex-rec.ch2 tex-binpool.ch
Dette er TIE, CWEB-version 2.4.
Copyright (c) 1989,1992 af THD/ITI. Alle rettigheder forbeholdes.
(tex.web)
(tex.ch)
(enctex.ch)
(synctex-def.ch0)
(synctex-mem.ch0)
(synctex-mem.ch2)
(synctex-rec.ch0)
(synctex-rec.ch1)
(synctex-rec.ch2)
(tex-binpool.ch)
....500....1000....1500....2000....2500....3000....3500....4000....4500
....5000....5500....6000....6500....7000....7500....8000....8500....9000
....9500....10000....10500....11000....11500....12000....12500....13000
....13500....14000....14500....15000....15500....16000....16500....17000
....17500....18000....18500....19000....19500....20000....20500....21000
....21500....22000....22500....23000....23500....24000....24500....
(Der blev ikke fundet nogen fejl.)
```

#### Bemærkning: XeTeX og pdfTeX

For fuldstændighedens skyld bør vi bemærke, at byggeprocessen for pdfTeX og XeTeX faktisk ikke starter med Knuths `tex.web`; i stedet starter de med filer kaldet `pdftex.web` og `xetex.web` henholdsvis: formodentlig fordi ændringerne er så omfattende, at det giver mere mening at dele/udgive WEB-filer, som allerede indeholder de meget betydelige ændringer, der er foretaget i Knuths oprindelige kode.

### Et eksempel: e-upTeX

Det japanske TeX-fællesskab har udviklet en række TeX-motorer, der er designet til at håndtere kompleksiteten ved satsning af japansk tekst:

* **pTeX**: Knuths TeX-motor udvidet til at understøtte japansk satsning;
* **e-pTeX**: En kombination af e-TeX og pTeX (plus et par primitive kommandoer introduceret af pdfTeX);
* **upTeX**: En Unicode-bevidst version af pTeX plus udvidelser til bedre håndtering af CJK (kinesisk, japansk og koreansk);
* **e-upTeX**: En kombination (sammenfletning) af e-TeX og upTeX.

#### Generering af den sammensatte kildefil for e-upTeX

For at skabe den sammensatte WEB-kildefil for e-upTeX (med SyncTeX) starter du med Knuths `tex.web` men skal anvende **26** enkeltstående ændringsfiler i følgende rækkefølge for at frembringe en enkelt sammensat fil, hvorfra listen over primitive kommandoer kan udtrækkes:

```
etex.ch, tex.ch0, tex.ch, tex.ech, etex.ch0,
ptex-base.ch, uptex-m.ch, euptex.ch0, eptex.ech,
etex.ch1, euptex.ch1, synctex-def.ch0, synctex-ep-mem.ch0,
synctex-mem.ch0, synctex-e-mem.ch0, synctex-ep-mem.ch1,
synctex-p-rec.ch0, synctex-rec.ch0, synctex-rec.ch1,
synctex-e-rec.ch0, synctex-p-rec.ch1, fam256.ch,
pdfstrcmp-eup-pre.ch, pdfutils.ch, pdfstrcmp-eup-post.ch,
tex-binpool.ch
```

#### Anvendelse af ændringsfiler: hvilke filer og i hvilken rækkefølge?

Som nævnt er det kritisk vigtigt at anvende/behandle ændringsfiler i en streng rækkefølge—men hvordan finder man ud af, hvilke filer der er nødvendige, og i hvilken rækkefølge de skal behandles? Heldigvis er disse afgørende oplysninger registreret i filer, der findes i TeX Live-distributionen, og en gennemgang af TeX Live-kildekoden afslørede de regler, som styrer byggekravene for hver TeX-motor. Ved at følge disse regler kunne Overleaf rekonstruere den sammensatte WEB-kildefil for hver TeX-motor og udtrække en liste over primitive kommandoer til videre databehandling.

## Og til sidst: Hvordan udtrækker man listen over primitive kommandoer?

Når den sammensatte WEB-fil er blevet konstrueret, er opgaven med at udtrække listen over primitive kommandoer ved hjælp af regulære udtryk ligetil, fordi alle primitive kommandoer defineres (“registreres”) ved hjælp af en enkelt Pascal-funktion kaldet `primitive(...)`. Her er nogle virkelige eksempler taget fra Knuths `tex.web` kildekode:

```
primitive("lineskip",assign_glue,glue_base+line_skip_code)
primitive("baselineskip",assign_glue,glue_base+baseline_skip_code)
primitive("parskip",assign_glue,glue_base+par_skip_code)
primitive("abovedisplayskip",assign_glue,glue_base+above_display_skip_code)
primitive("belowdisplayskip",assign_glue,glue_base+below_display_skip_code)
primitive("abovedisplayshortskip",assign_glue,glue_base+above_display_short_skip_code)
...
...
```

Som du kan se, er `primitive(...)` funktionen meget velegnet til tekstbehandling med regulære udtryk: navnet på den primitive kommando, der registreres, står i anførselstegn (`"..."`) sammen med yderligere data, der klassificerer adfærden for hver primitive kommando (det går vi ikke i detaljer med her). Efter udtrækningen af listen over primitive kommandoer for hver motor blev disse data behandlet af nogle Lua-scripts for at generere HTML med de tabellerede resultater.

### Tilbage til LuaTeX

Vi har bemærket, at LuaTeX ikke bruger helt de samme byggeprocesser som de andre 8 TeX-motorer. Efter kort at have udforsket Web2C-processen, konverteringen fra Pascal til C og mekanismen med ændringsfiler, kan vi nu forklare, hvor LuaTeX adskiller sig: udviklerne af LuaTeX besluttede at opgive den besværlige proces med at konvertere Pascal til C—som nævnt i [LuaTeX Reference Manual](http://www.pragma-ade.com/general/manuals/luatex):

> ...kompileringsrammen er web2c, og vi fortsætter med at bruge den, men uden Pascal-til-C-trinnet.

LuaTeX-kerne-motoren blev omskrevet i C, hvilket betyder, at dens byggeproces er noget mere standardiseret og bestemt langt mere bekvem. En nyttig konsekvens er, at de primitive kommandoer, som LuaTeX understøtter, er pænt udskilt i en separat C-kildekodefil, hvilket i høj grad lettede opgaven med at få adgang til/opremse dem.

Strengt taget bør vi også bemærke, at nogle af LuaTeX’s kildekodefiler bruger en variant af Knuths metode til litterær programmering, kaldet [CWEB](https://en.wikipedia.org/wiki/CWEB), som er baseret på C og ikke Pascal.

### Ikke kun WEB-filer: anden kildekode er påkrævet

Efter at have genereret den sammensatte WEB-kildefil for enhver TeX-motor (undtagen LuaTeX) skal Pascal-kildekoden udtrækkes og konverteres til C-kode, men det er ikke hele løsningen. Ud over den C-kode, der genereres fra WEB-kilden (Pascal⮕C), er de fleste TeX-motorer også afhængige af (kræver) en række yderligere tilhørende kildekodefiler (biblioteker), som typisk er skrevet i C—såsom [Kpathsea](https://www.tug.org/kpathsea/). Tilhørende kildefiler (biblioteker) implementerer funktionalitet, som ikke behøver, eller ikke kan, skrives i WEB (Pascal). Alt, der skrives i WEB-“sproget” til TeX, må bruge Pascal-sproget, som derefter udtrækkes og konverteres til maskin-genereret C: hvis du ikke har brug for at gøre det, hvorfor så ikke bare skrive det i C eller C++ fra starten.


---

# 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/da/flere-emner/18-how-overleaf-created-the-tex-primitive-reference-data.md?ask=<question>&goal=<endgoal>
```

`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.
