Unicode
polygen v1.0.6
Tutorial sull'impiego di caratteri Unicode nelle grammatiche Polygen
Indice
Come spiegato nella pagina Cratteri Validi, all'interno della grammatiche del PolyGen possiamo fuire di un sottoinsieme limitato di caratteri Ascii. Questo non vuol dire che non sia possibile scrivere grammatiche che producano testo Unicode. È possibile, e vi sono due principali modi per conseguirlo:
- utilizzando entità SGML
- generando uno stream di byte UTF-8 tramite sequenze escape Ascii
In questa pagina vi verrà mostrato come creare una grammatica che produca il nome del Polygen in arabo secondo ciascun metodo. I sorgenti delle grammatiche sono scaricabili dai link al fondo.
Partiremo dal primo metodo perché è il più semplice.
Le entità sono — nell'ambito di linguaggi di markup derivati dall'SGML (quali HTML, XML) — dei particolari codici per rappresentare quei caratteri speciali che sarebbe altrimenti problematico rappresentare (per via di limitazioni del sistema operativo, dei font di caratteri, della tastiera, o perché costretti a usare solo caratteri Ascii).
Chi ha lavorato con l'HTML conoscerà sicuramente le entità < e >, utilizzate per rappresentare i caratteri < e > all'interno di un documento HTML senza che vengano interpretati come delimitatori di tag.
Tramite le entità è possibile rappresentare qualsiasi carattere Unicode impiegando esclusivamente caratteri Ascii. Sarà sufficiente conosce il numero univoco con il quale il carattere è rappresentato nel sistema Unicode. Per esempio, il simbolo del "Re bianco" (scacchi) corrisponde a 0x2654 (esadecimale), l'entità per rappresentarlo saranno:
-
♔(esadecimale): ♔ -
♔(decimale): ♔
Come promesso, ora creeremo una grammatica in grado di produrre il nome del Polygen in arabo — ossia: بوليجان (traslitterato: Būlīǧēn)
Ora che abbiamo il nome in arabo, dobbiamo convertirlo nelle corrispondenti entità SGML. Grazie allo strumento online HTML entity encoder/decoder, di Mathias Bynens; ci basterà copiare il nome arabo dal documento e incollarlo nella finestra del convertitore, il quale ci restituira la stringa:
بوليجان
Questa sequenza di entità SGML rappresenta il nostro nome di Polygen in arabo (sillabato: Bū-lī-ǧēn):
| AR | IT | Entità | Unicode | Descrizione |
|---|---|---|---|---|
| ب | b | ب |
U+0628 |
Arabic letter BEH |
| و | ū | و |
U+0648 |
Arabic letter WAW |
| ل | l | ل |
U+0644 |
Arabic letter LAM |
| ي | ī | ي |
U+064A |
Arabic letter YEH |
| ج | ǧ | ج |
U+062C |
Arabic letter JEEM |
| ا | ē | ا |
U+0627 |
Arabic letter ALEF |
| ن | n | ن |
U+0646 |
Arabic letter NOON |
Si noti come, nonostante l'arabo si scriva da destra a sinistra, l'ordine di comparizione delle entità nella stringa è da sinistra a destra; cionostante, la scritta araba verrà visualizzata nell'ordine giusto.
Bene, ora non ci resta che creare una grammatica con la nostra stringa di entità. Il file polyARhtml.grm contiene la seguente definizione:
S ::= "Polygen in Arabo si scrive \"" ^ ArEntities ^ "\"!";
ArEntities := "بوليجان" ;Per testare la gramamtica, aprire la riga di comando (o Shell), e digitare:
polygen polyARhtml.grm > polyARhtml.html
Abbiamo rediretto l'output generato da Polygen in un file con estensione HTML; questo ci consentirà di aprirlo con un browser. Ecco il risultato visualizzato in Chrome (zoom al 175% per una migliore lettura):
Il limite nell'uso delle entità è che queste non sono adatte a tutti i contesti. Vanno bene in documenti HTML, XML, in alcune varianti del markdown che le supportano, ma in molti contesti esse non potrebbero essere decodificate nei corrispettivi caratteri Unicode.
Quindi, il secondo metodo per generare caratteri Unicode tramite le gramamtiche Polygen consiste nel ricorrere all'UTF-8. È importante premettere, per chi già non lo sappia, che UTF-8 è un sistema di codifica di caratteri Unicode tramite sequenze di byte di lunghezza variabile. Questo vuol dire che, in UTF-8, i caratteri Ascii standard vengono rappresentati da un singolo byte — ossia, esattemente come nel formato Ascii. Questo lo rende retro-compatibile non solo con il formato Ascii, ma anche con Polygen.
All'epoca in cui fu concepito, il Polygen fu pensato per generare un output Ascii (all'epoca ancora uno standard molto diffuso, e in alcuni ambiti prevalente).
Noi sfrutteremo qui l'uso delle sequenze di Ascii escape di Polygen (ossia, \nnn) per generare le sequenze di byte richieste per rappresentare caratteri Unicode tramite codifica UTF-8.
Riprendiamo la nostra parola araba di prima, il nome del Polygen. Adesso ci serve ottenere la sequenza UTF-8 che la rappresenti. Ci avverremo a tal fine dello strumento online UTF-8 encoder/decoder, anch'esso di Mathias Bynens; ci basterà incollare il nome di Polygen in arabo nella finestra del convertitore, ed esso ci restituira la stringa di byte UTF-8:
\xD8\xA8\xD9\x88\xD9\x84\xD9\x8A\xD8\xAC\xD8\xA7\xD9\x86
Si faccia caso a come la parola araba viene decodificata in UTF-8, ciascuna lettera è ora rappresentata da due caratteri:
| AR | IT | UTF-8 | Unicode | Descrizione |
|---|---|---|---|---|
| ب | b |
\xD8+\xA8
|
U+0628 |
Arabic letter BEH |
| و | ū |
\xD9+\x88
|
U+0648 |
Arabic letter WAW |
| ل | l |
\xD9+\x84
|
U+0644 |
Arabic letter LAM |
| ي | ī |
\xD9+\x8A
|
U+064A |
Arabic letter YEH |
| ج | ǧ |
\xD8+\xAC
|
U+062C |
Arabic letter JEEM |
| ا | ē |
\xD8+\xA7
|
U+0627 |
Arabic letter ALEF |
| ن | n |
\xD9+\x86
|
U+0646 |
Arabic letter NOON |
NOTA — In UTF-8, un carattere Unicode può essere rappresentato da un numero variabile di byte (da 1 a 4). In questo esempio, tutti i caratteri impiegati sono rappresentabili tramite 2 byte, in UTF-8; tenete però conto che potreste imbattervi in casi in cui il numero di byte per carattere è diverso.
Bene, ora abbiamo la nostra sequenza di byte UTF-8, sotto forma di escape esadecimali. Però Polygen supporta solo gli escape Ascii, quindi dovremo convertire i valori da esadecimale a decimale; per farlò ci basterà la calcolatrice di Windows e un po' di pazienza:
Fatto! ecco la nostra stringa UTF-8:
\216\168\217\136\217\132\217\138\216\172\216\167\217\134
Ora siamo pronti a crare la nostra grammatica UTF-8. Il file polyARhtml.grm contiene la seguente definizione:
S ::= "Polygen in Arabo si scrive \"" ^ ArUTF8 ^ "\"!";
ArUTF8 := "\216\168\217\136\217\132\217\138\216\172\216\167\217\134" ;Per testare la gramamtica, aprire la riga di comando (o Shell), e digitare:
polygen polyARutf8.grm > polyARutf8.txt
Abbiamo rediretto l'output generato da Polygen in un file di testo con estensione .txt; questo ci consentirà di aprirlo con un editor di testo/codice moderno, che supporti UTF-8. Ecco il risultato visualizzato in Notepad++ (zoom aumentato per una migliore lettura):
NOTA — Non tutti gli editor di testo sono in grado di visualizzare correttamente le ligature delle lettere arabe. Notepad++ (un editor open source) supporta molto bene le lingue bidirezionali; molti editor (inclusi quelli commerciali) non sono altrettanto efficienti.
Ai fini didattici, in questo tutorial vi ho mostrato come convertire manualmente del testo Unicode in sequenze escape per Polygen, un passo alla volta, usando strumenti classici.
La buona notizia è che, dopo aver scritto questo tutorial, ho creato uno strumento apposito per questo scopo, il PolyEscapist.
Si tratta di un'interfaccia grafica in cui editare/incollare il testo Unicode da convertire; poi basterà cliccare sul buttone CONVERTI e ci verrà restituita una stringa UTF-8 escaped pronta ad essere usata in una grammatica Polygen:
Praticamente, questo utile strumento è in grado di fare in un singolo click ciò che vi ho appena mostrato come fare in più passaggi e utilizzando più strumenti. Ovviamente, ho conservato quest'informazione per ultimo, se no vi sareste fatti prendere dall'entusiasmo e non avreste più letto questo tutorial (mentre invece è importante capire cosa succede "sotto il cofano" del Polygen).
Per maggiori informazioni su PolyEscapist e come scaricarlo:
In questo tutorial ho scelto di proposito un'esempio Unicode in arabo, proprio perché è una delle lingue che rappresenta maggiori sfide per una corretta rappresentazione (oltre ad essere una lingua scritta da destra a sinistra, le sue ligature sono complesse). E ho altresì voluto dimostrare come sia possible generare con Polygen una produzione testuale in cui una parola araba appare nel mezzo di una frase italiana (la "sfida nella sfida", per così dire).
In questi esempi ho volutamente omesso di trattare i caratteri di controllo Unicode per il testo bidirezionale (che avrebbero solo appesantito il tutorial), ma nulla impedisce di implentarli in quei casi in cui fossero necessari per un controllo capillare della direzionalità.
In ogni caso, nella maggior parte degli scenari d'uso quotidiani, vi ritroverete a gestire caratteri Unicode che risulteranno visualizzabili dalla maggior parte delle applicazioni, senza intoppi. Inoltre, vi ritroverete a reindirizzare l'output di Polygen perlopiù verso applicazioni mirate, in grado di gestire bene l'UTF-8. Per tutti gli altri casi esistono utilità da riga di comando per la conversione tra i vari formati di codifica, in grado di filtrate il vostro output e adattarlo a ogni situazione.
Queste sono le due grammatiche utilizzate negli esempi di questo tutorial: