NOME

       UTF-8 - una codifica Unicode multi-byte ASCII-compatibile

DESCRIZIONE

       L'insieme  di caratteri Unicode 3.0 occupa uno spazio a 16 bit. La codifica più naturale di Unicode (nota
       come UCS-2) consta di sequenze di parole a 16 bit. Queste stringhe possono contenere  byte  come  '\0'  o
       '/', che hanno significato speciale per i nomi di file e per i parametri di altre funzioni della libreria
       C,  come  parte  di  un carattere a 16 bit. Inoltre, la maggioranza dei programmi UNIX si aspetta nomi di
       file in ASCII e, non sa leggere parole a 16 bit come caratteri senza grosse modifiche. Per queste ragioni
       UCS-2 non è una codifica esterna di Unicode adatta a nomi di file, file di  testo,  variabili  d'amiente,
       ecc. L' Insieme universale di caratteri ISO 10646 (UCS), un'estensione di Unicode, occupa addirittura uno
       spazio a 31 bit, e la sua codifica naturale, UCS-4 (una sequenza di parole a 32 bit), soffre degli stessi
       problemi.

       La  codifica  UTF-8 di Unicode e UCS evita questi problemi, ed è il modo comune nel quale Unicode è usato
       nei sistemi operativi tipo Unix.

   Proprietà
       La codifica UTF-8 possiede queste ottime proprietà:

       * i  caratteri  UCS  da  0x00000000  a  0x0000007f  (i  caratteri  US-ASCII  classici)  sono   codificati
         semplicemente  come  byte  da  0x00  a  0x7f  (compatibilità  ASCII).  In altre parole, file e stringhe
         contenenti solamente caratteri ASCII a 7 bit hanno la stessa codifica sia in ASCII che in UTF-8.

       * Tutti i caratteri UCS > 0x7f sono codificati come una sequenza a multi-byte consistente  esclusivamente
         di byte nell'intervallo da 0x80 a 0xfd, in modo tale da non trovare nessun byte ASCII all'interno di un
         altro carattere, e da non avere problemi con, tra gli altri, '\0' o '/'.

       * L'ordinamento lessicografico delle stringhe in UCS-4 viene preservato.

       * Tutti i 2^31 possibili codici UCS possono essere codificati con UTF-8.

       * I byte 0xfe e 0xff non sono mai usati nella codifica UTF-8.

       * Il  primo  byte  di  una  sequenza  multi-byte  UCS  che  rappresenta  un  carattere non ASCII è sempre
         nell'intervallo da 0xc0 a 0xfd e indica la  lunghezza  della  sequenza.  Tutti  i  byte  seguenti  sono
         nell'intervallo  da  0x80  a  0xbf,  facilitando un'eventuale risincronizzazione e facendo diventare la
         codifica senza memoria e resistente a byte mancanti.

       * I caratteri UCS codificati con UTF-8 possono arrivare ai sei byte di lunghezza,  tuttavia  lo  standard
         Unicode  non  specifica  caratteri  oltre 0x10ffff, così i caratteri Unicode possono essere lunghi solo
         fino a quattro byte in UTF-8.

   Codifica
       Le seguenti sequenze di byte vengono usate per rappresentare un carattere. La sequenza da  usare  dipende
       dal numero del codice UCS del carattere:

       0x00000000 - 0x0000007F:
           0xxxxxxx

       0x00000080 - 0x000007FF:
           110xxxxx 10xxxxxx

       0x00000800 - 0x0000FFFF:
           1110xxxx 10xxxxxx 10xxxxxx

       0x00010000 - 0x001FFFFF:
           11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

       0x00200000 - 0x03FFFFFF:
           111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

       0x04000000 - 0x7FFFFFFF:
           1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

       Le  configurazioni  di  bit  xxx  sono  riempite coi bit del numero del codice carattere rappresentato in
       binario. Viene usata solo la più breve delle sequenze multi-byte che possono rappresentare il numero  del
       codice.

       I  valori  del codice UCS 0xd800–0xdfff (surrogati UTF-16), così come 0xfffe e 0xffff (non-caratteri UCS)
       non devono apparire nei flussi UTF-8 conformi.

   Esempi
       Il carattere Unicode 0xa9 = 1010 1001 (il simbolo di copyright ©) si codifica in UTF-8 come

              11000010 10101001 = 0xc2 0xa9

       e il carattere 0x2260 = 0010 0010 0110 0000 (il simbolo «non uguale») si codifica come:

              11100010 10001001 10100000 = 0xe2 0x89 0xa0

   Note sull'applicazione
       Gli utenti devono selezionare una localizzazione UTF-8 , ad esempio con

              export LANG=en_GB.UTF-8

       per poter attivare il supporto UTF-8 nelle applicazioni.

       I software applicativi che devono riconoscere la  dofica  caratteri  usata  devono  sempre  impostare  la
       localizzazione con, ad esempio,

              setlocale(LC_CTYPE, "")

       e i programmatori possono quindi testare l'espressione

              strcmp(nl_langinfo(CODESET), "UTF-8") == 0

       per  determinare  se  una  localizzazione  UTF-8 è stata selezionata e se quindi tutti gli input e output
       standard in testo, comunicazioni terminale, contenuto in testo dei file, nomi file e variabili d'ambiente
       sono codificati in UTF-8.

       I programmatori abituati alle codifiche a singolo byte come US-ASCII o ISO 8859 devono ricordare che  due
       assunzioni  valide  qui non sono più valide nelle localizzazioni UTF-8 . Innanzitutto un singolo byte non
       corrisponde necessariamente più ad un singolo carattere. In secondo luogo,  poiché  i  moderni  emulatori
       terminale  in modalità UTF-8 supportano anche caratteri a doppia larghezza cinese, giapponese e coreano e
       i caratteri combinanti, non spaziati, l'emissione di un singolo carattere non avanza  necessariamente  il
       cursore  di  una  posizione  come avveniva in ASCII. Funzioni di libreria come mbsrtowcs(3) e wcswidth(3)
       oggi devono essere usate posizioni di caratteri e cursore.

       La sequenza ufficiale ESC per commutare da uno  schema  di  codifica  ISO  2022  (usato  ad  esempio  dai
       terminali  VT100) a UTF-8 è ESC % G ("\x1b%G"). La corrispondente sequenza di ritorno da UTF-8 a ISO 2022
       è ESC % @ ("\x1b%@"). Altre sequenze ISO 2022 (come quelle per commutare gli insiemi G0 e  G1)  non  sono
       applicabili in modalità UTF-8.

       Si può sperare che nel futuro UTF-8 sostituirà ASCII e ISO 8859 a tutti i livelli come codifica caratteri
       comune  nei  sistemi POSIX, portando così ad un ambiente significativamente più ricco per la gestione del
       testo.

   Sicurezza
       Gli standard Unicode and UCS richiedono che i produttori di  UTF-8  debbano  usare  la  forma  più  breve
       possibile,  ad  es.  produrre  una sequenza a due byte con primo byte 0xc0 non è conforme. Unicode 3.1 ha
       aggiunto la richiesta che i programmi confori non debbano accettare le forme non brevi  nel  loro  input.
       Ciò  è per ragioni di sicurezza: se l'input utente è verificato per possibili violazioni di sicurezza, un
       programma può verificare solo la versione ASCII di "/../" o ";" o NUL e dimenticare  che  ci  sono  motli
       modi non-ASCII di rappresentare queste cose in una codifica UTF-8 non breve.

   Standard
       ISO/IEC 10646-1:2000, Unicode 3.1, RFC 2279, Plan 9.

AUTORE

       Markus Kuhn <mgk25@cl.cam.ac.uk>

VEDERE ANCHE

       nl_langinfo(3), setlocale(3), charsets(7), unicode(7)

GNU                                              11 maggio 2001                                         UTF-8(7)