> 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/it/altri-argomenti/24-how-tex-macros-actually-work-part-6.md).

# Come funzionano davvero le macro TeX: Parte 6

[Parte 1](/latex/it/altri-argomenti/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/it/altri-argomenti/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/it/altri-argomenti/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/it/altri-argomenti/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/it/altri-argomenti/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/it/altri-argomenti/24-how-tex-macros-actually-work-part-6.md)

## Introduzione e panoramica: la storia finora

Nelle 5 parti precedenti di questa serie abbiamo visto:

* come TeX legge i caratteri all'interno di un file di input e usa i codici di categoria per riconoscere diverse “classi” di caratteri e successivamente convertirli in token di carattere e token di comando;
* che una macro è, in pratica, composta da quattro sezioni:

```
<primitive della macro TeX><nome della macro><testo dei parametri>{<testo di sostituzione>}
```

dove:

* `<primitive della macro TeX>` = uno dei `\def`, `\edef`, `\gdef` o `\xdef`;
* `<nome macro>`=il nome della tua macro, come ad esempio `\foo`;
* `<testo dei parametri>` può essere “nullo” (assente) oppure può essere una stringa di token delimitatori e token parametro della macro;
* `<testo di sostituzione>` è il corpo effettivo della tua macro: la sezione che viene “eseguita” (espansa) quando richiami la macro.
* come la `<testo dei parametri>` sezione può contenere un'ampia gamma di token e TeX usa questa sezione come un “modello di token” per confrontare una chiamata alla macro con la sua definizione originale e ricavare gli argomenti usati con la macro — e come TeX si aspetta che l'uso di una macro corrisponda alla sua definizione originale;
* che, all'interno di TeX, la definizione di una macro è memorizzata come una sequenza continua di token che rappresentano le `<testo dei parametri>` e `<testo di sostituzione>` sezioni.

Quando usi un comando macro, TeX verificherà prima se accetta parametri. In tal caso, TeX deve poi identificare i veri *argomenti* usati nella tua chiamata alla macro. TeX deve verificare la tua chiamata alla macro rispetto alla definizione “modello di token” che ha memorizzato in memoria. In particolare, TeX usa la definizione interna (memorizzata) della `<testo dei parametri>` sezione come modello attraverso cui può individuare i *token* che sono i veri argomenti, e che *token* servono solo da delimitatori.

## Il significato dell'espansione delle macro

Ora, finalmente, siamo pronti a passare all'argomento più importante: come TeX elabora gli argomenti delle macro ed esegue davvero la macro: un processo che TeX chiama *espansione delle macro*.

### Ma prima, un breve esempio: qualcosa di strano?

Per “preparare la scena” per spiegare il meccanismo con cui TeX elabora le macro e i loro argomenti, useremo un breve esempio per indicare le questioni che dobbiamo considerare.

#### Gli argomenti vengono prima convertiti in token

