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 sullapplicazione
       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)