NOME

NOME

perluniintro - introduzione a Unicode in Perl

DESCRIZIONE

Questo documento fornisce un'idea generale di Unicode e di come usarlo in Perl.

Unicode

Unicode è uno standard per la codifica dei caratteri che progetta di codificare tutti i metodi di scrittura del mondo, e molti altri simboli ancora.

Unicode e ISO/IEC 10646 sono due standard coordinati che forniscono ``code point'' per ciascun carattere di praticamente tutti gli standard di codifica carattere moderni, coprendo oltre 30 sistemi di scrittura e centinaia di linguaggi, inclusi tutti i linguaggi moderni di importanza commerciale. Sono codificati anche tutti i caratteri dei voluminosi dizionari cinesi, giapponesi e coreani. Lo standard arriverà a coprire sostanzialmente tutti i caratteri di oltre 250 sistemi di scrittura e di migliaia di linguaggi. Unicode 1.0 è stato rilasciato in Ottobre 1991, e la 4.0 in Aprile 2003.

Un carattere Unicode è un'entità astratta. Non è limitato da alcuna particolare dimensione dei tipi interi, in particolare non è limitato al char del linguaggio C. Unicode è indipendente dal linguaggio e dall'aspetto grafico: non codifica la lingua del testo e non definisce font o altri dettagli di rappresentazione grafica. Unicode si occupa di caratteri e di testi composti da tali caratteri.

Unicode definisce caratteri come LATIN CAPITAL LETTER A (``lettera A latina maiuscola'', NdT), o GREEK SMALL LETTER ALPHA (``lettera alpha greca minuscola'', NdT), e numeri univoci per tali caratteri, in questo caso 0x0041 e 0x03B1, rispettivamente. Questi numeri univoci sono chiamati code point (``punti codice'', NdT).

Lo standard Unicode preferisce usare la notazione esadecimale per i code point. Se numeri come 0x0041 vi sono poco familiari, date un'occhiata alla sezione Notazione esadecimale, più sotto. Lo standard Unicode usa la notazione U+0041 LATIN CAPITAL LETTER A, per indicare il code point esadecimale e il nome normativo del carattere.

Unicode definisce altresì svariate proprietà dei caratteri, come ``maiuscolo'' o ``minuscolo'', ``cifra decimale'', o ``punteggiatura''; queste proprietà sono indipendenti dal nome dei caratteri. Inoltre, alcune operazioni sui caratteri, come conversioni tra maiuscole e minuscole, e ``collazione'' (ordinamento), sono definite dallo standard.

Un carattere Unicode può cosistere di un singolo code point, oppure di un carattere base (ad esempio LATIN CAPITAL LETTER A), seguito da uno o più modificatori (ad esempio COMBINING ACUTE ACCENT ``accento acuto da combinare''). Questa sequenza di carattere base e modificatori viene chiamata sequenza di caratteri combinati (``combining character sequence'' in inglese, NdT).

Se chiamare o no queste sequenze ``caratteri'' dipende dal vostro punto di vista. Se siete un programmatore, probabilmente tenderete a vedere ciascun elemento della sequenza come una unità distinta, o ``carattere''. D'altro canto, l'intera sequenza può essere vista come ``carattere'' dal punto di vista dell'utente, poiché probabilmente viene considerata tale nel contesto della sua lingua.

Secondo questa visione dei caratteri come ``l'intera sequenza'', il numero totale di caratteri è un concetto poco chiaro. Ma nell'idea del programmatore, ``ciascuna unità è un carattere'', il concetto di ``carattere'' è molto più deterministico. In questo documento, assumiamo questo secondo punto di vista: un ``carattere'' è un code point Unicode, sia un carattere base o un carattere da combinare.

Per alcune combinazioni, esistono caratteri precombinati. LATIN CAPITAL LETTER A WITH ACUTE (``lettera A latina maiuscola con accento acuto'', NdT), ad esempio, è definito come singolo code point. Questi caratteri precombinati, comunque, esistono solo per alcune combinazioni, e sono previsti principalmente per supportare conversioni avanti-e-indietro tra Unicode e standard precedenti (come ad esempio i vari ISO 8859). Nel caso generale, il metodo di composizione è più estendibile. Per supportare conversioni tra i vari modi di comporre i caratteri, sono state definite varie forme di normalizzazione (``normalization forms'' in inglese, NdT) per produrre rappresentazioni uniformi.

