> 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/fler-amnen/22-how-tex-macros-actually-work-part-4.md). # Hur TeX-makron egentligen fungerar: Del 4 [Del 1](/latex/sv/fler-amnen/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/sv/fler-amnen/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/sv/fler-amnen/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/sv/fler-amnen/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/sv/fler-amnen/24-how-tex-macros-actually-work-part-6.md) ## Introduktion och översikt I del 1–3 gjorde vi en djupdykning i några detaljer på låg nivå som bakgrund som förberedelse för att förstå hur TeX-makron fungerar. I den här artikeln ska vi ”komma upp till ytan” för att gå igenom några grundläggande praktiska principer för TeX-makron som förberedelse inför en ny djupdykning i del 5 och 6. Genom hela den här artikeln kommer vi att visa exempelmakron definierade med hjälp av TeX:s primitiva kommandot `\def`: vi kommer inte att använda det kanske mer bekanta LaTeX-kommandot `\\newcommand`. Det finns en mycket god anledning till detta: vårt mål är att förstå de grundläggande principerna bakom TeX:s makrobeteende, men för att göra det behöver vi använda centrala kommandon *inbyggda i* TeX-programvaran. LaTeX-kommandon, som till exempel `\\newcommand`, är själva makron: kommandon med ett specifikt programmerat beteende som i slutändan är uppbyggda av lager av TeX:s primitiva kommandon på lägre nivå. För att bättre förstå TeX:s grundläggande beteende måste vi använda TeX-primitiver, inte LaTeX-makron. ### Vart är vi på väg? I grunden arbetar vi mot en förklaring av makron som en specialiserad form av tokenlista: när du instruerar TeX att definiera ett makro skapar det en sekvens av token (en tokenlista) och lagrar dem i sitt minne kopplade till ett namn som du definierar. I del 5 och 6 kommer vi att titta närmare på makrots tokenlistor, men om du hellre vill hoppa från den här artikeln för att läsa bakgrundsinformation hittar du det i [Vad är en TeX-tokenlista?](/latex/sv/fordjupade-artiklar/54-what-is-a-tex-token-list.md) Tokenlistor för makron, och deras parametrar, innehåller några ytterligare finesser som vi ska gå igenom i detalj — och använda gott om exempel. För att bättre förstå TeX:s makrobehandlingsbeteende finns det egentligen en nyckelfaktor att komma ihåg: TeX tänker bara på tecken i det tidigaste stadiet av inmatningsbearbetningen: från den punkten och framåt är det token hela vägen! Under den här, och de återstående artiklarna i serien, kommer vi att utforska den roll som token spelar i TeX-makron. ## De fyra delarna av ett makro ### Påminnelse: makroparametrar och makroargument Innan vi börjar är det värt att påminna oss om skillnaden mellan ett makros *parametrar* och ett makros *argument*argument ``` \def\foo#1#2{This is #1, this is #2} ``` Konstruktionerna (token) `#1`, `#2` (upp till `#9`) kallas makrots *parametrar*: tänk på dem som ”platshållare” för de faktiska data du kommer att använda när du anropar makrot: ``` \foo{alpha}{beta} ``` Här är `alpha` och `beta` de *argument* som används med detta anrop av \foo: ett makros argument är de faktiska värden som matas in i parameterplatshållarna (`#1`, `#2`... `#9`) som användes när du definierade makrot. ### Makrodefinition: har 4 element Vi börjar med det som kanske ser ut som en något formell definition av ett makro, men den ger en användbar ram för vidare diskussion. Varje makrodefinition består av 4 delar: ``` {} ``` där: * ``: en av `\def`, `\edef`, `\gdef` eller `\xdef`; * ``: namnet som ges till ditt makrokommando, som till exempel `\foo`; * ``: detta kan saknas, men om en sådan finns är det en serie av *tokens* som kommer före `` i makrot. `` kan innehålla makroparametrar (`#1`, `#2`... `#9`) och andra token-typer. I grunden, och som vi ska se i detalj, ger `` en sorts *tokenmall* som TeX använder för att räkna ut vilka token användaren vill använda som makrots argument: när du anropar ett makro matar TeX in *argument* tokenen i ditt makros `` (som också är en tokenlista); * `{}`: detta är själva kroppen i ditt makro: det är en serie av token som *argument* ”infogas” när makrot bearbetas (expanderas). Argumenten matas in på de positioner som anges av de makroparametrar som används i den ursprungliga definitionen. **NOTERA**: Genom hela diskussionen antar vi att `` kommer att följas av ett blanktecken med kategorikod 10 som ska fungera som ett avgränsande tecken för att avsluta ``. Vi *har inte* uttryckligen visat det blanktecknet i vår text/diskussion, men vi antar att det finns där. Strikt taget borde vi representera det ungefär så här: ``` {} ``` Vi kommer dock att utelämna den explicita inkluderingen av ett `` tecken och implicit anta att det finns där. #### Anmärkningar om {} Vi har visat användningen av två klamrar: `{` och `}` som omger (avgränsar) den faktiska kroppen av ditt makros ``. Användningen av `{` och `}` är dock bara en vedertagen konvention eftersom det TeX faktiskt förväntar sig är att texten i ditt makro `` ska börja med ett tecken med kategorikod 1 (”Starta en grupp”) och sluta med ett tecken med kategorikod 2 (”Avsluta en grupp”). Enligt konventionen är dessa `{` och `}` tecknen respektive. Men du kan, om du vill, tilldela vilket par av tecken som helst att göra det. Till exempel ``` \catcode`\(=1 \catcode`\)=2 ``` Nu kan du definiera och använda makron så här: ``` \def\foo #1(Hello, #1) \foo(World!) ``` Och du kan fortfarande använda `{` och `}` eftersom vi inte har ändrat deras kategorikoder — flera tecken kan ha, och har, samma kategorikod, så du kan fortsätta att definiera makron på vanligt sätt: ``` \def\foo #1{Hello, #1} \foo{World!} ``` ### och {} De delar av ett makros definition som är mest relevanta för vår diskussion är `` och `{}`. När du definierar ett makro är `` i praktiken en strikt tokenmall som definierar hur makrot ska användas. Som nämnts kan `` vara tomt, t.ex. `\def\foo{Some text}` där ingenting visas mellan vårt kommandonamn (`\foo`) och den öppnande klammern `{` som här signalerar början av vårt makros ``. **Obs**: En del läsare känner kanske till TeX:s ”hashquote”-mekanism (`#{`) men vi kommer inte att ta upp den här. ### och makroavgränsare Den här artikeln är inte tänkt som en heltäckande genomgång av hur man skriver makron, men det är ändå värt att ha en kort repetition, med några exempel, som visar att `` kan bli komplext eftersom TeX tillåter `` att innehålla: * **makroparametrar**: (`#1`, `#2`,... `#9`) som fungerar som ”platshållare” för värden som användaren kommer att tillhandahålla när de kör makrot — makrots *argument*; * **avgränsartoken**: godtyckliga token som är insprängda i/runt parameter-tokenen och används för att ange gränsen mellan makroparametrar. Du kan tänka på dessa avgränsare som en sorts ”interpunktion” som gör `` till en ”tokenmall” som du måste följa när du använder makrot. Avgränsartoken sätts inte i tryck. Så vad betyder detta egentligen — låt oss titta på några exempel. `` står mellan makronamnet och vänsterklammern `{` i makrodefinitionen. #### Avgränsare: Exempel 1 Anta att vi definierar ett enkelt makro `\foo` på följande sätt: ``` \def\foo ABC{hello, there} ``` * `` = `ABC` * Det finns inga parameter-token (`#1`, `#2`,... `#9`) * Avgränsarna är *de tre teckentokenen* `ABC` men i det här exemplet är de något överflödiga och används bara som exempel. De tre teckentokenen `ABC` behandlas som avgränsare: inte något som ska sättas i tryck utan ”interpunktion” som förväntas finnas när makrot anropas — när du använder makrot `\foo` måste du ange samma avgränsare som fanns när det definierades. Om du skriver `\foo ABC` i din text kommer detta att sätta `hello, there`i tryck — teckentokenen `ABC` sätts inte i tryck men TeX kontrollerade mycket noggrant att de faktiskt fanns i ditt anrop av `\foo`. TeX letar efter dessa avgränsare (”interpunktion”) och tar bort (absorberar) dem, som du kan se i följande Overleaf-skärmbild: `ABC` sätts inte i tryck: ![Overleaf kör ett TeX-makro](/files/dc3954f571c65549ed87c280d2cc042e115181f2) Om du försöker använda `\foo` utan `ABC` avgränsarna kommer TeX att klaga `Användning av \foo stämmer inte överens med dess definition.`: ![Visar ett TeX-fel i Overleaf](/files/a2753ea31070f8d4f0ec3287c67106525e18d4dc) I exemplet ovan, efter att ha upptäckt `\foo` förväntar sig TeX att se de tre teckentokenen `ABC` men det gör den inte: den ser teckentokenen för `w` och upptäcker omedelbart att något är fel. #### Avgränsare: Exempel 2 Ett intressant, och kanske överraskande, faktum är att avgränsare kan vara godtyckliga kommandotoken — inklusive kommandon som *inte ens har definierats*. Till exempel skulle vi kunna definiera `\foo` på följande sätt: ``` \def\foo A\bob B\anne{Hello \TeX{}} ``` * `` = `A\bob B\anne` * Det finns inga parameter-token (`#1`, `#2`,... `#9`) * Avgränsarna är tokenen `A\bob B\anne` men återigen är de i det här exemplet överflödiga och endast för diskussionens skull. Observera att `\bob` och `\anne` är påhittade kommandon som *inte definierades*— och det behöver de inte vara. När du anropar ett makro kontrollerar (skannar) TeX `` som finns där *i ditt makroanrop* och jämför det, token för token, med versionen av ”tokenmallen” *lagrad i minnet*— den som skapades när makrot definierades. TeX skannar *som används i ditt makroanrop* och omvandlar helt enkelt alla kommandon det hittar där till sitt numeriska tokenvärde: det försöker inte exekvera dessa kommandon, därför spelar det ingen roll att `\bob` och `\anne` aldrig definierades. TeX använder helt enkelt tokenmallen som lagrats i minnet som en vägledning som gör det möjligt att räkna ut vilka token i `` i ditt makroanrop som är de faktiska argumenten som ska matas in i ``. Som du kan se i följande Overleaf-skärmfragment sattes varken någon av teckentokenen (`Ett` och `B`) i `A\bob B\anne` i tryck och våra odefinierade kommandon `\bob` och `\anne` orsakade inga problem. Alla dessa token *absorberades* av TeX när den matchade din användning av `\foo` med definitionen (tokenmallen) av `\foo` (en tokenlista) lagrad i minnet. ![Overleaf kör ett TeX-makro](/files/646788a5e9bde705dea383874764628367282e81) #### Avgränsare: Exempel 3 Du kan blanda in olika avgränsare (teckentoken, kommandotoken) med makroparametrar, som i det här exemplet: ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Hello from \TeX{} to \#1=#1, \#2=#2 and \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Det finns 3 makroparametertoken: `#1`, `#2`, `#3` * Den här gången är parametrarna (`#1`, `#2`, `#3`) avgränsade av en kombination av token: `A\bob#1B\anne#2\jane#3bye!` Här har du i praktiken gett TeX en mall som den mycket noggrant kommer att försöka, och förvänta sig, matcha när du anropar `\foo`: den kommer att gå igenom ditt makroanrop, *token för token*, och förvänta sig att matcha (finna): * de två tokenen `Ett` och `\bob` innan `#1` * de två tokenen `B` och `\anne` innan `#2` * tokenen `\jane` före parameter `#3` och *fyra teckentoken* `b`, `y`,`e` och `!` efter `#3`. **Kom ihåg**: TeX tänker i token, så `bye!` är *fyra teckentoken*. Det finns två sätt vi kan använda det här makrot — vi skulle kunna sätta alla argument som består av flera token inom klamrar för att skapa en grupp: ``` \foo A\bob{This}B\anne{That}\jane{Other}bye! ``` Men det *är inte nödvändigt* eftersom vår makrodefinition har avgränsare som ger en tokenmall. TeX kan använda den mallen för att plocka ut token för varje argument bland token som enbart är avgränsare. Vi kan använda vårt makro så här: ``` \foo A\bob ThisB\anne That\jane Otherbye! ``` och TeX kan plocka ut argumenten för att ge samma resultat som när man använder grupper `{...}`: ![Overleaf kör ett TeX-makro med avgränsare](/files/ac336facd65626d76444eb64aaea1553aede180d) Lägg märke till hur TeX kunde upptäcka exakt vilka token som matchade parametrarna `#1` och `#3`: ![Overleaf kör ett TeX-makro med avgränsare](/files/e53934b8144d3bb49b1fea2ab65a04b5a25c903a) #### Avgränsare: Exempel 4 (det handlar om token, inte om tecken!) Här är ett kort exempel som visar att det när man arbetar med makron är viktigt att komma ihåg att vi verkligen befinner oss i tokenens värld *tokens* och **inte** *tecken*… Vi definierar följande korta makro där A och B är tecken som fungerar som avgränsare och båda har kategorikod 11. Detta fungerar utan problem: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hello, #1} \foo AGrahamB \end{document} ``` och sätter i tryck `Hello, Graham`. Men om du ändrar kategorikoden för A eller B till något annat än 11 kommer makroanropet att misslyckas. Anta att vi ändrar kategorikoden för B till 12 med hjälp av ``\catcode`B=12`` och försöker anropa makrot igen, som tidigare: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hello, #1} \foo AGrahamB % Detta fungerar \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Det misslyckas med ett något förbryllande fel: ``` Runaway argument? GrahamB \end {document} ! Filen tog slut medan användningen av \foo skannades. \par <*> main.tex Jag tror att du har glömt en `}', vilket får mig att läsa förbi den punkt där du ville att jag skulle sluta. Jag ska försöka återhämta mig; men om felet är allvarligt är det bäst att du skriver `E' eller `X' nu och rättar din fil. ! Nödstopp. <*> main.tex *** (jobbet avbröts, ingen giltig \end hittades) ``` ![Overleaf visar ett fel i ett TeX-makro](/files/fda15651840a707774cbc905dd091373bc583675) Tyvärr är TeX:s standardsuggestion ``Jag tror att du har glömt en `}'`` är **felaktig**, det orsakas inte av en saknad klammer (`}`). #### Vad har hänt? TeX försöker matcha `\foo` makro *anropet* med `\foo` makro *definitionen* som den har lagrat i minnet. När du anropar ett makro som behöver ett eller flera argument måste TeX undersöka (skanna) din användning av makrot för att räkna ut *argument* som du tillhandahåller till det makrot. Här förväntar sig TeX att argumentet ska vara inramat av ett A (kategorikod 11) och ett B (kategorikod 11). Kom ihåg: TeX tänker i *tokens*, **inte** *tecken*. Tokenvärdena för A och B, $$\mathrm{T\_A}$$ och $$\mathrm{T\_B}$$ respektive, är: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Men när TeX fortsätter sin sökning ser den B *men* nu har den kategorikod 12 och det ger ett annat tokenvärde: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ I `\foo` I makrodefinitionen var tokenvärdet för B (använt som avgränsare) 2882, men TeX ser nu ett tokenvärde på 3138: den tror att detta bara är ytterligare en token som är avsedd att användas i *argument* som tillhandahålls till `\foo`. Såvitt TeX är oroad har argumentets sista token ännu inte hittats, så den går och hämtar en till token i sin sökning efter ett B med kategorikod 11. Det är då, och därför, som makrot misslyckas: i sitt försök att hitta argumentet ”går TeX för långt” och börjar läsa token som du inte avsåg skulle bli en del av argumentet för `\foo` makroanropet. Vad som händer sedan beror på vilka token TeX upptäcker efter B — de kommer att utlösa olika `Runaway argument?` fel. I vårt exempel går TeX för långt och konsumerar tokenströmmen `\end {document}` och når snabbt slutet av filen, därav felmeddelandet: ``` ! Filen tog slut medan användningen av \foo skannades ``` ## Del 5 Som vi såg ovan kan `` avsnittet i vårt makros definition sträcka sig från extremt enkelt till en komplex blandning av makroparametrar insprängda med teckentoken och kommandotoken som fungerar som avgränsare. TeX kan bearbeta de olika kombinationerna av token som finns i `` för att extrahera de argument som tillhandahålls till ett makro — och upptäcka när vi försöker använda ett makro felaktigt. Hur den gör det är ämnet för nästa artikel i serien. [Del 1](/latex/sv/fler-amnen/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/sv/fler-amnen/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/sv/fler-amnen/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/sv/fler-amnen/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/sv/fler-amnen/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/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.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.