Il seguente esempio si basa su uno discusso alle pagine 114–5 di [The Advanced TeXbook](https://www.amazon.co.uk/Advanced-Texbook-David-Salomon/dp/0387945563) scritto da David Salomon. È stato scelto perché racchiude in modo efficace le idee centrali in una macro TeX molto breve.

Durante le normali operazioni di TeX/LaTeX, il `$` simbolo ha codice di categoria 3 (“math shift”) che porta TeX dentro/fuori dalla modalità matematica in linea (`$...$`) oppure dalla modalità matematica in display (`$$...$$`)—naturalmente, LaTeX usa `\(..\)` e `\[..\]` per gli stessi scopi.

Supponiamo di volere una macro che cambi il codice di categoria di un `$` simbolo a, diciamo, 11, in modo da poterlo comporre come un normale carattere. Possiamo usare il comando primitivo TeX `\catcode` e il nostro primo tentativo di una macro del genere, `\docat`, potrebbe essere

```
\def\docat #1{\catcode`\$=11 #1}
```

Tuttavia, quando proviamo a usarla, così

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Ho pagato \docat{$90} per quel libro.
\end{document}
```

ci aspettiamo che TeX componga `Ho pagato $90 per quel libro.` ma fallisce con un messaggio di errore:

```
! Inserito $ mancante.
<testo inserito>
                $
<da rileggere>
                   \par
l.7
```

Dall'errore sembra che il `$` usato nell'argomento della nostra macro stia ancora facendo sì che TeX componga in modalità matematica; chiaramente, TeX *non ha* cambiato il codice di categoria del `$` usato nell'argomento della nostra macro (`$90`). La domanda è *perché* TeX non ha cambiato il codice di categoria di `$` a 11 e non l'ha composto come un normale carattere? La breve risposta è che TeX prima converte gli argomenti delle macro in token **prima** e poi li inserisce nella lista di token della `<testo di sostituzione>`—ma esamineremo i meccanismi di base in modo molto più dettagliato.

Quello che dobbiamo ricordare è che la nostra idea di TeX che usa testo/caratteri è rilevante solo per il contenuto del file che TeX sta leggendo: non appena TeX ha letto qualsiasi carattere entriamo nel mondo dei *token*. Le chiamate alle macro di TeX funzionano con *token*, non con il reale *rappresentazione scritta/testuale* dei comandi TeX/LaTeX—questo diventerà più chiaro man mano che esamineremo l'esempio.

Inizialmente, potremmo pensare che il nostro uso della `\docat` macro in `Ho pagato \docat{$90} per quel libro.` sia lo stesso che scrivere direttamente il codice TeX (o LaTeX) equivalente—come il seguente, che *di* funziona:

```
\begin{document}
Ho pagato \catcode`\$=11 $90 per quel libro.
\end{document}
```

![Alcuni codici TeX in esecuzione su Overleaf](/files/fe483b04f6d5e672b0e7a6042f01e250d1c422e5)

Tuttavia, come abbiamo visto sopra, il modo in cui TeX elabora gli argomenti delle macro produce un risultato (`! Inserito $ mancante.`) che è molto diverso dallo scrivere il codice TeX: ora esploreremo *perché* cosa succede.

### Macro e argomenti come liste di token

Per comprendere pienamente il comportamento della `\docat` macro e del suo argomento (`$90`), e perché fallisce, dobbiamo di nuovo visualizzare la definizione della `\docat` macro e di eventuali argomenti usati (quando \docat viene chiamato) come *liste di token*, non come una sequenza di caratteri.

Mentre TeX scansiona il tuo testo di input, riconoscerebbe `\docat` come un comando macro; dopodiché verifica se accetta parametri—come TeX lo fa è spiegato nella sezione seguente per i lettori interessati ai dettagli più fini.

#### Per coloro che amano i dettagli...

Dopo che la macro viene chiamata, TeX verifica se il primissimo token (nella lista di token della definizione memorizzata della macro) è il **token di corrispondenza finale** token: in tal caso, TeX può essere certo che la macro non accetta parametri.

**Un esempio**

I seguenti diagrammi di liste di nodi confrontano le liste di token di due macro:

* `\def\foo A#1B{#1}`: questa ha `<testo dei parametri>` di `A#1B`, di conseguenza il **token di corrispondenza finale** token è **non** il primo token, quindi TeX procederebbe a cercare parametri;
* `\def\foo{X}`: questa non ha una `<testo dei parametri>` sezione, di conseguenza il **token di corrispondenza finale** token è il primo nella lista di token e TeX sa di non dover cercare alcun parametro.

![Come TeX verifica se una macro accetta parametri](/files/2bc1818c2ac3d36f67ec5a1ea0157ce23aa471cf)

## Verso il “gran finale”: espansione

Ricordiamoci la domanda: perché la seguente macro non ha funzionato; cioè, perché TeX non cambia il codice di categoria di alcun `$` simboli $ usati nell'argomento della `\docat` macro, come ad esempio `\docat{$90}`?

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Ho pagato \docat{$90} per quel libro.
\end{document}
```

Come spiegato sopra, quando TeX scansiona il tuo input e riconosce un comando macro—nel momento in cui TeX sta per eseguirlo—TeX verifica prima se quella macro accetta parametri. In tal caso, TeX dovrà scansionare ulteriormente il file di input per identificare i veri *argomenti* che l'utente ha fornito per questa specifica chiamata alla macro: TeX deve farlo **prima** prima di poter chiamare il codice effettivo della macro. Chiaramente, TeX deve determinare i dati che l'utente vuole fornire alla macro.

Per identificare gli argomenti presenti nell'input (la chiamata alla macro dell'utente), TeX sarà guidato dalla definizione di quella macro memorizzata internamente: in particolare, la `<testo dei parametri>` sezione della definizione della macro memorizzata (lista di token)—che fornisce una sorta di “modello di token”. Usando quel “modello di token” TeX deve determinare quali *token* nella chiamata alla macro dell'utente sono solo *delimitatori* (essenzialmente “punteggiatura”) e quali *token* fanno parte di un *argomento*. È quando TeX incontra un **token parametro di corrispondenza** nella definizione memorizzata della macro `<testo dei parametri>` sezione (“modello di token”) che sa di dover iniziare a formare una *lista di token* per quell'argomento specifico.

Non appena TeX riconosce la necessità di identificare l'argomento dell'utente, scansionerà l'input per generare token e li controllerà con molta attenzione, token per token, rispetto alla definizione memorizzata della macro. TeX continua a raccogliere token per un argomento finché non rileva un token che è effettivamente un delimitatore, oppure se rileva il **token di corrispondenza finale** token: in entrambi i casi, TeX capisce che è ora di smettere di cercare i token che fanno parte di quell'argomento.

### Perché la macro \docat è fallita

Come osservato, *prima* TeX può effettivamente chiamare una macro solo dopo aver identificato e preparato eventuali argomenti da usare con quella macro. Tuttavia, per identificare il/i argomento/i, pronti per essere passati alla macro, TeX deve generare ciascun argomento come una *lista di token*: ed è questo il motivo del `\docat`fallimento di

Nel nostro esempio, abbiamo fornito `\docat` con un argomento di `$90` ma quell'argomento viene prima *convertito in una lista di token* mentre TeX scansiona la chiamata alla macro—l'argomento viene convertito in token *prima* prima che la macro venga effettivamente chiamata. Qui, per l'argomento `$90`, TeX genererà tre token di carattere: un token per ciascuno di `$`, `9` e `0`.

Il seguente grafico mostra la lista di token generata per l'argomento `$90`, prima di essere inserita nel corpo della `\docat` macro:

![Lista di token TeX generata per un argomento della macro](/files/4330ed72f6ffa1eb195b87c4a5ecca48ef582229)

Nel grafico sopra possiamo vedere chiaramente che la lista di token dell'argomento contiene il `$` come token di carattere basato su un codice di categoria di 3.

Come abbiamo visto nelle Parti 1-3, i token di carattere vengono creati usando i valori del codice di categoria *in vigore nel momento in cui il carattere viene letto*—cioè, nel momento in cui viene creata (trasformata in token) la lista di token dell'argomento. Nel momento in cui gli argomenti vengono tokenizzati, la `\docat` macro non è ancora stata eseguita, quindi la modifica del codice di categoria che abbiamo inserito nella chiamata alla macro (``\catcode`\$=11``) *non* influenza i codici di categoria usati per generare i token dell'argomento.