Per mantenere la compatibilità con le codifiche precedenti, l'idea di ``un numero unico per ciascun carattere'' non si realizza del tutto: invece, c'è ``almeno un numero per ciascun carattere''. Lo stesso carattere potrebbe essere rappresentato in modo diverso in diverse codifiche. Neppure l'inverso è sempre vero: alcuni code point non hanno un corrispondente carattere assegnato. In primo luogo, esistono code point non allocati all'interno di blocchi altrimenti usati. In secondo luogo, ci sono speciali caratteri di controllo Unicode che non rappresentano veri e propri ``caratteri''.

Un'idea diffusa relativamente a Unicode sostiene che sia ``a 16 bit'', ovvero, che Unicode sia rappresentato da 0x10000 (ovvero 65536) caratteri, da 0x0000 a 0xFFFF. Ciò è falso. > A partire dalla versione 2.0 (Luglio 1996), Unicode è stato definito fino a 21 bit (0x10FFFF), e dalla versione 3.1 (Marzo 2001) sono stati definiti caratteri oltre 0xFFFF. I primi 0x10000 caratteri sono chiamati il Piano 0, o Basic Multilingual Plane (BMP). Con Unicode 3.1, sono definiti in totale 17 piani, anche se ancora non sono affatto pieni di caratteri definiti.

Un'altra idea diffusa è che i blocchi di 256 caratteri abbiamo qualcosa a che vedere con le lingue -- che ciascun blocco definisca i caratteri usati in una lingua o insieme di lingue. Neanche questo è vero. > La divisione in blocchi esiste, ma è quasi del tutto accidentale -- un effetto collaterale del modo con cui i caratteri sono stati, e sono ancora, allocati. Invece, esiste il concetto di script, che è molto più utile: c'è lo script Latin, lo script Greek, et cetera. Gli script di solito coprono varie parti di diversi blocchi. Per maggiori informazioni, leggete the Unicode::UCD manpage.

I code point Unicode sono soltanto numeri, astratti. Per essere comunicati, questi numeri devono essere codificati (``encoded'' in inglese, NdT) o serializzati in qualche modo. Unicode definisce svariate forme di codifica dei caratteri, di cui UTF-8 è forse la più nota. UTF-8 è una codifica a lunghezza variabile che rappresenta i caratteri Unicode come sequenze da 1 a 6 byte (se ci si limita ai caratteri attualmente definiti ne bastano 4). Altre codifiche sono UTF-16 e UTF-32, e le loro varianti big-endian e little-endian (UTF-8 è invariante). Lo standard ISO/IEC 10646 definisce le forme UCS-2 e UCS-4.

Per ulteriori informazioni sulle codifiche -- ad esempio, per sapere cosa sono i surrogati e i byte order marks (BOM) -- leggete the perlunicode manpage.

Il supporto Unicode in Perl

A partire da Perl 5.6.0, Perl ha avuto la capacità di gestire nativamente Unicode. Ad ogni modo, Perl 5.8.0 è la minima versione raccomandata per lavorare seriamente con Unicode. La versione di manutenzione 5.6.1 ha corretto molti dei problemi della prima implementazione di Unicode, ma ad esempio le espressioni regolari ancora non funzionano con Unicode nella 5.6.1.

A partire da Perl 5.8.0, l'uso di use utf8 non è più necessario. > In versione precedenti la direttiva utf8 era usata per dichiarare che le operazioni del blocco o file corrente avrebbero dovuto tener conto di Unicode. Si è scoperto che questo modello era sbagliato, o quantomeno scomodo: la ``Unicodità'' è ora associata ai dati, anziché alle operazioni. Resta solo un caso in cui serve un esplicito use utf8: se il vostro stesso script Perl è codificato in UTF-8, potete usare caratteri Unicode negli identificatori, nelle costanti stringa e nelle espressioni regolari, scrivendo use utf8. Questo non è il comportamento predefinito perché script salvati in altre codifiche a 8 bit (ad esempio ISO 8859-1) provocherebbero errori. Cfr. the utf8 manpage.

Il modello Unicode di Perl

Perl supporta sia stringhe di caratteri nativi a 8 bit, come prima della 5.6, che stringhe di caratteri Unicode. Il principio è che Perl tenta di mantenere i dati come byte più a lungo possibile, ma quando non è più possibile evitare la ``Unicodità'', i dati vengono automaticamente convertiti in Unicode.

