> 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/19-how-tex-macros-actually-work-part-1.md). # Come funzionano davvero le macro TeX: Parte 1 [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: Obiettivi di questa serie Questa serie di articoli ha un obiettivo ambizioso: spiegare *come* come funzionano davvero le macro di TeX (come i comandi LaTeX) — al livello più fondamentale, all'interno del vero software del motore TeX. Invece di basarci *esclusivamente* su una serie di macro di esempio progettate per dimostrare varie funzionalità, casi limite e comportamenti di TeX, guarderemo dentro TeX stesso per vedere *come* e *perché* perché i suoi metodi di programmazione delle macro funzionano nel modo in cui funzionano. Per raggiungere il nostro obiettivo dobbiamo iniziare discutendo argomenti piuttosto di basso livello e, inizialmente, questi potrebbero sembrare un po' lontani dal compito di impaginare i tuoi documenti. Speriamo che, dopo un'analisi più approfondita, tu esca con una base per costruire una comprensione migliore che, alla fine, ti farà risparmiare molto tempo e, forse, ridurrà anche il livello di frustrazione. ### Il linguaggio di programmazione di TeX: ti suona familiare? Non è eccessivamente severo descrivere il linguaggio di programmazione di TeX come alquanto arcano, perché lo è — almeno secondo gli standard della maggior parte dei linguaggi di programmazione mainstream in uso oggi. Quando inizi il tuo percorso per imparare di più su TeX/LaTeX, soprattutto se vuoi scrivere macro non banali, incontri rapidamente nozioni come i codici di categoria, i token/la tokenizzazione e l’“espansione” dei comandi o delle macro. Questo bombardamento di concetti è probabilmente piuttosto estraneo, e potresti sentirti smarrito e, a volte, magari un po' frustrato, mentre il tuo cammino verso il successo non è sempre agevolato dai messaggi di errore di TeX/LaTeX, quasi impenetrabili. ## Quindi, da dove iniziamo? Dai codici di categoria. I motori TeX rientrano in una classe di software chiamata [compilatori](https://en.wikipedia.org/wiki/Compiler): programmi che prendono in input un file scritto in un *linguaggio sorgente* e lo *compilano* (trasformano) in un file di output scritto in un *linguaggio di destinazione* Più precisamente, TeX è un *compilatore di documenti*. Per i motori TeX (compilatori), il file di input è scritto nel linguaggio di composizione tipografica TeX e il risultato è un file di output scritto in un altro “linguaggio” come [DVI](https://en.wikipedia.org/wiki/Device_independent_file_format) o PDF — anche se stiamo usando una nozione un po' rilassata di “linguaggio”. Diamo uno sguardo più da vicino al “linguaggio” sorgente, o di input, usato per scrivere il tuo file TeX. Un `.tex` file è, in definitiva, una lunga sequenza di caratteri (inclusi i caratteri di interruzione di riga): composta da testo destinato alla composizione tipografica intervallato da `\`, `}`, `$`, `[` e con ogni sorta di caratteri che possono comparire in una gamma apparentemente pressoché infinita di combinazioni. Chi non usa TeX/LaTeX potrebbe guardare un tipico `.tex` file e sarebbe perdonato se lo percepisse come un miscuglio di caratteri piuttosto confuso, con poca o, se non altro, nessuna struttura visibile del file. Il pacchetto di macro LaTeX contribuisce certamente in certa misura a “imporre” una struttura di base a un file di input .tex. Tuttavia, tra i `\begin{document}` e `\end{document}` decide l'autore del documento cosa ci va inserito. Se guardi ai `.tex` file scritti usando il pacchetto di macro Plain TeX originale di Knuth, vedrai che la struttura del documento è quasi completamente assente. Quindi, in generale, un file di input TeX può apparire piuttosto non strutturato, una miscela apparentemente arbitraria di contenuti da comporre intervallati da istruzioni (comandi) che guidano la composizione di quel contenuto. Come è possibile persino per TeX dare un senso a un tipico `.tex` file di input: filtrare quel caos in arrivo di caratteri in istruzioni operative per il motore di composizione e in contenuti che devono essere composti? ### Filtrare il caos: diamo il benvenuto ai codici di categoria Qualsiasi osservatore umano, che non sappia nulla di TeX, potrebbe guardare un `.tex` file e riconoscere certi caratteri come `$` e sapere che è il simbolo di una valuta, oppure vedere un `&` e identificarlo come una e commerciale. Quell'osservatore inferisce un *forma* per ogni carattere che vede — un significato basato sul ruolo che quel carattere svolge nella comunicazione umana. Inoltre, potrebbe vedere caratteri come `un`, `e`, `o` e sapere che sono classificati come vocali, mentre altri come `b`, `c` o `d` sono classificati come consonanti. Come esseri umani, abbiamo una sorta di tabella di ricerca incorporata (nella nostra memoria) attraverso la quale assegniamo un significato a ogni carattere che vediamo — un significato basato sul ruolo che quel carattere svolge nelle lingue in cui siamo in grado di comunicare. Per elaborare un `.tex` file, anche il software TeX deve esaminare ogni carattere del tuo input e deve anch'esso assegnare un *forma* a ciascun carattere che “vede”. Tuttavia, TeX è solo una macchina software che si occupa di elaborare testo — memorizzato come una sequenza di interi (codici di carattere) situati in un file di input. Come macchina, TeX deve essere programmato con i dati pertinenti che gli dicono come determinare il significato di un carattere che sta “guardando” e, successivamente, cosa deve farne. Come fa TeX a ottenere questo? La risposta è uno di quei concetti propri di TeX: *codici di categoria,* di cui ce ne sono 16, da 0 a 15. Per quanto riguarda TeX, ogni carattere che si aspetta di vedere in un `.tex` file ha un cosiddetto *codice di categoria* assegnato in anticipo. All'interno del software TeX c'è una sorta di “tabella di ricerca” che elenca il codice di categoria *attualmente* assegnato a ciascun carattere che TeX potrebbe vedere in un file .tex di input. Dovresti pensare ai codici di categoria di TeX come a un'assegnazione di un *forma* a ciascun carattere individuale all'interno del flusso di input che TeX deve esaminare (scansionare). Per comporre il tuo documento, un motore TeX deve leggere (scansionare) ogni singolo carattere, ma l'interesse immediato di TeX non sono i caratteri effettivi (i codici dei caratteri): il *codice di categoria* di un carattere è di maggiore importanza durante la scansione dell'input. Il *dimensione* codice di categoria determina il *significato corrente* di quel carattere *nel momento in cui TeX lo legge*: quel codice di categoria determina come TeX tratterà/elaborerà ciascun carattere — spiegheremo perché diciamo “codice di categoria corrente” e “significato corrente”. È attraverso i codici di categoria che TeX è in grado di filtrare il caos di caratteri in arrivo per distinguere tra caratteri (contenuto) destinati alla composizione e caratteri che formano istruzioni da elaborare —*comandi* che TeX deve eseguire. La tabella seguente elenca questi 16 codici di categoria: ciò che ciascuno di essi significa insieme a esempi di caratteri tipicamente assegnati a ciascuna categoria. | **Codice di categoria** | **Descrizione** | **LATEX/TEX standard** | | ----------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ | | 0 | Carattere di escape—indica a TEX di iniziare a cercare un comando | `\` | | 1 | Inizia un gruppo | { | | 2 | Termina un gruppo | } | | 3 | Cambio matematico—attiva/disattiva la modalità matematica | $ | | 4 | Tabulazione di allineamento | & | | 5 | Fine della riga | Codice ASCII 13 (`\r`) | | 6 | Parametro di macro | # | | 7 | Apice—per comporre formule matematiche: `$y=x^2$` $$y=x^2$$ | ˆ | | 8 | Pedice—per comporre formule matematiche: `$y=x_2$` $$y=x\_2$$ | \_ | | 9 | Carattere ignorato | ASCII 0 `` | | 10 | Spaziatore | Codici ASCII 32 (spazio) e 9 (carattere di tabulazione) | | 11 | Lettera | A...Z, a...z, (e migliaia di caratteri Unicode) | | 12 | Altro | 0...9 più ,.;?" e molti altri | | 13 | Carattere attivo | Codice di categoria speciale per creare macro a carattere singolo come ˜ | | 14 | Carattere di commento—ignora tutto ciò che segue fino alla fine della riga | % | | 15 | Carattere non valido, non consentito nel file di input .tex | Codice ASCII 127 (`DEL`) | L'uso dei codici di categoria è il meccanismo essenziale di TeX per filtrare il suo flusso in arrivo di caratteri, dando un senso al tuo input per determinare: * i caratteri che compongono il testo da comporre; * il contenuto delimitante che dovrebbe essere composto come matematica; * sequenze di caratteri che sono nomi di comandi da elaborare o eseguire; * … e molte altre operazioni di composizione tipografica. Inizialmente, potresti pensare che il codice di categoria di ciascun carattere (il significato) sia una sorta di assegnazione fissa: immutabile e permanentemente incorporata nelle fondamenta interne del software TeX, ma non è così. Come notato, TeX mantiene una tabella di ricerca interna per memorizzare i dettagli di quale codice di categoria sia *attualmente* assegnato a ciascun carattere — usiamo volutamente l'espressione *assegnato attualmente* perché il codice di categoria di qualsiasi carattere (non ancora letto) può essere modificato usando un comando primitivo (integrato) chiamato `\catcode`\catcode. Questo offre una notevole flessibilità perché, se vuoi, puoi cambiare completamente il modo in cui TeX tratterà o interpreterà il significato di qualsiasi carattere letto successivamente dall'input, offrendo un'enorme possibilità per applicazioni di composizione sofisticate. Se sei principalmente interessato all'uso di LaTeX per “portare a termine il lavoro”, è probabile che non ti sia imbattuto direttamente nei codici di categoria se non, forse, attraverso messaggi di errore che potresti aver visto. Ma stai tranquillo: i codici di categoria sono una componente fondamentale delle operazioni di un motore TeX: consentono a LaTeX (e ai pacchetti LaTeX) di fare davvero il lavoro di composizione del tuo documento. Quando il tuo motore TeX si avvia (“[bootstrap](https://en.wikipedia.org/wiki/Bootstrapping)”) userà un insieme di allocazioni predefinite di caratteri ai codici di categoria ma, tramite il `\catcode` comando, tali valori predefiniti possono essere modificati dal codice principale di LaTeX (macro) e/o dai pacchetti LaTeX che hai caricato — o addirittura dal tuo stesso codice TeX o dalle tue macro. Tuttavia, nel tempo e per tradizione/uso, alcuni caratteri assegnati a determinati codici di categoria sono diventati accettati come “standard” e attenersi a tali standard è certamente auspicabile se vuoi che i tuoi documenti siano portabili e facilmente condivisibili con colleghi o altri utenti. Per esempio, il `\` carattere [tabella sopra](#tbl-0). ### Lettura (scansione) dell'input Quando TeX legge (scansiona) il carattere successivo dal tuo file di input, la prima cosa che fa è guardare il suo codice di categoria, quindi diamo uno sguardo più da vicino a ciò che accade quando TeX legge una riga tipica di input. Supponiamo di avere un file .tex che contiene il testo `Hello World \jobname` da qualche parte all'interno di un paragrafo. Se guardiamo all'interno del `.tex` file usando un [editor esadecimale](https://en.wikipedia.org/wiki/Hex_editor), vediamo che la sequenza di caratteri `Hello World \jobname` nel nostro `.tex` file è solo una serie di interi, o *codici di carattere*, mostrati nella schermata qui sotto come la sequenza esadecimale: `48, 65, 6C, 6C, 6F, 20, 57, 6F, 72, 6C, 64, 20, 5C, 6A, 6F, 62, 6E, 61, 6D, 65, 20` ![Codici di carattere esadecimali in un file TeX](/files/1c06cb7c21d098e9814cda823faa878c10319ebb) Se convertiamo dall'esadecimale (base 16) al decimale (base 10), la sequenza dei codici di carattere è: ![Codici di carattere decimali in un file TeX](/files/4072060c00d40789624fd74bb31a386c452f31ec) Sappiamo anche che, per TeX, ogni carattere ha un codice di categoria corrispondente; quindi, in base a [tabella sopra](#tbl-0) questo, sappiamo che le seguenti allocazioni predefinite dei codici di categoria sono (probabilmente) anch'esse in uso: ![Codici di categoria di TeX](/files/e962b352bdbad596cd7a2288524975151b882d23) Pertanto, per TeX, ogni carattere nel file di input è rappresentato da *due* valori numerici — il suo codice di carattere e il suo codice di categoria: ![Codici di carattere e codici di categoria TeX corrispondenti](/files/d3b5c1807dac2e7d89d550fd54a0481ac1bf7f32) A questo punto stiamo considerando solo la primissima fase dell'elaborazione del tuo file da parte di TeX: la scansione dei singoli caratteri. Quindi cosa fa effettivamente TeX con queste coppie di codici di carattere e codici di categoria? Una volta che TeX ha scansionato un singolo carattere e ha cercato il suo corrispondente codice di categoria, in che modo esattamente TeX usa queste informazioni per “filtrare” i caratteri in arrivo? ## Parte 2 Nella parte 2 esaminiamo più da vicino come TeX legge il tuo input: fingendo di essere gli “occhi” di TeX mentre guarda il tuo input, carattere per carattere. [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/19-how-tex-macros-actually-work-part-1.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.