Una volta che TeX ha generato una lista di token che rappresenta l'argomento di `$90`, quei tre token di carattere vengono inseriti nella macro effettiva `<testo di sostituzione>`. Tuttavia, ciò comporta che il `$` venga inserito come un *token di carattere* creato usando il codice di categoria 3: “math on” e abbiamo visto che, una volta formato un token di carattere, il codice di categoria associato è permanente. Il `$` è *non* inserito nella macro *come carattere*, ma come un *token di carattere* basato sul `$` che ha codice di categoria 3.

### Eseguendo \docat: espansione della macro

TeX si riferisce al processo di “esecuzione” di una macro come *espansione delle macro*; un termine che, secondo l'autore, è un po' confuso ma è la terminologia accettata, quindi continueremo a usarlo.

#### Il vero significato dell'espansione delle macro

Dopo che TeX rileva il `\docat` comando nell'input dell'utente, scansiona gli argomenti e genera una lista di token per il suo argomento(`$90`). Per eseguire (espandere) la macro, TeX sposta il suo sguardo lontano dal file di input dell'utente e inizia a leggere i token contenuti `\docat`’s `<testo di sostituzione>` lista di token memorizzata nella memoria di TeX.

Mentre TeX elabora `\docat`la definizione di`**codice di categoria**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**#1**`).

Il seguente grafico mostra il processo di espansione della `\docat` macro: TeX smette di ottenere token dal file di input e inizia a leggere token dalla `<testo di sostituzione>` sezione della `\docat` definizione della macro memorizzata in memoria. TeX procede a eseguire questi token predefiniti finché non vede un **parametro di output** token che istruisce TeX a leggere (“iniettare”) ed “eseguire” i token dell'argomento a questo punto. Nel nostro esempio, si tratta di tre token di carattere che rappresentano `$90` e ciò provoca un errore perché il token di carattere predefinito per `$` ha codice di categoria 3. Poiché abbiamo a che fare con token di carattere, non con caratteri, il `$` non è influenzato dalla precedente modifica del codice di categoria causata dai token in ``\catcode`\$=11``.

![Mostrando il processo di espansione della macro \docat](/files/99c2910c60f94bbdecd1568819528678dc184fb6)