Internamente, al momento, Perl usa la codifica a 8 bit nativa della piattaforma (ad esempio Latin-1), qualunque essa sia, usando UTF-8 per codificare le stringhe Unicode. In particolare, se tutti i code point nella stringa sono minori di 0xFF, Perl usa la codifica a 8 bit nativa. Altrimenti usa UTF-8.

Un utente di Perl normalmente non deve preoccuparsi di come Perl codifichi internamente le stringhe, ma ciò diventa rilevante quando si scrivono stringhe Unicode in un canale (``stream'', NdT) senza uno strato PerlIO -- un canale con la codifica predefinita. In questo caso, i byte della codifica interna (quella nativa, o UTF-8, a seconda della stringa), vengono usati pari pari, e verrà emesso un avvertimento di ``Wide character'' se tali stringhe contengono caratteri oltre 0xFF.

Ad esempio,

      perl -e 'print "\x{DF}\n", "\x{0100}\x{DF}\n"'

produce una mistura piuttosto inutile di byte in codifica nativa e UTF-8, oltre che un avvertimento:

     Wide character in print at ...

Per emettere UTF-8, usate lo strato :utf8. Inserendo

      binmode(STDOUT, ":utf8");

prima di print in questo programma di esempio ci si assicura che l'output sia interamente UTF-8, e si elimina l'avvertimento.

Potete abilitare l'interpretazione automatica in UTF-8 dei filehandle standard e di @ARGV, e l'uso di UTF-8 come strato implicito nelle open(), fornendo il parametro a linea di comando -C o la variabile d'ambiente PERL_UNICODE; leggete the perlrun manpage per la documentazione del parametro -C.

Notare che ciò implica che Perl si aspetta che tutti gli altri programmi facciano altrettanto: se Perl è portato a credere che STDIN sia in UTF-8, ma i dati che arrivano da un altro programma su STDIN non sono in UTF-8, Perl si lamenterà che gli sta arrivando UTF-8 malformato.

Tutte le funzionalità che combinano Unicode e I/O richiedono l'uso della nuova caratteristica PerlIO. Praticamente tutte le piattaforme di Perl 5.8, comunque, usano PerlIO: potete controllare se la vostra lo usa eseguendo ``perl -V'' e cercando ``useperlio=define''.

Unicode e EBCDIC

Perl 5.8.0 supporta Unicode anche sulle piattaforme EBCDIC. Su di esse, il supporto Unicode è alquanto più complesso da implementare poiché sono nessarie conversioni aggiuntive a ogni passo. Restano alcuni problemi, leggete the perlebcdic manpage per i dettagli.

Ad ogni modo, il supporto Unicode sulle piattaforme EBCDIC è migliore che nella serie 5.6, che in pratica non funzionava affatto. Sulle piattaforme EBCDIC la codifica interna è UTF-EBCDIC, anziché UTF-8. La differenza sta nel fatto che, come UTF-8 è ``ASCII-safe'' nel senso che i caratteri ASCII hanno una codifica identica in UTF-8, UTF-EBCDIC è ``EBCDIC-safe''.

Creare Unicode

Per creare caratteri Unicode nelle costanti per code point oltre 0xFF, usate la notazione \x{...} all'interno di stringhe con virgolette doppie:

    my $sorriso = "\x{263a}";

Potete fare altrettanto nelle espressioni regolari costanti:

    $sorriso =~ /\x{263a}/;

A tempo di esecuzione potete usare chr():

    my $alef_ebraica = chr(0x05d0);

Leggete le Ulteriori risorse per sapere come trovare tutti questi codici numerici.

Naturalmente, ord() esegue l'operazione inversa: trasforma un carattere in un code point.

Notate che \x.. (senza {} e con solo due cifre esadecimali), \x{...} e chr(...) con argomenti minore di 0x100 (256 in decimale) producono caratteri a 8 bit per compatibilità all'indietro con versioni precedenti di Perl. Per argomenti maggiori o uguali a 0x100, vengono sempre prodotti caratteri Unicode. Se volete forzare la produzione di caratteri Unicode indipendentemente dal valore numerico, usate pack("U", ...) anziché \x.., \x{...} e chr().

Potete anche usare la direttiva charnames per chiamare i caratteri per nome nelle stringhe con virgolette doppie:

    use charnames ':full';
    my $alef_araba = "\N{ARABIC LETTER ALEF}";

E, come detto prima, potete usare pack() per convertire numeri in caratteri Unicode:

   my $an_georgiana  = pack("U", 0x10a0);

Notate che sia \x{...} che \N{...} sono costanti stringa risolte a tempo di compilazione: non potete metterci dentro delle variabili. Se volete funzionalità simili a tempo di esecuzione, usate chr() e charnames::vianame().

Se volete forzare la produzione di caratteri Unicode, usate lo speciale prefisso "U0". Non consuma argomenti, ma forza il risultato ad essere composto di caratteri Unicode, anziché di byte:

   my $caratteri = pack("U0C*", 0x80, 0x42);

Allo stesso modo, potete forzare la produzione di byte usando lo speciale prefisso "C0".

Gestire Unicode

Nella maggior parte dei casi, gestire Unicode è trasparente: usate semplicemente le stringhe come sempre. Funzioni come index(), length() e substr() lavorano sui caratteri Unicode, così come le espressioni regolari (leggete the perlunicode manpage e the perlretut manpage).

Ricordate che Perl considera i componenti delle sequenze di caratteri combinati come caratteri separati, per cui ad esempio

    use charnames ':full';
    print length("\N{LATIN CAPITAL LETTER A}\N{COMBINING ACUTE ACCENT}"), "\n";

scriverà 2, non 1. L'unica eccezione è che le espressioni regolari hanno \X che fa match con una sequenza di caratteri combinati.

La gestione non è proprio così trasparente, ad ogni modo, quando si lavora con altre codifiche, I/O, e alcuni casi speciali.

Altre codifiche

Quando combinate dati Unicode e dati in codifiche precedenti, questi ultimi devono essere trasformati in Unicode. Normalmente viene assunto che i dati non-Unicode siano codificati secondo ISO 8859-1 (o EBCDIC, sulle opportune piattaforme). Potete aggirare questa assunzione usando la direttiva encoding, ad esempio:

    use encoding 'latin2'; # ISO 8859-2

nel qual caso le costanti (stringhe o espressioni regolari), chr() e ord() in tutto il vostro script produrranno caratteri Unicode a partire da code point in ISO 8859-2. Notate che la corrispondenza dei nomi delle codifiche è lasca: invece che latin2 potreste aver scritto Latin 2 o iso8859-2, o altre varianti. Dicendo soltanto

    use encoding;

la codifica viene estratta dalla variabile di ambiente PERL_ENCODING. Se tale variabile non è impostata, la direttiva fallirà.

Il modulo Encode sa trattare molte codifiche e fornisce interfacce per convertire tra tali codifiche:

    use Encode 'decode';
    $data = decode("iso-8859-3", $data); # converte da latin-3 a utf-8

I/O in Unicode

Normalmente, scrivendo su file dati Unicode

    print FH $qualche_stringa_in_unicode, "\n";

si ottengono i byte che Perl usa internamente per rappresentare la stringa Unicode. La codifica interna del Perl dipende sia dal sistema che da quali caratteri sono presenti al momento nella stringa. Se qualcuno dei caratteri ha code point 0x100 o maggiore, otterrete un avvertimento. Per essere sicuri che l'output venga prodotto nella codifica che volete -- ed evitare gli avvertimenti -- aprite il canale specificando la codifica. Alcuni esempi:

    open FH, ">:utf8", "file";
    open FH, ">:encoding(ucs2)",      "file";
    open FH, ">:encoding(UTF-8)",     "file";
    open FH, ">:encoding(shift_jis)", "file";

e su canali già aperti, usate binmode():

    binmode(STDOUT, ":utf8");
    binmode(STDOUT, ":encoding(ucs2)");
    binmode(STDOUT, ":encoding(UTF-8)");
    binmode(STDOUT, ":encoding(shift_jis)");

La corrispondenza dei nomi di codifica è lasca: maiuscole e minuscole sono uguali, e molte codifiche hanno svariati sinonimi. Notare che lo strato :utf8 deve essere sempre specificato esattamente in quel modo; non viene trattato come gli altri nomi di codifica.

Leggete the PerlIO manpage per lo strato :utf8, the PerlIO::encoding manpage e the Encode::PerlIO manpage per lo strato :encoding(), e the Encoding::Supported manpage per le tante codifiche supportate dal modulo Encode.

