> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Hur fungerar \expandafter: en introduktion till TeX-tokens [Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Bakgrund till \expandafter: TeX-token och tokenlistor Som ett första steg mot att förstå hur `\expandafter` det verkligen fungerar kommer vi att titta på två komponenter i TeX som är grundläggande för hur `\expandafter`: TeX-token (heltal) och tokenlistor (listor av heltal). Läsare som vill utforska dessa ämnen mycket mer i detalj kan vara intresserade av att läsa följande artiklar som publicerats av Overleaf: * [Vad är en TeX-token?](/latex/sv/fordjupade-artiklar/53-what-is-a-tex-token.md) * [Vad är en TeX-tokenlista?](/latex/sv/fordjupade-artiklar/54-what-is-a-tex-token-list.md)-[Hur fungerar TeX-makron egentligen?](/latex/sv/fler-amnen/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### Var kom token-datan ifrån? Genom hela den här artikeln använder vi faktiska tokenvärden beräknade av TeX—data som normalt inte är tillgänglig för användare. För läsare som är nyfikna på hur denna tokenvärdesdata erhölls har Overleaf anpassade byggen av flera TeX-motorer som vi använder för forskning. Dessa motorer har modifierats för att skriva ut information om TeX:s interna bearbetningsaktiviteter—vilket hjälper till att ge ytterligare bakgrundsmaterial till några av de artiklar vi producerar. Genom att visa/diskutera numeriska tokenvärden är vårt mål att inkludera detaljer som förhoppningsvis hjälper läsare att bättre förstå ”TeX-token”, så att detta viktiga begrepp känns lite mindre ogenomskinligt. ## TeX-token 101 (och begreppet expansion) När TeX bearbetar din indatafil läser det texten och konverterar enskilda tecken och sekvenser av tecken (kommandon) till så kallade *tokens*. En TeX-token är helt enkelt ett heltalsvärde, beräknat av TeX, som används för att ”koda” data som TeX behöver lagra om ett objekt som lästs in från dess aktuella indatakälla. Tänk på token som små informationspaket som ”paketerar ihop” data som TeX behöver registrera, redo att skickas vidare till nästa bearbetningssteg. Internt arbetar TeX med dessa heltals-tokenvärden — det använder inte de faktiska bokstäverna, symbolerna, siffrorna osv. som ursprungligen fanns i din indatafil: allt konverteras till en token (ett heltal) och TeX arbetar med dem. ## Hur TeX beräknar tokenvärden Här tittar vi på tokenberäkningar som används i Knuths ursprungliga TeX, e-TeX och pdfTeX; för andra TeX-motorer, särskilt XeTeX och LuaTeX, behöver deras tokenberäkningar vara något annorlunda för att ta hänsyn till användningen av Unicode, men beräkningsmetoderna liknar dem som beskrivs nedan. ### Teckentoken (icke-aktiva tecken) Beräkningen av tokenvärden för icke-aktiva tecken är enkel: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Exempel**: Bokstaven A med [kategorikod](/latex/sv/fler-amnen/43-table-of-tex-category-codes.md) 11, teckenkod 65 representeras av TeX som teckentokensvärdet $$256\times 11 + 65 = 2881$$. Du kan stöta på beskrivningar i TeX-litteraturen som påpekar att när TeX har läst in ett tecken blir dess kategori-kodsvärde ”permanent bundet” till det tecknet: ovanstående beräkning av tokenvärdet visar varför det stämmer. Men senare i TeX:s bearbetning kan det, och gör det, ”packa upp” teckentoken för att avslöja paret av beståndsdelar (teckenkod, kategori-kod) som tokenen konstruerades av — när TeX gör denna ”uppackning” ändrar det fortfarande inte det tecknets kategori-kod; det använder bara den informationen under den fortsatta bearbetningen. ### Kommandotoken TeX:s indata-bearbetning och token-generering känner igen två typer av kommandon: * kommandon konstruerade av ett eller flera tecken som har kategori-kod 11; * kommandon med ett enda tecken där det tecknets kategori-kod inte är 11: såsom `\$` eller `\#`. I båda fallen utesluter TeX det inledande `\` tecknet och använder teckenkoden för varje återstående tecken för att beräkna ett heltal som TeX kallar `curcs` (**cur**rent **c**ontrol **s**equence). TeX använder sedan värdet av `curcs` för att beräkna ett tokenvärde för kommandot. #### Kommandon skapade av tecken med kategori-kod 11 Anta att vårt kommando (minus det inledande `\` tecknet) består av en sekvens av tecken: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ där $$\mathrm{C}\_i$$ är teckenkoden för varje tecken—t.ex. är teckenkoden för A 65. TeX använder alla teckenkoder $$\mathrm{C}\_i$$ för att beräkna heltalet `curcs` (med hjälp av en [hash-funktion](https://en.wikipedia.org/wiki/Hash_function)). När TeX har beräknat värdet av `curcs` lägger det helt enkelt till 4095 till det värdet, för att ge tokenvärdet: $$\text{command token} = \text{curcs + 4095}$$ Observera att variabeln `curcs` spelar en extremt viktig roll i TeX:s inre bearbetningsaktiviteter. #### Kommandon med ett enda tecken Token för att representera kommandon såsom `\$`, `\#` osv. är föremål för en något annorlunda beräkning: heltalet `curcs` är nu den enklare beräkningen: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Till exempel, med `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX lägger återigen till 4095 till detta värde (med $$\text{command token} = \text{curcs} + 4095$$) vilket resulterar i `\$` som har tokenvärdet $$293 + 4095 = 4388$$. Jämfört med kommandon som består av tecken med kategori-kod 11 är den enda skillnaden här sättet som TeX beräknar värdet för `curcs`. **Obs**: heltalet `curcs` beräknas inte för teckentoken: det sätts alltid till 0 när TeX skapar eller arbetar med teckentoken. #### Aktiva teckens token TeX har begreppet så kallade *aktiva tecken*: vilket tecken som helst som tilldelats kategori-kod 13. Token för denna speciella klass av tecken beräknas på ett annat sätt än vanliga tecken. Mekanismen för aktiva tecken gör det möjligt för TeX att skapa det som i praktiken är makron med ett enda tecken som du kan använda *utan* utan att behöva föregå det aktiva tecknet med ett escape-tecken (vanligen `\`): det isolerade tecknet kommer att utlösa dess makrobeteende. Det klassiska exemplet är tilde-tecknet (\~) som TeX/LaTeX använder för icke-brytande mellanslag, vilket kan definieras/aktiveras så här: ``` \catcode`~=13 %assign category code 13 to ~ \def~{\penalty100000\ } % define ~ to act as a macro ``` När TeX senare läser ett `~` tecken kommer det att upptäcka att dess kategori-kod är 13 och behandla det som ett ”mini-makro”. För att beräkna en token som representerar ett aktivt tecken tillämpar TeX en annan variant för att beräkna `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Till exempel har tecknet \~ teckenkoden 126, vilket innebär att dess tokenvärdesrepresentation för aktivt tecken beräknas så här: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Observera att token som representerar aktiva tecken, precis som kommandon, är > 4095. ### Konsekvenser/anmärkningar * Alla token vars värde överstiger 4095 kan omedelbart identifieras som en kommandotoken — därför kan TeX mycket enkelt avgöra om en viss token representerar ett tecken eller ett kommando. * För varje tokenvärde kan TeX, när det behövs, ”packa upp” den tokenen för att avslöja tecknet (och dess kategori-kod), eller kommandot, som ursprungligen fanns i din `.tex` fil, lagrat i en makrodefinition eller innehållet i någon annan tokenlista. * Det ”mellanliggande” värde som kallas `curcs`—som TeX använder för att beräkna kommandotokens värden—spelar en viktig roll i TeX:s låg-nivåbearbetning. `curcs` fungerar som ett ”indexvärde” som TeX använder för att lagra/hämta den aktuella betydelsen av ett kommando. Givet vilken som helst kommandotoken, $$\mathrm{T}$$, subtraherar TeX helt enkelt 4095 för att komma åt värdet av `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ För övrigt lagrar TeX faktiskt den läsbara strängen av tecken från vilken en kommandotoken genereras — detta är nödvändigt för felrapportering och andra kommandon såsom `\string` vars expansion är den mänskligt läsbara versionen av ett tokenvärde. Men de läsbara teckensträngar som lagras inne i TeX används/skrivs ut endast när det begärs: för all annan bearbetning används tokenheltalsvärdet. ## Titta på några riktiga token För att göra begreppet token lite mindre opakt ska vi definiera följande enkla makro och titta på de token som TeX producerar: ``` \def\hello{Greetings, from \TeX. \hskip 10pt} ``` För `\hello` makrot använder TeX tecknen `h`, `e`, `l`, `l`, `o` för att beräkna värdet 3745 för `curcs`; TeX lägger sedan till 4095 för att skapa ett tokenvärde på $$3745 + 4095 = 7840$$ (för Knuths TeX, e-TeX eller pdfTeX). Efter att ha skapat en token för att representera `\hello`, den `\def` kommandot får TeX att läsa de efterföljande tokenen och använda dem för att skapa en tokenlista som lagras som *definitionen* av `\hello` kommandot. Den lagrade definitionen (tokenlistan) kan sedan hämtas närhelst du säger åt TeX att använda `\hello` kommandot. Följande tabell listar de faktiska tokenvärden som skapas för varje objekt (tecken, makro eller primitiv) som finns i `\hello` makrodefinitionen — denna lista av token (heltal) är vad TeX lagrar i sitt minne (som en datastruktur känd som en [länkad lista](https://en.wikipedia.org/wiki/Linked_list)). Läsare som vill förstå tokenlistor mer i detalj hänvisas till Overleaf-artikeln [Vad är en TeX-tokenlista?](/latex/sv/fordjupade-artiklar/54-what-is-a-tex-token-list.md) | | | | ------------------ | ------------------------ | | **TeX-tokenvärde** | **Representerat objekt** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | s | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | I tokenlistan ovan har tecknen kategori-koderna 10, 11 eller 12. Till exempel: * tecknen har kategori-kod 10 och teckenkod 32, vilket ger ett tokenvärde på $$256\times 10 + 32 = 2592$$ * `,` och `.` har kategori-kod 12 och teckenkoderna 44 respektive 46, vilket ger token: * token för `,` $$= 256 \times 12 + 44 = 3116$$ * token för `.` $$= 256\times 12+ 46 = 3118$$ När TeX senare stöter på tokenvärdet 7840 (som representerar `\hello`) kan det, om så krävs, ”packa upp” den tokenen för att extrahera `curcs` genom den enkla beräkningen $$\text{curcs} = \text{token value} - 4095$$ (se ovan). Med värdet av `curcs` kan TeX konsultera sina interna datatabeller för att avgöra att kommandotoken 7840 representerar ett makrokommando. Dessutom kan TeX, återigen via `curcs`, också slå upp och hämta den lagrade definitionen av `\hello`. När TeX behöver bearbeta token 7840 fullständigt, dvs. köra `\hello` makrot, behöver det inte längre token 7840: den tokenen har *gjort sitt jobb*—dvs. den utlöste TeX att köra makrot `\hello`. TeX kan nu kassera token 7840 och hämta de token som representerar definitionen (tokenlistan) lagrad i minnet. I praktiken har `\hello` makrokommandot (token 7840) har blivit *borttaget* från TeX:s aktuella indatakälla och *ersatts* av token som finns i definitionen av `\hello`. Det vi just beskrev är en form av *tokenexpansion*. Den `\TeX` kommandot (tokenvärdet 5235 listat ovan) som används inom `\hello` är i sig självt ett makro konstruerat av fler token — så dess definition lagras också som en tokenlista: | | | | ------------------ | ------------------------ | | **TeX-tokenvärde** | **Representerat objekt** | | 2900 | T | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \hbox | | 379 | { | | 2885 | E | | 637 | } | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Om vi skulle ersätta `\hello` kommandot med den fullständiga lista av token som det är uppbyggt av, inklusive `\TeX` makrot, skulle det bli en ganska lång lista — dvs. om vi också *expanderade* den `\TeX` makrot skulle vi se: ![En lista av token lagrad i ett TeX-makro](/files/ef2fd79c7ee23f132fb8c620457339e37c589854) I huvudsak skulle det enskilda tokenvärdet 7840 (för `\hello`) vid full expansion producera totalt 51 token (heltal) som representerar tecken och primitiva kommandon. I följande lista är det tecken eller kommando som representeras av varje token inneslutet i parenteser ”(...)” — dessa lagras inte direkt i TeX:s tokenlistor och visas för att hjälpa läsaren: ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` För en mänsklig läsare är detta bara en serie heltal men för TeX kodar det en stor mängd information. ## Läs token nu och spara dem till senare När TeX läser din indata kan det ibland behöva (eller instrueras att) skjuta upp den fullständiga bearbetningen av en viss uppsättning token. Om det beordras att göra det kommer TeX, tills det får besked att sluta, att fortsätta skapa token från indata men lagra dem för senare användning — och därefter hämta och bearbeta dem som en del av sina sättningsaktiviteter. Dessa lagrade token sparas som så kallade *tokenlistor* som i praktiken är TeX:s enda (interna) lagringsmekanism för token-data. Vi har redan sett exempel på tokenlistor — de `\hello` och `\TeX` makron som listades ovan: definitionerna av dessa makron lagras i TeX:s minne som listor av token. TeX bearbetar (verkställer) sådana tokenlistor först när du bestämmer dig för att anropa dessa makron. Kom också ihåg att varje token (heltalsvärde) kodar tillräckligt med information för att TeX enkelt ska kunna avgöra om varje token som lagras i en makrodefinition representerar ett tecken eller ett kommando. ### Spara token med tokenregister Ett annat exempel på tokenlagring är den explicita skapelsen av tokenlistor som sparas i så kallade *tokenregister*: särskilda interna lagringsområden som TeX tillhandahåller för att användare ska kunna lagra tokenlistor. TeX-primitiven `\\toksdef` är ett sätt att använda tokenregister; för exempel, för att använda tokenregister `100` och referera till det med kommandot `\mylist`: ``` \toksdef\mylist=100 \mylist={några \TeX{}-token här} ``` `\mylist` är i praktiken bara ett namn som du tilldelar en lista av token lagrade på registerplats `100`. I likhet med en makrodefinition, `\mylist` innehåller följande tokenlista: | | | | ------------------ | ------------------------ | | **TeX-tokenvärde** | **Representerat objekt** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Obs**: för att avsluta `\TeX` makrot och förhindra att det suger upp det följande `` tecknet använde vi ett par klamrar `{}` omedelbart efter `\TeX`—tokenen för `{` (379) och `}` (637) lagras i tokenlistan. Ett annat alternativ är att använda en ”kontrollmellanslag”-token `\` som skulle förekomma i tokenlistan som visas nedan (i fetstil): | | | | ------------------ | ------------------------ | | **TeX-tokenvärde** | **Representerat objekt** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Observera att `` tecken representeras som en *teckentoken* med värdet $$256\times 10 + 32 = 2592$$ men `\` behandlas som en kommandotoken med ett enda tecken *kommandotoken* (värde 4384) som beräknas med hjälp av formlerna ovan: \begin{align\*} \text{curcs} & = 257 + \text{teckenkod (ASCII)}\\\ & = 257 + 32\\\ &=289\\\ \text{kommandotoken för} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} I grund och botten `\mylist={några \TeX{}-token här}` säger till TeX: vänligen skanna min indatafil för att konvertera följande tecken/kommandon till token och spara dem för senare användning. TeX kommer att följa detta och lagra dessa token på en minnesplats som du kan komma åt genom att skriva `\the\mylist`, vilket instruerar TeX att infoga en kopia av token som finns i tokenregistret `\mylist`. TeX-motorer inkluderar ett antal primitiva kommandon som explicit genererar och lagrar tokenlistor — såsom `\everyjob`, `\everypar`, `\mark`, och många andra. [Del 1](/latex/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/sv/fordjupade-artiklar/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/sv/fordjupade-artiklar/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/sv/fordjupade-artiklar/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/sv/fordjupade-artiklar/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/sv/fordjupade-artiklar/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.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/sv/fordjupade-artiklar/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.