NOME

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

DESCRIZIONE

       The  Unicode 3.0 character set occupies a 16-bit code space.  The most obvious Unicode encoding (known as
       UCS-2)  consists of a sequence of 16-bit  words.   Such  strings  can  contain—as  part  of  many  16-bit
       characters—bytes  such  as  '\0'  or  '/',  which have a special meaning in filenames and other C library
       function arguments.  In addition, the majority of UNIX tools expect ASCII files  and  can't  read  16-bit
       words  as  characters  without  major modifications.  For these reasons, UCS-2 is not a suitable external
       encoding of Unicode in filenames, text files, environment variables, and so on.  The ISO 10646  Universal
       Character  Set  (UCS),  a superset of Unicode, occupies an even larger code space—31 bits—and the obvious
       UCS-4 encoding for it (a sequence of 32-bit words) has the same problems.

       La codifica UTF-8 di Unicode e UCS evita questi problemi, ed è il modo comune con cui 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.

       * All  UCS  characters  greater than 0x7f are encoded as a multibyte sequence consisting only of bytes in
         the range 0x80 to 0xfd, so no ASCII byte can appear as part of  another  character  and  there  are  no
         problems with, for example, '\0' or '/'.

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

       * All possible 2^31 UCS codes can be encoded using UTF-8.

       * I byte  0xc0, 0xc1, 0xfe E 0xff non sono mai usati nella codifica UTF-8.

       * Il  primo  byte  di  una  sequenza  multibyte  che  rappresenta  un  carattere  UCS  non ASCII è sempre
         nell'intervallo da 0xc0 a 0xfd e indica la lunghezza  della  sequenza.  Tutti  i  byte  seguenti  nella
         sequenza  multibyte  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, prima il bit più significativo (big-endian). Viene  usata  solo  la  più  breve  delle  sequenze
       multibyte che possono rappresentare il numero del codice.

       The  UCS  code  values 0xd800–0xdfff (UTF-16 surrogates) as well as 0xfffe and 0xffff (UCS noncharacters)
       should not appear in conforming UTF-8 streams.  According to RFC 3629 no point above U+10FFFF  should  be
       used, which limits characters to four bytes.

   Esempio
       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  codica 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 più necessariamente ad un singolo carattere. In secondo luogo, poiché i moderni emulatori  di
       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.

   Sicurezza
       Gli  standard  Unicode  e  UCS  richiedono  che  i  produttori  di UTF-8 debbano usare la forma più breve
       possibile, ad esempio produrre una sequenza a due byte con primo byte 0xc0 non è conforme. Unicode 3.1 ha
       aggiunto  la  richiesta che i programmi conformi 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 molti
       modi non- ASCII di rappresentare queste cose in una codifica UTF-8 non breve.

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

VEDERE ANCHE

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

TRADUZIONE

       La  traduzione  italiana  di  questa  pagina  di  manuale  è   stata   creata   da   Ottavio   G.   Rizzo
       <rizzo@pluto.linux.it>,  Giulio  Daprelà <giulio@pluto.it>, Elisabetta Galli <lab@kkk.it> e Marco Curreli
       <marcocurreli@tiscali.it>

       Questa  traduzione  è  documentazione  libera;  leggere  la  GNU  General  Public  License   Versione   3
       ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  o  successiva  per  le  condizioni  di  copyright.   Non  ci
       assumiamo alcuna responsabilità.

       Per segnalare errori nella traduzione di  questa  pagina  di  manuale  inviare  un  messaggio  a  ⟨pluto-
       ildp@lists.pluto.it⟩.