Leggere da un file di cui conoscete la codifica non trasforma magicamente i dati in Unicode per quanto riguarda Perl. Per farlo, specificato l'opportuno strato all'apertura del file:

    open(my $fh,'<:utf8', 'file_in_utf8');
    my $linea_in_unicode = <$fh>;
    open(my $fh,'<:encoding(Big5)', 'file_in_Big5');
    my $linea_in_unicode = <$fh>;

Gli strati di I/O possono essere anche specificati con la direttiva open. Leggete the open manpage, o analizzate l'esempio seguente.

    use open ':utf8'; # gli strati di input e output di default saranno UTF-8
    open X, ">file";
    print X chr(0x100), "\n";
    close X;
    open Y, "<file";
    printf "%#x\n", ord(<Y>); # dovrebbe scrivere 0x100
    close Y;

Con la direttiva open potete usare lo strato :locale

    BEGIN { $ENV{LC_ALL} = $ENV{LANG} = 'ru_RU.KOI8-R' } 
    # :locale controllera` le variabili di ambiente come LC_ALL
    use open OUT => ':locale'; # russki parusski
    open(O, ">koi8");
    print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
    close O;
    open(I, "<koi8");
    printf "%#x\n", ord(<I>), "\n"; # dovrebbe scrivere 0xc1
    close I;

oppure potete usare anche lo strato :encoding(...)

    open(my $epic,'<:encoding(iso-8859-7)','iliad.greek');
    my $linea_in_unicode = <$epic>;

Questi metodi installano un filtro trasparente sui canali di I/O che converte i dati dalla codifica specificata quando vengono letti dal canale. Il risultato è sempre in Unicode.

La direttiva the open manpage influisce su tutte le chiamate a open() dopo la direttiva, impostando gli strati di default. Se volete influenzare solo certi canali, usate gli strati esplicitamente nella chiamata a open().

Potete cambiare la codifica di un canale già aperto usando binmode; leggete binmode in the perlfunc manpage.

Lo strato :locale al momento (Perl 5.8.0) non fusnziona con open() e binmode(), solo con la direttiva open. Gli strati :utf8 e :encoding(...) funzionano con tutte, open(), binmode() e la direttiva open.

In modo analogo, potete usare questi strati di I/O sui canali di uscita per convertire automaticamente Unicode nelle codifiche specificate quando i dati vengono scritti sul canale. Ad esempio, il frammento seguente copia il contenuto del file ``testo.jis'' (codificato secondo ISO 2022-JP, noto anche come JIS) nel file ``testo.utf8'', codificato in UTF-8:

    open(my $nihongo, '<:encoding(iso-2022-jp)', 'testo.jis');
    open(my $unicode, '>:utf8',                  'testo.utf8');
    while (<$nihongo>) { print $unicode $_ }

La denominazione delle codifiche, sia per open() che per la direttiva open, è analoga a quella della direttiva encoding in quanto permette di usare sinonimi: koi8-r e KOI8R verranno riconosciuti entrambi.

Vengono riconosciute molte codifiche comuni definite da ISO, MIME, IANA e svariate altre organizzazioni di standard; per un'elenco più dettagliato leggere the Encode::Supported manpage.

read() legge caratteri e restituisce il numero di caratteri. seek() e tell() lavorano contando i byte, così pure sysread() e sysseek().

Fate attenzione che, a causa del fatto che non viene effettuata alcuna conversione in lettura se non c'è nessuno strato di default, è facile sbagliarsi e scrivere codice che continua ad allungare un file codificando ripetutamente i dati:

    # ATTENZIONE CODICE SBAGLIATO
    open F, "file";
    local $/; ## legge l'intero file come caratteri a 8 bit
    $t = <F>;
    close F;
    open F, ">:utf8", "file";
    print F $t; ## scrive convertendo in UTF-8
    close F;

Se eseguite questo codice due volte, il contenuto del file verrà codificato in UTF-8 due volte. Si può evitare il problema scrivendo use open ':utf8', oppure aprendo esplicitamente il file in lettura in UTF-8.

NOTA: :utf8 e :encoding funzionano solo se il vostro interprete Perl è stato compilato con le nuove funzionalità PerlIO (che vengono compilate di default nella maggior parte dei sistemi).

Mostrare Unicode Come Testo

