> 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/21-how-tex-macros-actually-work-part-3.md).
# Come funzionano davvero le macro TeX: Parte 3
[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)
## È il momento di fare una pausa!
Prima di passare alla parte successiva di questa storia dobbiamo fare un riepilogo: ricordarci dove stiamo andando e raccogliere le idee per essere sicuri che tutte le idee chiave siano al loro posto. Solo un promemoria: il nostro esempio svolto si basa sull'ipotesi che TeX abbia letto una riga di testo contenente `Hello World \jobname` e che TeX stia componendo questo per costruire un paragrafo.
### L'obiettivo finale
Il nostro obiettivo è sviluppare una migliore (più profonda) comprensione della natura delle macro di TeX e del loro funzionamento. Tuttavia, per arrivarci dobbiamo prima capire come TeX legge un file di input ed elabora i caratteri al suo interno. Ecco un riepilogo degli argomenti trattati finora.
* TeX legge (scansiona) ogni carattere del tuo input e, per ogni carattere, TeX ha due informazioni:
* **codice del carattere**: un numero intero usato per identificare quel carattere, ad es. quando è memorizzato in un file di input .tex;
* **codice di categoria**: un altro intero, interno a TeX, che usa per assegnare un significato a ogni carattere letto dall'input.
* Non appena un carattere viene letto da TeX, il codice di categoria di ciascun carattere diventa *definitivamente* associato a quel singolo carattere tramite la creazione di un token di carattere:
* TeX usa una semplice formula per “impacchettare insieme” un codice del carattere e il relativo codice di categoria in un intero chiamato token di carattere.
* Puoi cambiare il significato di qualsiasi carattere che TeX abbia *non ancora letto* assegnando un codice di categoria diverso a qualsiasi carattere il cui comportamento desideri cambiare — cioè modificando il modo in cui TeX tratta quel carattere.
* La ridefinizione (rimappatura) dei codici di categoria si ottiene usando il primitivo di TeX `\catcode` comando.
* Quando TeX vede un codice di categoria pari a 0 passerà a una modalità speciale di scansione e inizierà a cercare un comando: sia una *parola di controllo* oppure un *simbolo di controllo*.
Finora abbiamo esaminato il processo di scansione dell'input di TeX mentre identifica i singoli caratteri e usa il codice di categoria di ciascun carattere per capire cosa fare dopo. Alcuni caratteri sono semplicemente elementi ordinari di testo da comporre (ad es. codice di categoria 11), ma abbiamo visto anche caratteri di spazio (codice di categoria 10) e caratteri di escape (codice di categoria 0). Esistono altri codici di categoria che, per brevità, non abbiamo esaminato — come il codice di categoria 1 (“inizio gruppo”, ad es., `{`), codice di categoria 2 (“fine gruppo”, ad es., `}`) e altri. Ogni codice di categoria svolge il proprio ruolo nella scansione dell'input di TeX e nell'elaborazione successiva da parte dei processi/algoritmi software interni a TeX.
### Token: una rapida revisione
Il concetto di “token” è centrale nel modo in cui funziona TeX: vedrai “token” menzionati o citati in libri, articoli e comunità online legati a TeX, quindi vale la pena rivedere brevemente questo argomento — puoi trovare maggiori dettagli in un articolo pubblicato in precedenza [Che cos’è un «token TeX»?](/latex/it/articoli-approfonditi/53-what-is-a-tex-token.md)
Abbiamo già visto che TeX converte i caratteri di input in token combinando il codice del carattere e il codice di categoria in un singolo intero composito. TeX fa qualcosa di simile per i comandi: usando il nome del comando calcola un intero chiamato un *token di comando* (lo esploreremo in modo più dettagliato). Come guida, puoi pensare ai token come al metodo di TeX per “impacchettare” gli elementi che ha letto dall'input, rendendoli pronti per essere inviati alla fase successiva dell'elaborazione di TeX. Avere tutti gli elementi (caratteri o comandi) ordinatamente racchiusi in una singola rappresentazione numerica rende più facile elaborarli più avanti nella catena. Ad esempio, quando TeX vuole memorizzare parte del tuo input per usarla in seguito, come una definizione di macro, TeX deve solo salvare la definizione della tua macro, per quanto complessa, come una serie di interi, dove ogni intero è un token che rappresenta un carattere o un comando che fa parte di (è contenuto in) la definizione della tua macro.
## Allora, cosa c'è dopo?
Nell'ultima sezione della Parte 2 abbiamo visto come un carattere di escape (codice di categoria 0) faccia passare TeX a una modalità speciale di elaborazione in cui cerca il nome di un comando. Nel nostro esempio, TeX ha rilevato la stringa di caratteri `jobname` e abbiamo concluso la Parte 2 nel punto in cui TeX stava per “fare qualcosa” con quella stringa di caratteri (nome di un comando). In questa parte esamineremo, in dettaglio, cosa fa TeX dopo.
Una volta che TeX ha identificato che una particolare sequenza di caratteri nel tuo file di input rappresenta il nome di un comando (qui, `jobname`) TeX potrebbe, a seconda di ciò che sta facendo, dover eseguire quel comando. Diciamo “potrebbe dover” perché ci sono casi in cui TeX non proverà immediatamente a eseguire un comando: per esempio, quando sta definendo una macro (TeX sta costruendo liste di token)—argomenti di cui parleremo più avanti. Tuttavia, continueremo a seguire il nostro esempio in cui TeX sta componendo un paragrafo e *componga*, in questa situazione, deve eseguire `\jobname`.
### Da una stringa di caratteri all'esecuzione di un comando: come?
Per prima cosa, rivisitiamo il Grafico 5b della Parte 2, in cui TeX ha identificato che una particolare stringa di caratteri all'interno dell'input costituisce il nome di un comando: `jobname`. Il Grafico 5b indica che TeX deve “Controllare le tabelle interne...”. Cosa significa *in realtà*?
Un'altra descrizione, più dettagliata, di come TeX “controlla le tabelle interne” per passare dall'avere una stringa di caratteri (ad es., `jobname`) a determinare esattamente quale sia il comando e cosa significhi, si può trovare in un articolo precedente [Che cos’è un «token TeX»?](/latex/it/articoli-approfonditi/53-what-is-a-tex-token.md) Qui riassumeremo le idee chiave cercando di evitare eccessive ripetizioni.
Cominciamo con un'analogia. Supponi di stare leggendo un libro e di imbatterti in una parola sconosciuta: cosa fai? Oggi, quasi certamente “prendi Google” ma supponiamo che tu preferisca un metodo più vecchio: prendi un dizionario che elenca le parole e ne fornisce il significato. TeX ha un meccanismo analogo: un “dizionario” interno che elenca tutti i comandi attualmente noti a TeX — e il “significato” di quei comandi. Per “significato” intendiamo di che tipo di comando si tratta: cosa fa, oltre a qualsiasi altra informazione che TeX potrebbe necessitare per eseguire quel comando. Nota anche che il termine “comando” include qualsiasi macro TeX/LaTeX scritta da utenti/programmer di TeX e le [centinaia di comandi primitivi incorporati](/latex/it/altri-argomenti/46-tex-primitives-listed-by-tex-engine.md).
Continuando con la nostra analogia del dizionario. Quando, come lettori umani, dobbiamo cercare il significato di una parola, la cercheremo nel dizionario usando l'elenco alfabetico delle parole fornito dal dizionario — ma, naturalmente, TeX non funziona proprio così. Tornando al nostro `jobname` esempio originale, come fa TeX a trovare, nel suo “dizionario”, il “significato” di `jobname`—e cosa fornisce davvero quel “significato” a TeX?
Piuttosto che fornire un “elenco alfabetico” interno di tutti i comandi che TeX conosce, fa qualcosa di un po' diverso. TeX converte l'intera sequenza di caratteri — presente nel nome di un comando — in un singolo intero, che verrà usato per identificare (rappresentare) quel comando. Internamente, TeX mantiene un grande “dizionario” di tutti i comandi noti nel quale salva/memorizza gli *interi* calcolati dai nomi dei comandi — nota che il dizionario non memorizza i nomi effettivi dei comandi stessi come sequenze di lettere (chiamate *stringhe*). TeX usa quel dizionario per tutti i suoi comandi incorporati (primitivi) *e* lo userà per memorizzare i dettagli di qualsiasi macro (comando) creata dagli utenti: il nome della tua macro viene trasformato in un intero e quell'intero viene “registrato” all'interno del dizionario di TeX.
Ogni volta che TeX rileva un comando usato nel tuo input e ha bisogno di sapere qualcosa su quel comando, converte la serie di caratteri nel nome del comando in un intero “equivalente” e usa quell'intero per cercare il comando all'interno del suo “grande dizionario”. I programmatori tra voi potrebbero voler sapere che TeX usa una forma di [funzione hash](https://en.wikipedia.org/wiki/Hash_function) per effettuare quella conversione.
### Grafico 6: Dai caratteri al significato del comando
Il grafico seguente mostra il percorso che un comando compie mentre TeX converte la stringa di caratteri in un intero equivalente, che viene chiamato **curcs**, e usa quell'intero per cercare il significato del comando nel “grande dizionario” di TeX. Il risultato di quella ricerca è costituito da due informazioni: due interi, chiamati **curcmd** e **curchr**, che TeX può usare per determinare esattamente cosa fa il comando e come eseguirlo successivamente.
Internamente, TeX mantiene una variabile chiamata **curcs** (**sequenza**di controllo **c**corrente **s**) che viene usata per memorizzare il valore intero del comando su cui TeX sta attualmente lavorando—cioè, **curcs** memorizza l'intero calcolato dal nome del comando. Questa non è proprio tutta la storia perché c'è un altro dettaglio: se TeX ha appena letto/elaborato un carattere, e non un comando, imposterà **curcs** a un valore di 0, per ricordare che l'ultima cosa letta era un carattere, non un comando.
### Cosa significano i comandi per TeX
Se guardiamo all'insieme dei [comandi incorporati forniti dai motori TeX](/latex/it/altri-argomenti/46-tex-primitives-listed-by-tex-engine.md) possiamo vedere che alcuni di questi comandi sono strettamente correlati: svolgono compiti simili; per esempio, ci sono 4 comandi primitivi che tutti i motori TeX usano per definire (creare) macro: `\def`, `\gdef`, `\edef`, `\xdef`. Quei 4 comandi definiscono tutti macro ma, naturalmente, ciascuno lo fa in modo leggermente diverso. Se pensiamo a questo dal punto di vista della programmazione: qui abbiamo 4 comandi di definizione di macro che, in generale, fanno la stessa cosa ma dobbiamo scegliere tra loro per adattarci al loro comportamento individuale.
Per gestire questo, TeX assegna due valori a ogni comando e quei due valori sono ciò che TeX intende come “significato” di un comando (il suo ruolo/cosa fa) — quei due valori sono interni a TeX, in profondità nel software, e fanno parte del “meccanismo interno” non accessibile agli utenti. Ogni comando TeX, che sia un primitivo incorporato o un comando definito dall'utente, riceve due valori che, per TeX, definiscono/classificano il suo comportamento — ciò che significa per TeX. Quando TeX usa il suo “grande dizionario” per cercare un comando, troverà quelle due informazioni vitali:
* **codice di comando**: una sorta di “classificazione generale” che indica che “tipo” di comando sia — come un comando di “definizione di macro” (uno di `\def`, `\gdef`, `\edef`, `\xdef`); un comando di “creazione di box” (uno di `\hbox`, `\vbox` o `\vcenter`) e così via per le centinaia di comandi supportati dai motori TeX. Alle macro (comandi definiti dall'utente) viene assegnato anche un codice di comando.
* **modificatore del comando**: Si tratta di informazioni accessorie che forniscono a TeX informazioni specifiche su un comando. Alle macro (comandi definiti dall'utente) viene assegnato anche un modificatore del comando — sebbene, con le macro, il modificatore del comando svolga un ruolo leggermente diverso rispetto ai primitivi (per le macro, il modificatore del comando indica dove la definizione della macro è memorizzata in memoria).
Considerati insieme, il codice del comando e il modificatore del comando identificano in modo univoco ogni comando. Ecco i codici del comando e i modificatori del comando per i comandi di definizione di macro come usati dal software TeX originale di Knuth — nota che altri motori TeX possono usare valori diversi, ma seguono esattamente lo stesso principio:
| | | |
| ----------- | ---------------------------------------------------------- | ---------------------------------------------------------------- |
| **Comando** | Comando
codice
| Comando
modificatore
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Riepilogo: dare un senso a tutte queste variabili/valori
A questo punto siamo sommersi da molte informazioni su valori, variabili, valori dei comandi e ogni sorta di dettaglio — può diventare rapidamente confuso, quindi facciamo il punto su ciò che sappiamo. Quando TeX legge qualcosa dal tuo input, si tratta di un carattere o di un comando. Ogni volta che TeX legge qualcosa dall'input deve memorizzare informazioni su ciò che ha appena letto (scansionato):
* Per **caratteri**: deve registrare il codice del carattere e il codice di categoria. Deve anche creare e memorizzare il valore del token che TeX calcola usando quei valori.
* Per **comandi**: TeX ha bisogno di conoscere l'equivalente numerico, **curcs**, che ha calcolato dal nome del comando. Potrebbe anche dover memorizzare il “significato” che ha recuperato cercando il comando nel “dizionario” di TeX: il codice del comando e il modificatore del comando. Oltre a questo, TeX dovrà anche calcolare un valore token che rappresenti questo comando.
Sì, è confuso: ci sono molte variabili e idee di token che circolano, quindi proviamo a dare un senso a tutto ciò.
Internamente, TeX usa quattro variabili globali per memorizzare informazioni sull'ultimo elemento che TeX ha letto (o su cui sta attualmente “lavorando”) — non discuteremo queste variabili in grande dettaglio, ma conoscerne l'esistenza aiuta a fornire un po' più di contesto per capire cosa succede davvero:
* **curcmd**: (comando corrente) una variabile intera. Viene usata per memorizzare il *comando corrente* valore per il comando in fase di elaborazione *o* memorizza il codice corrente *codice di categoria* del carattere in fase di elaborazione;
* **curchr**: (carattere corrente) una variabile intera, ma ciò che memorizza dipende da ciò che TeX ha appena letto dal suo input:
* **carattere**: se l'elemento letto più di recente è un carattere, **curchr** memorizza il codice corrente *codice del carattere*.
* **comando**: se l'elemento letto più di recente è un comando, **curchr** memorizza il *modificatore del comando*: informazioni aggiuntive che TeX usa per supportare/chiarire **curcmd**—perché, come abbiamo visto sopra, alcuni comandi condividono lo stesso valore di **curcmd**
* **curcs**: (sequenza di controllo corrente) una variabile intera che memorizza il valore calcolato dalla stringa di caratteri in un nome di comando. **curcs** = 0 se l'ultimo elemento letto era un singolo carattere e non il nome di una sequenza di controllo (un nome di comando);
* **curtok**: (token corrente) una variabile intera che contiene il valore del token corrente — che è un token di comando o un token di carattere.
Ecco le informazioni sopra visualizzate in forma di tabella:
| | | |
| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Variabile globale usata all'interno di TeX:** | **Quando TeX scansiona un carattere:** | **Quando TeX scansiona un comando:** |
| **curcmd** | Memorizza il codice di categoria del carattere corrente | Memorizza il codice del comando *codice di comando*—che identifica il “tipo” del comando corrente |
| **curchr** | Memorizza il codice del carattere corrente | Memorizza dati supplementari (chiamati il *modificatore del comando*) che forniscono informazioni aggiuntive sul comando corrente |
| **curcs** | 0 | Un intero positivo non zero che viene calcolato (tramite una funzione hash) usando la stringa di caratteri presente nel nome del comando. Viene usato per accedere al “dizionario” di TeX e cercare il significato corrente di un comando — per recuperare il suo codice del comando e il suo modificatore del comando. |
| **curtok** | Per i motori TeX a 8 bit, un *token di carattere* viene calcolato usando la formula: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ dove $$\text{curcmd}$$ è il codice di categoria del carattere e $$\text{curchr}$$ è il codice del carattere | Per i motori TeX a 8 bit, un *token di comando* viene calcolato usando la formula: $$\text{curtok}=4095 + \text{curcs}$$ |
### Ulteriori note sul token corrente
Per i caratteri, il massimo valore possibile del token si ottiene usando il codice di categoria più grande (15) e il codice del carattere più grande che, per i motori TeX a 8 bit, è 255. In teoria (per i motori TeX a 8 bit), il massimo valore del token di carattere, $$\text{curtok}\_{\text{max}}$$, è:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Notiamo “in teoria” perché il codice di categoria 15 è usato per rappresentare un “carattere non valido”, che causa la generazione di un errore da parte di TeX: un carattere non valido non passerà mai il processo di scansione dell'input di TeX e quindi non diventerà mai un token di carattere.
Per i comandi il token corrente ($$\text{curtok}$$) è calcolato da $$\text{curtok}=4095 + \text{curcs}$$ ma per i comandi $$\text{curcs}$$ è *sempre* non zero, quindi TeX può determinare facilmente cosa rappresenta un token:
* Se $$\text{curtok} > 4095$$ allora è un token di comando;
* Se $$\text{curtok} < 4095$$ è un token di carattere.
In effetti, TeX usa i token, un semplice valore intero, per “impacchettare” tutte le informazioni che deve conoscere su un elemento letto dall'input.
## Parte 4
Nella Parte 4 esploriamo una serie di macro di esempio per dimostrare il ruolo e lo scopo della `` sezione della macro per fungere da “modello di token” che può essere costruito tramite l'uso di token delimitatori.
[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/21-how-tex-macros-actually-work-part-3.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.