Provided by: manpages-it_2.80-3_all bug

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)