Certe volte potreste voler mostrare scalari Perl contenenti Unicode come semplice testo ASCII (o EBCDIC). La subroutine seguente converte i suoi argomenti in modo che i caratteri Unicode con code point maggiore di 255 vengano mostrati come \x{...}, i caratteri di controllo (come \n) vengano mostrati come \x.., e gli altri caratteri non subiscano trasformazioni:

   sub nice_string {
       join("",
         map { $_ > 255 ?                  # se carattere esteso...
               sprintf("\\x{%04X}", $_) :  # \x{...}
               chr($_) =~ /[[:cntrl:]]/ ?  # altrimenti, se controllo...
               sprintf("\\x%02X", $_) :    # \x..
               quotemeta(chr($_))          # altrimenti identici
         } unpack("U*", $_[0]));           # unpack caratteri Unicode
   }

Ad esempio,

   nice_string("foo\x{100}bar\n")

restituisce la stringa:

   'foo\x{0100}bar\x0A'

pronta per essere stampata.

Casi Particolari

Argomenti avanzati

Varie

Domande e risposte

Notazione esadecimale

Lo standard Unicode preferisce usare la notazione esadecimale perché mostra più chiaramente la divisione dei code point in blocchi da 256. L'esadecimale è anche più breve del decimale. Potete anche usare la notazione decimale, ma imparando a usare l'esadecimale farete molta meno fatica con lo standard Unicode. La notazione U+HHHH, ad esempio, è in esadecimale.

Il prefisso 0x indica un numero esadecimale, le cifre sono 0-9 e a-f (o A-F, non fa differenza). Ciascuna cifra rappresenta quattro bit, ovvero mezzo byte. print 0x..., "\n" mostra numeri esadecimali in decimale, e printf "%x\n",$decimale fa l'inverso. Se avete solo le ``cifre esadecimali'' di un numero, potete usare la funzione hex().

    print 0x0009, "\n";    # 9
    print 0x000a, "\n";    # 10
    print 0x000f, "\n";    # 15
    print 0x0010, "\n";    # 16
    print 0x0011, "\n";    # 17
    print 0x0100, "\n";    # 256
    print 0x0041, "\n";    # 65
    printf "%x\n",  65;    # 41
    printf "%#x\n", 65;    # 0x41
    print hex("41"), "\n"; # 65

Ulteriori risorse

UNICODE IN PERL PRECEDENTI

Se non potete aggiornare a Perl 5.8.0 o successivi, potete comunque fare un po' di elaborazione Unicode usando i moduli Unicode::String, Unicode::Map8, e Unicode::Map, disponibili da CPAN. Se avete installato il programma GNU recode, potete anche usare il modulo Convert::Recode per le conversioni tra codifiche.

Queste sono rapide conversioni da byte ISO 8859-1 (Latin-1) a byte UTF-8 e viceversa. Il codice funziona anche con versioni precedenti di Perl 5.

    # da ISO 8859-1 a UTF-8
    s/([\x80-\xFF])/chr(0xC0|ord($1)>>6).chr(0x80|ord($1)&0x3F)/eg;
    # da UTF-8 a ISO 8859-1
    s/([\xC2\xC3])([\x80-\xBF])/chr(ord($1)<<6&0xC0|ord($2)&0x3F)/eg;

VEDI ANCHE

the perlunicode manpage, the Encode manpage, the encoding manpage, the open manpage, the utf8 manpage, the bytes manpage, the perlretut manpage, the perlrun manpage, the Unicode::Collate manpage, the Unicode::Normalize manpage, the Unicode::UCD manpage

RINGRAZIAMENTI

Grazie ai gentili lettori delle liste perl5-porters@perl.org, perl-unicode@perl.org, linux-utf8@nl.linux.org, e unicore@unicode.org per i loro preziosi commenti.

AUTORE, COPYRIGHT, E LICENZA

Copyright 2001-2002 Jarkko Hietaniemi <jhi@iki.fi>

Questo documento può essere distribuito secondo gli stessi termini del Perl.

TRADUZIONE

Versione

La versione su cui si basa questa traduzione è ottenibile con:

   perl -MPOD2::IT -e print_pod perlfaq7

Per maggiori informazioni sul progetto di traduzione in italiano si veda http://pod2it.sourceforge.net/ .

Traduttore

Traduzione a cura di Gianni Ceccarelli.

Revisore

Revisione a cura di Michele Beltrame.

 NOME