> 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/sv/fordjupade-artiklar/53-what-is-a-tex-token.md).
# Vad är ett "TeX-token"?
## Motivering för en serie om TeX-token och besläktade begrepp
Motivationen och den metodik som används för att ta fram en serie artiklar om TeX-token och besläktade begrepp diskuteras i denna artikel [En ny artikelserie: TeX-tokens och relaterade begrepp—men varför (och hur)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Som nämndes i den artikeln baserar vi genom hela serien våra diskussioner och förklaringar på insikter som erhållits genom en egenbyggd version av Knuths ursprungliga TeX-program—och använder det för att ta fram en serie artiklar som syftar till att ge enkla beskrivningar och lättföljda förklaringar av centrala TeX-begrepp.
## Inledning: vad är vårt mål?
I den här artikeln tar vi reda på exakt vad en TeX-token är genom att följa bearbetningsresan från tecken i indatafilen till den faktiska skapelsen av TeX-token. I praktiken är det ganska komplext, så vi har reducerat processen till dess kärninslag och strävar efter att göra den lätt att följa och förstå samtidigt som den tekniska korrektheten bevaras.
Vi börjar med att introducera några viktiga interna TeX-begrepp: *primitiver*, *kommandokoder* och *kommandomodifierare*. Därifrån använder vi ett mycket enkelt makroexempel för att se exakt hur TeX bearbetar kommandot `\def` och den token som TeX skapar för att representera det kommandot.
Vi avslutar med en kort titt på hur TeX skapar token som representerar tecken och hur ett teckens `\\catcode` faktiskt blir permanent fäst vid en tecken-token—något som ofta nämns i böcker om TeX men här ser vi exakt hur det uppnås.
Följande grafik visar resan vi kommer att sammanfatta—från indatatext till TeX-token:
## Men först: primitiv och kommandokoder
Varje TeX-motor (Knuths TeX, pdfTeX, XeTeX, LuaTeX) förstår ett antal inbyggda kommandon: de så kallade *primitiver*—de grundläggande byggstenarna som ligger till grund för TeX:s programmerbarhet. De kallas “primitiv” eftersom de, till skillnad från användardefinierade makron, inte är uppbyggda av andra kommandon och inte kan brytas ned ytterligare till enklare instruktioner. För Knuths TeX finns det ungefär 320 primitiv—även om vi bör notera att andra TeX-motorer som pdfTeX, XeTeX och LuaTeX alla har lagt till nya kommandon i Knuths ursprungliga program och därför innehåller primitiv som inte finns i Knuths TeX-programvara.
Internt tilldelar TeX ett numeriskt *kommandokod* till alla kommandon—oavsett om de är användardefinierade makron eller inbyggda primitiv. Dessa kommandokoder är inte åtkomliga för TeX-användaren, de är helt enkelt en del av TeX:s interna bearbetningsmekanik men det är nyttigt att känna till dem inför den senare diskussionen om TeX-token.
Grupper av kommandon som har närbesläktad funktionalitet delar samma kommandokod. Till exempel använder de `\def`, `\gdef`, `\edef` och `\xdef` primitiv alla för att definiera makron och delar kommandokoden 97 (i Knuths TeX). Tydligt nog skapar dessa fyra makrodefinitionskommandon vardera makron på lite olika sätt; därför behöver TeX under bearbetningen ett sätt att skilja dem åt.
En kommandokod i sig (såsom 97) kan inte tala om vilket makroskapande kommando som avses; så, som du kanske förväntar dig, tilldelas varje TeX-kommando en extra informationsbit som kallas dess *kommandomodifierare* (se exemplen nedan).
### Kommandomodifierare: två typer
Kommandomodifierare faller i två kategorier som vi här kallar “Typ 1” och “Typ 2”—TeX använder inte denna terminologi, det är bara praktiskt att göra så här:
* **Typ 1**: Enkla heltalsvärden som TeX, om det behövs, kan använda för att skilja mellan kommandon som delar samma kommandokod.
* **Typ 2**: Ett heltalsvärde som är en numerisk plats i TeX:s minne och talar om för TeX var det behöver gå för att slå upp information om det kommandot. Till exempel gäller detta för användardefinierade kommandon (makron) där kommandomodifieraren talar om för TeX var makrodefinitionen lagras i minnet.
#### Typ 1-kommandomodifierare (ett exempel)
Som nämnts, i Knuths TeX delar de fyra primitiva kommandona för att definiera makron: `\def`, `\gdef`, `\edef`, `\xdef` alla kommandokoden 97: de särskiljs genom sina kommandomodifierare, som listas i följande tabell:
| kommando | Kommando
kod
| Kommando
modifierare
|
| -------- | ---------------------- | ------------------------------ |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Som ett andra exempel valde Knuth att implementera kommandona `\openout`, `\\write`, `\closeout`, `\special`, `\immediate` och `\setlanguage` som “utvidgningar” till TeX, enbart för att visa hur man kan lägga till nya primitiv i TeX. I detta fall delar dessa kommandon egentligen inte “liknande funktionalitet” mer än att Knuth valde att gruppera dem tillsammans för att förklara hur man utvidgar TeX. Dessa 6 kommandon klassificeras som “utvidgningar” och grupperas tillsammans med kommandokodvärdet 59, men var och en har en lämplig kommandomodifierare för att skilja den från de andra:
| kommando | Kommando
kod
| Kommando
modifierare
|
| -------------- | ---------------------- | ------------------------------ |
| `\openout` | 59 | 0 |
| `\\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Typ 2-kommandomodifierare (en kort förklaring)
Även om alla kommandomodifierare är heltal, behöver Typ 2-modifierare lite mer förklaring. Dessa kommandomodifierare kallas i TeX för “pekare” eftersom de pekar på en plats i minnet där TeX kan hitta ytterligare information för det kommandot. Det kan låta lite vagt men hur TeX använder dessa pekare för att slå upp information är ganska varierat och en fylligare förklaring skulle avleda från artikelns kärnmål. Ett exempel kan hjälpa: makron. När ett makrokommando definieras måste TeX lagra ersättningstexten någonstans i minnet. Som vi kommer att se nedan har användardefinierade makron kommandokoder mellan 111 och 114 med en kommandomodifierare som är en pekare in i minnet och talar om för TeX var dess ersättningstext (makrodefinitionen) lagras.
### Kommandokoder: expanderbara och icke-expanderbara
I Knuths källkod till TeX varierar kommandokoderna från 0 till 120—notera att vissa koder inom det intervallet enbart är avsedda för specialiserad intern användning och inte tilldelas kommandon som är åtkomliga för användaren. Det är värt att notera att andra TeX-motorer som pdfTeX, XeTeX och LuaTeX alla har lagt till nya kommandon till Knuths ursprungliga uppsättning och därför innehåller fler primitiv och motsvarande kommandokoder; principerna som beskrivs här är dock centrala för alla TeX-baserade motorer som härstammar från Knuths källkod.
Samlingen av kommandokoder delas in i två huvuduppsättningar:
* *icke-expanderbara kommandon*: har kommandokoder mindre än eller lika med 100;
* *expanderbara kommandon*: har kommandokoder större än 100, upp till ett maxvärde på 120. Intervallet 101 till 120 inkluderar användardefinierade makron samt kommandon som `\csname`, `\expandafter` och `\the`.
Icke-expanderbara kommandon utför vanligtvis tilldelning av ett värde till en intern parameter eller producerar direkt material som kan sättas. Expanderbara kommandon “injicerar” vanligtvis en ström av token i TeX:s aktuella bearbetningsaktivitet eller ändrar ordningen för tokenbearbetningen.
Som nämnts ovan får alla makron (användardefinierade kommandon) kommandokoder mellan 111 och 114: de olika värdena återspeglar om makrot definierades som `\long`, `\outer`, båda eller ingetdera. Här är ett exempel:
| Makrotyp | Exempel | Kommentar |
| --------------------- | ------------------------------ | ------------------------- |
| Icke-lång, icke-ytter | `\def\ohyeah{....}` | `\ohyeah` kommandokod=111 |
| Lång, icke-ytter | `\long\def\ohyeah{....}` | `\ohyeah` kommandokod=112 |
| Icke-lång, ytter | `\outer\def\ohyeah{....}` | `\ohyeah` kommandokod=113 |
| Lång ytter | `\long\outer\def\ohyeah{....}` | `\ohyeah` kommandokod=114 |
Som en påminnelse om kommandomodifierare: när ett makro definieras lagrar TeX makrodefinitionen på någon plats i minnet: den platsen (en pekare) blir kommandomodifieraren för makrokommandot, som kommer att lagras med en kommandokod från 111 till 114 beroende på hur det definierades. Det faktiska namn som tilldelas ett användardefinierat makro spelar egentligen ingen roll: efter bearbetningen av indata får de alla en kommandokod som varierar från 111–114 och, i slutänden, omvandlas alla kommandon som TeX läser från din indata, oavsett om de är primitiv eller användardefinierade makron, till slut till en numerisk representation som kallas en *token*.
## Resan från indatatext till TeX-token
I detta avsnitt använder vi ett mycket enkelt makroexempel för att se exakt hur TeX bearbetar kommandot `\def` för att skapa en token som representerar `\def` kommandot. TeX:s detaljerade bearbetningsaktivitet kan vara extremt komplex, så vi använder inte makroparametrar eller avgränsare eftersom det skulle öka komplexiteten och avleda från vår resa.
Anta att din TeX-indatafil innehåller följande rad:
```latex
\def\ohyeah{Overleaf är coolt!}
```
När TeX börjar bearbeta denna indatarad kontrollerar den `\\catcode` för varje tecken och ser att det första tecknet är `\` (första tecknet i `\def`). Den upptäcker (slår upp det i en intern tabell) att `\` har `\\catcode` 0 vilket betyder att det introducerar början på en *kontrollsekvens*. Naturligtvis kan du definiera om vilket tecken som helst så att det har `\\catcode` 0, men vi antar att de konventionella definitionerna i plain TeX eller LaTeX används.
Strängt taget har termen *kontrollsekvens* två underkategorier: *kontrollord* och *kontrollsymbol*:
* *kontrollord*: en sekvens av tecken med `\\catcode` bokstav (11);
* *kontrollsymbol*: ett enskilt tecken vars `\\catcode` är *inte* bokstav (11).
Vid denna punkt har `\` tecknet gjort sitt jobb och är nu färdigt. När TeX upptäcker ett escape-tecken är dess respons att börja läsa alla efterföljande tecken i indatat med sikte på att upptäcka ett kontrollord eller en kontrollsymbol.
Efter det inledande `\`, upptäcker TeX omedelbart `d`: ett tecken vars `\\catcode` är 11 vilket talar om för TeX att det har hittat första bokstaven i ett *kontrollord*. Det fortsätter att skanna efterföljande tecken tills det till slut upptäcker ett tecken som *gör inte* har `\\catcode` bokstav (11). Alla efterföljande tecken (efter det inledande `\`) med `\\catcode` 11 (bokstav) anses bilda namnet på ett kontrollord: dvs. namnet på ett kommando—kanske ett makro eller ett primitiv, men TeX har ännu ingen aning om vilken typ av kommando det är. Vid denna punkt är det helt enkelt en teckensträng.
Så i vårt exempel skannar TeX glatt vidare och kontrollerar varje tecken tills det når det inledande `\` för `\ohyeah` som också har `\\catcode` 0. TeX inser att den har skannat för långt och returnerar artigt det `\` tillbaka till textströmmen så att det blir nästa tecken som ses vid fortsatt skanning av texten. Vid denna punkt har TeX identifierat en sträng (`def`) som den vet utgör texten i ett kontrollord bestående av tre tecken, var och en med `\\catcode` 11 (`d`, `e` och `f`). Vad TeX nu behöver göra är att ta reda på vad `def` betyder: vad gör det? Som du kanske har gissat behöver TeX hitta kommandokoden och kommandoidentifieraren för `def` så att det kan lista ut vad det ska göra med detta kommando.
## Att göra en hash av det
Efter att ha upptäckt ett kontrollord (`def`), är det första TeX gör att “omvandla” teckensträngen (`def` i vårt exempel) till ett heltal genom att använda något som kallas en hashfunktion. Vi behöver inte bry oss alltför mycket om detaljerna, en översikt räcker. I huvudsak tittar TeX på varje tecken i kontrollordet som det just har upptäckt och använder ASCII-kodvärdet (eller Unicode-värdet för XeTeX/LuaTeX) för varje tecken för att beräkna ett tal som kallas ett hashvärde: det är helt enkelt ett vanligt heltal.
Som en del av denna hashberäkningsprocess kontrollerar TeX också om teckensträngen i det nyupptäckta kontrollordet redan är känd för det. Den text som kan läsas av människor för alla kommandon, oavsett om de är primitiv eller användardefinierade makron, lagras i ett internt lagringsområde som kallas *strängpoolen*. TeX måste göra detta eftersom det kan behöva mata ut det läsbara namnet på ett kommando—till exempel när TeX behöver rapportera ett fel och ange namnet på det felande kommandot. Till exempel definierar vårt makro `\def\ohyeah{Overleaf är coolt!}` ett nytt kommando som kallas `\ohyeah` och TeX kommer (i ett senare skede) inte bara att behöva beräkna ett hashvärde för `ohyeah` (*utan* det inledande `\` tecknet) utan också lagra den textsträngsbaserade (läsbara) formen ifall den behöver använda den för felrapportering (eller andra uppgifter).
Om du vill ha fler detaljer om TeX:s processer för stränghantering har jag skrivit om detta på min [personliga blogg](http://www.readytext.co.uk/?p=3590).
Slutresultatet är att teckensträngen som representerar kommandot `def` omvandlas till det numeriska värdet 1218 (det är det faktiska värde som TeX beräknar). Vid denna punkt är de enskilda tecknen `d`, `e` och `f` inte längre en del av huvudhistorien—de har lästs in från indatat och har gjort sitt jobb: från och med nu handlar allt om heltal och *tokens*—vi kommer snart att se vad en token faktiskt är! Internt hänvisar TeX till dessa hashvärdesnummer som den *aktuella kontrollsekvensen* men i källkoden förkortas den termen till en variabel som kallas `curcs`. TeX:s källkod är full av mycket korta, ofta ganska kryptiska, variabelnamn.
Men vad gör TeX *faktiskt* med detta nybakade heltalsvärde 1218? Hur får TeX veta att den ursprungliga strängen `def`, nu representerad av heltalet 1218, faktiskt avser en instruktion att definiera ett makro? Svaret är att TeX har en slags intern “arkivlåda” där det lagrar den aktuella betydelsen och värdet för varje kommando som det för närvarande känner till—oavsett om det kommandot är ett användardefinierat makro eller ett inbyggt primitiv. Anledningen till att TeX lade möda på att omvandla `def` till hashvärdet 1218 (nu lagrat i variabeln som kallas `curcs`) är att använda det för att slå upp *betydelse* för `def`. TeX kommer naturligtvis att upprepa denna hashberäkning för alla kontrollord det upptäcker i indatat—även om olika kontrollord ger olika heltalsvärden från hashfunktionen: det är hela poängen.
TeX:s interna “arkivlåda” kallas *ekvivalenstabellen* och är ämnet för nästa avsnitt.
### Slå upp i ekvivalenstabellen
För att sammanfatta, låt oss se vad vi har lärt oss hittills:
* `\` introducerar början på en kontrollsekvens (antingen en *kontrollsymbol* eller en *kontrollord*).
* Om det första tecknet efter `\` har `\\catcode` 11 (bokstav) så är det början på ett *kontrollord*.
* För *kontrollord* TeX skannar för att kontrollera alla efterföljande indatatecken som har `\\catcode` 11 och slutar skanna så snart det hittar det första tecken som inte gör det *inte* har en `\\catcode` av 11.
* Teckensträngen i indatat (som följer efter `\`) och som har `\\catcode` 11 anses vara ett *kontrollord* som användaren har skrivit in: ett kommando som ber TeX att “göra något”.
* För att inleda processen att “göra något” omvandlar TeX teckensträngen i kontrollordet till ett heltal. Det gör det med hjälp av en så kallad hashfunktion som ger ett heltal som utdata.
* Heltalet (det beräknade hashvärdet) kallas *aktuella kontrollsekvensen*, men TeX ger det det kortare namnet `curcs`.
* I vårt exempel omvandlas kontrollordet `def` till värdet 1218—vilket lagras i en variabel som kallas `curcs`: dvs. `curcs=1218`.
TeX behöver nu ta reda på vad det nyupptäckta *aktuella kontrollsekvensen* egentligen betyder—vad gör TeX med det?
#### En not om gruppering: behovet av att spara och återställa information
Här tar vi en liten omväg för att påminna oss om att TeX har förmågan att spara och återställa information: dvs. det har någon form av inbyggt “minne”.
Alla som har skrivit ens det enklaste makro bör vara medvetna om TeX:s grupperingsmekanism—till exempel genom att använda `\def` för att skapa makron inom en grupp. Om du inte använder `\global` prefixet till `\def`-skapade makron som definieras inom en grupp, så kvarstår makrots värde eller betydelse endast inom den gruppen (och de under den): dess definition förloras när gruppen avslutas. Om du till exempel definierar ett enkelt makro inne i en grupp, så här:
```latex
{\def\foo{Hello}}
```
och försöker använda `\foo` utanför gruppen
```latex
{\def\foo{Hello}}% \foo definieras inom en grupp (obs: ingen användning av \global)
\foo %<--- inte längre definierad, nu odefinierad
```
får vi då det älskade felet: `Odefinierad kontrollsekvens`. `\foo` har endast betydelse inne i den grupp (och dess undergrupper) i vilken den definierades. Dessutom, när du omdefinierar ett makro inom en grupp kan det nya värdet gå förlorat när gruppen avslutas och den tidigare betydelsen (som fanns utanför gruppen) återställs.
```latex
\def\foo{Goodbye}
\foo\par% Ger Goodbye
{\def\foo{Hello}% Omdefinierad inom en grupp:
{Inuti grupp på andra nivån: \foo\par}}% Använt inom grupp på andra nivån: \foo ger Hello
Utanför gruppen återställs det gamla värdet: \foo\par% Ger Goodbye
```
Syftet med dessa enkla exempel är att peka på att TeX har någon form av “lagringsmekanism” eller “minne” som sparar/återställer kommandons “betydelse”—och det gör det förstås. Vi antydde detta i föregående avsnitt: den “lagringsmekanism” eller “arkivlåda” är en stor intern tabell som kallas *ekvivalenstabellen*. Det är där TeX lagrar den aktuella betydelsen eller värdena för alla kommandon det för närvarande känner till—de inbyggda primitiv och användardefinierade makron.
### Ekvivalenstabellen: genom analogi
För att förklara ekvivalenstabellen går vi fram genom analogi. Vi fortsätter att använda föreställningen om en arkivlåda med tusentals små lådor, där varje låda är märkt med ett unikt heltal. I detta skede i bearbetningen säger TeX i praktiken:
“Okej, jag har detta heltalsvärde 1218 som jag just beräknade och sparade i en variabel som kallas `curcs`. Jag behöver nu ta reda på vad det betyder: för att göra det går jag och tittar i låda nummer 1218 i min arkivlåda för att se vad som står där.”
TeX använder 1218 för att lokalisera rätt låda och där finner den en liten notis som innehåller tre informationsbitar vars namn är de som används i TeX:s källkod:
* **`eq_level:`** den grupperingsnivå vid vilken denna post definierades (nivå 1 = globalt definierad). Vi såg grupperingsverkningarna i praktiken ovan: här i ekvivalenstabellen är det som den informationen om grupperingsnivån lagras;
* **`eq_type:`** kommandokoden för denna post;
* **`equiv:`** nuvarande “värde” för denna post—det kan vara ett enkelt heltal som kommandomodifieraren som nämndes ovan, eller en pekare till ett område i minnet; till exempel minnesplatsen för samlingen av token som representerar en makrodefinition.
Så vårt hashvärde 1218 (sparat i variabeln `curcs`) har i praktiken använts som *nyckel* för att få tillgång till en låda som innehåller den aktuella betydelsen och värdet av kommandot som vi ursprungligen skrev in som teckensträngen `\def`.
Inom källkoden för TeX-programmet lagras `eq_type` för alla kommandon med hjälp av en variabel som kallas `curcmd` och värdet av `equiv` lagras i en variabel som kallas `curchr`.
### Vad säger ekvivalenstabellen för def?
Som nämnts sparas hashvärdet som beräknas för varje kommando i en variabel som kallas `curcs`; alltså för `def` har vi `curcs=1218`. Om vi tittar på plats 1218 i ekvivalenstabellen hittar TeX följande information:
* `curcmd`=97. Detta är kommandokoden för `\def`;
* `curchr`=0. Detta är kommandomodifieraren för `\def`.
`\def` är ett primitivt (inbyggt) TeX-kommando och om det inte har omdefinierats någonstans, bör den tredje och sista informationsbiten vara `eq_level=1` vilket indikerar att betydelsen av `\def` är definierad globalt och inte begränsad till någon lägre grupperingsnivå. Internt spelar värdet av `eq_level` som är knutet till ett kommando en oerhört viktig roll inom TeX:s grupperingsmekanism men vi kommer inte att gå vidare med detta.
Följande grafik sammanfattar förklaringen vi har arbetat igenom:
## TeX-token för kommandon
Efter att ha plöjt igenom förklaringarna ovan visar det sig att den faktiska beräkningen av TeX-token för kontrollsekvenser är verkligen mycket enkel. TeX använder värdet av `curcs` (1218) från hashfunktionen för att skapa ett enkelt heltal som det kallar en *token*. Beräkningen för att generera en token från värdet av `curcs` är:
```c
curtok = 4095 + curcs
```
TeX lagrar värdet på den aktuella tokenen (den senast beräknade) i en variabel som kallas `curtok`.
Så, sammanfattningsvis är TeX-tokenen som representerar `\def` kommandot är `4095 + 1218 = 5313`. Och det är allt vad gäller TeX-token som representerar kommandosekvenser: de är helt enkelt ett heltalsnummer som beräknas från ett värde i hash-tabellen plus 4095.
## TeX-token för tecken
När TeX behöver skapa en token som representerar ett tecken använder det följande, lika enkla, beräkning:
```c
curtok = 256*catcode + (tecknets ASCII-värde)
```
Observera att något olika beräkningar används för Unicode-medvetna motorer såsom LuaTeX.
Till exempel är TeX-tokenen som representerar ett blanktecken med `\\catcode` 10 och ASCII-värdet 32:
```c
256*10 + 32 = 2592
```
### Tokenlistor som innehåller tecken
När du skapar en enkel tokenlista med till exempel
```latex
\toks100={Hello}
```
kommer TeX att skapa följande tokenlista och lagra den i minnet för senare användning:
* H→ 256 × 11 + 72 = 2888
* e→ 256 × 11 + 101 = 2917
* l→ 256 × 11 +108 = 2924
* l→ 256 × 11 +108 = 2924
* o→256 × 11 + 111 = 2927
Djupt inne i TeX:s minne kommer tokenregistret 100 att ge åtkomst till lagringsplatsen för “Hello”, sparat som 5 tokenvärden: 2888, 2917, 2924, 2924, 2927. Observera att dessa token kombinerar varje teckens ASCII-kod och värdet av dess `\\catcode`i det ögonblick de omvandlas till token (tokeniseras). När tecken har omvandlats till tecken-token är `\\catcode` värdet som är knutet till dem permanent och lagras inom tokenen för senare användning när användaren säger till exempel `\the\toks100`.
Som nämnts beräknas en tecken-token från `256*catcode + (ASCII-värde)` medan en kontrollsekvenstoken beräknas från `4095 + curcs` där `curcs` är hashvärdet för kontrollordet (teckensträngen för ett kommando som skrivits in av användaren) som TeX upptäcker i indatat. Det är värt att notera att tecken-token alltid är mindre än 4095. Därför kan TeX lätt avgöra om en viss token representerar en kontrollsekvens (ett kommando) eller ett tecken och sedan lista ut vilken kontrollsekvens eller vilket tecken och `\\catcode` par som är kodat i den tokenen.
---
# 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/sv/fordjupade-artiklar/53-what-is-a-tex-token.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.