Dopo che TeX ha elaborato i token che rappresentano ``\catcode`\$=11``, la modifica del codice di categoria per `$` sarà ora in vigore. TeX incontra quindi il “token speciale” chiamato **parametro di output** che dice a TeX di **inserire** la lista di token dell'argomento. Tuttavia, quella lista di token è composta da tre caratter *token*, il primo dei quali è un token per un `$` a cui è assegnato un codice di categoria 3 (“math on”): la precedente modifica del codice di categoria all'interno della macro non può influenzare questo token di carattere, quindi TeX tratta quel token come un segnale per iniziare l'elaborazione matematica, il che causa il fallimento della macro.

### La macro \docat può essere corretta?

Dalle discussioni sopra, è chiaro che qualsiasi carattere che appare negli argomenti delle macro viene tokenizzato usando i codici di categoria in vigore nel momento in cui avviene la tokenizzazione—che, nel nostro esempio, è *sempre* prima della `<testo di sostituzione>` della `\docat` macro venga effettivamente eseguita. Quindi, come possiamo assicurarci che i codici di categoria degli argomenti di una macro vengano modificati?

Un modo è modificare `\docat` in una macro senza parametri che effettua solo la modifica del codice di categoria—non ha argomenti da tokenizzare. Usiamo poi una seconda macro, `\getarg`, che prende un singolo parametro, e facciamo in modo che l'argomento di quella macro venga tokenizzato quando il codice di categoria appropriato per `$` è operativo.

```
\begin{document}
\def\docat{\catcode`\$=11 \getarg} % Nessun parametro, chiama una seconda macro \getarg
\def\getarg#1{#1} %1 parametro il cui argomento verrà tokenizzato
Ora puoi eseguirlo così e funzionerà:

Ho pagato \docat{$90} per quel libro.
\end{document}
```

Quando usiamo la nostra nuova versione di `\docat` (così `\docat{$90}`) sembra *sembrare* come se il `$90` fosse ancora usato come argomento per la `\docat` macro. Tuttavia, come discusso sopra, quando TeX rileva `\docat` nell'input controlla se ha argomenti: ora non ne ha, quindi TeX procede a eseguirla (espanderla). L'espansione di `\docat` è la sequenza di token `**codice di categoria**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**spazio**`, `**getarg**` e questo avviene *prima* TeX inizia a leggere (tokenizzare) i caratteri successivi contenuti nel file di input—cioè, il gruppo `{$90}`. Ricorda che quando TeX espande una macro, ottiene il suo input successivo leggendo i token contenuti nella lista di token della definizione di quella macro; cioè, dalla sua `<testo di sostituzione>` sezione memorizzata in memoria.

TeX elaborerà ed eseguirà l'espansione di `\docat` e rileverà il *token* **`getarg`**, riconoscendolo come un token che rappresenta un comando che accetta parametri. A questo punto, TeX scansionerà il file di input per cercare **`getarg`**&#x6C;'argomento di: i caratteri: `{$90}`. Come al solito, questi vengono tokenizzati, ma poiché TeX ha letto ed elaborato l'espansione di `\docat`, i caratteri `$90` vengono tokenizzati quando il codice di categoria di `$` è stato cambiato in 11. La definizione (`<testo di sostituzione>`) di `\getarg` è semplicemente `#1` che significa comporre l'argomento fornito, ed è esattamente ciò che accade, con il risultato di un `$` con codice di categoria 11 generato e composto in modo sicuro.

## Osservazioni conclusive: la storia nei nodi

La sequenza di eventi derivante dalla riscrittura di `\docat` per usare la macro `\getarg` è contenuta nel seguente diagramma annotato della lista di nodi che mostra il processo di espansione per la macro `\docat`. I lettori che desiderano studiare attentamente questo diagramma possono scaricare il grafico come [PDF](https://assets.ctfassets.net/nrgyaltdicpt/7MOBdavza4WxAEQGISEEht/cabe5097d9063a6415bc553cd38237e6/newdocatexpansion.pdf) o [SVG](https://images.ctfassets.net/nrgyaltdicpt/2FIqqVRXjakdAzTpZsV0m9/10ccc1353741d42d3df18f1692d8aa84/newdocatexpansion--plain.svg) file per l'uso offline.

![Mostrando il processo di espansione della macro \docat modificata e della macro \getarg](/files/5481252ce7fdeec5ce67f92c2bc63c3218972a68)

[Parte 1](/latex/it/altri-argomenti/19-how-tex-macros-actually-work-part-1.md) [Parte 2](/latex/it/altri-argomenti/20-how-tex-macros-actually-work-part-2.md) [Parte 3](/latex/it/altri-argomenti/21-how-tex-macros-actually-work-part-3.md) [Parte 4](/latex/it/altri-argomenti/22-how-tex-macros-actually-work-part-4.md) [Parte 5](/latex/it/altri-argomenti/23-how-tex-macros-actually-work-part-5.md) [Parte 6](/latex/it/altri-argomenti/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/it/altri-argomenti/24-how-tex-macros-actually-work-part-6.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.