index | project | pods | responsabili

NOME

perlrun - come eseguire l'interprete Perl


SINOSSI

perl-sTtuUWX ] [ -hv ] [ -V[:variabilediconfigurazione] ] [ -cw ] [ -d[t][:debugger] ] [ -D[numero/lista] ] [ -pna ] [ -Fmodello ] [ -l[ottale] ] [ -0[ottale/esadecimale] ] [ -Idir ] [ -m[-]modulo ] [ -M[-]'modulo...' ] [ -f ] [ -C [numero/lista] [ -P ] [ -S ] [ -x[dir] ] [ -i[estensione] ] [ -e 'comando' ] [ -- ] [ filedelprogramma ] [ argomento ]...


DESCRIZIONE

Il modo consueto di eseguire un programma Perl è quello di renderlo direttamente eseguibile, oppure passando il nome del file sorgente come un argomento sulla linea di comando. (È anche possibile un ambiente Perl che sia interattivo--si veda perldebug per i dettagli sul modo di farlo). In fase di avvio, Perl cerca il vostro programma in uno dei seguenti posti:

  1. Specificato linea per linea tramite il parametro -e sulla linea di comando.

  2. Contenuto nel file specificato dal primo nome del file sulla linea di comando. (Va notato che sistemi che supportano la notazione #! invocano l'interprete in questo modo. Si veda La posizione di Perl).

  3. Passato implicitamente attraverso lo standard input. Questo funziona solamente se non ci sono nomi di file come argomento -- per passare argomenti ad un programma che legge da STDIN dovete specificare esplicitamente un ``-'' per il nome del programma.

Con i metodi 2 e 3, Perl inizia a fare il parsing del file di input dall'inizio, a meno che non si abbia specificato uno switch -x, nel qual caso cerca la prima linea che inizia con #! e che contiene la parola ``perl'', e quindi inizia da lì. Questo è utile per eseguire un programma integrato in un messaggio più ampio. (In questo caso si indicherebbe la fine del programma utilizzando il simbolo __END__).

La linea #! viene comunque esaminata per trovare dei parametri durante il parsing della linea stessa. Quindi, se si è su una macchina che permette solamente un argomento con la linea #!, o peggio ancora, se nemmeno riconosce la linea #!, si può ancora ottenere un comportamento coerente con i parametri, senza curarsi di come Perl sia stato invocato, anche se per trovare l'inizio del programma è stato utilizzato -x.

Dato che storicamente alcuni sistemi operativi tagliano silenziosamente fuori l'interpretazione della linea #! da parte del kernel dopo i 32 caratteri, alcuni parametri potrebbero esser passati sulla linea di comando e altri no; si potrebbe anche ottenere un ``-'' senza l'opzione ad esso associata, se non si fa attenzione. Probabilmente si vuole essere sicuri che tutti i parametri ricadano o prima o dopo il limite dei 32 caratteri. Molti parametri non tengono conto del fatto di essere processati in maniera ridondante, ma ottenere un ``-'' invece di un parametro completo potrebbe far sì che Perl cerchi di eseguire lo standard input invece del programma. E un parametro parziale come -I potrebbe anch'esso causare dei risultati bizzarri.

Alcuni parametri tengono conto del fatto di essere stati processati due volte, per esempio combinazioni di -l e -0. Quindi o si mettono tutti i parametri dopo il limite dei 32 caratteri (se possibile), oppure si rimpiazza l'uso di -0cifre con BEGIN{ $/ = "\0cifre"; }.

Il parsing del parametro #! inizia ovunque ``perl'' venga menzionato nella linea. Le sequenze ``-*'' e ``- '' sono specificatamente ignorate così che si possa, se si fosse così inclini a farlo, dire

    #!/bin/sh -- # -*- perl -*- -p
    eval 'exec perl -wS $0 ${1+"$@"}'
        if $in_esecuzione_in_una_qualche_shell;

permette che Perl veda il parametro -p.

Un trucco simile coinvolge il programma env, se lo si ha.

    #!/usr/bin/env perl

Gli esempi qui sopra usano un percorso relativo all'interprete perl, ottenendo qualsiasi versione compaia per prima nel path dell'utente [``percorso nel quale vengono cercati i file eseguibili'', NdT]. Se si vuole una specifica versione di Perl, diciamo, perl5.005_57, si dovrebbe posizionarlo direttamente nel path della linea #!.

Se la linea #! non contiene la parola ``perl'', invece dell'interprete Perl viene eseguito il programma chiamato dopo la #!. Questo è un po' bizzarro, ma aiuta le persone su macchine in cui non funziona #!, perché possono dire al programma che la loro SHELL è /usr/bin/perl, e quindi Perl invierà il programma all'interprete corretto.

Dopo aver localizzato il programma, Perl lo compila in un formato interno. Se ci sono degli errori di compilazione, l'esecuzione del programma non viene tentata. (Questo è diverso dal tipico comportamento di uno script shell, il quale potrebbe essere in parte eseguito prima di trovare un errore di sintassi).

Se il programma è sintatticamente corretto, viene eseguito. Se il programma viene eseguito fino alla fine senza incontrare un operatore exit() o die(), viene fornito implicitamente un exit(0) per indicare un completamento con successo.

#! e il quoting su sistemi non-Unix

La tecnica #! usata in Unix può essere simulata in altri sistemi:

OS/2
Si metta
    extproc perl -S -i_parametri

come prima linea nei file *.cmd (-S a causa di un bug nella gestione di 'extproc' da parte di cmd.exe).

MS-DOS
Si crei un file batch per eseguire il programma, e lo si codifichi in ALTERNATE_SHEBANG (per maggiori informazioni, si dia un'occhiata al file dosish.h nella distribuzione sorgente).

Win95/NT
L'installazione in Win95/NT, quando si utilizza l'installatore ActiveState per Perl, modificherà il registro di Windows per associare l'estensione .pl con l'interprete perl. Se si installa Perl con altri intenti (incluso il compilarlo da sorgenti), si potrebbe dover modificare da soli il registro di sistema. Va notato che ciò significa che non si può più dire quale sia la differenza tra un programma eseguibile Perl e una libreria Perl.

Macintosh
Sotto il MacOS ``classico'', un programma perl avrà il Creator e il Type appropriati, così che facendoci doppio click, invocheranno l'applicazione MacPerl. Sotto Mac OS X, le applicazioni cliccabili possono essere fatte da un qualsiasi script del tipo #! usando DropScript, l'utility di Wil Sanchez: http://www.wsanchez.net/software/ .

VMS
Si metta
    $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
    $ exit++ + ++$stato != 0 and $exit = $stato = undef;

in cima al programma, dove -mysw sono qualasiasi parametri da linea di comando si vogliano passare a Perl. Ora si può invocare il programma direttamente, dicendo perl programma, o come una procedura DCL, dicendo @programma (o implicitamente via DCL$PATH utilizzando semplicemente il nome del programma).

Questo incantesimo è un po' troppo per essere ricordato, ma Perl lo mostrerà se si digita perl "-V:startperl".

Gli interpreti su sistemi non-Unix hanno delle idee piuttosto differenti sul come quotare rispetto alle shell Unix. Si avrà bisogno di imparare i caratteri speciali dell'interprete (*, \ e " sono comuni), come proteggere gli spazi bianchi e quei caratteri per eseguire i programmi su singola linea [oneliner, NdT] (si veda -e più sotto).

In alcuni sistemi, si potrebbe dover cambiare i quote singoli in quelli doppi, che non si deve fare in sistemi Unix o Plan 9. Si potrebbe anche dover cambiare un singolo % in due %%.

Per esempio:

    # Unix
    perl -e 'print "Ciao mondo\n"'
    # MS-DOS, ecc.
    perl -e "print \"Ciao mondo\n\""
    # Macintosh
    print "Ciao mondo\n"
     (poi Run "Mioscript" or Shift-Command-R)
    # VMS
    perl -e "print ""CIao mondo\n"""

Il problema è che nessuno di questi è affidabile: dipende dal comando ed è del tutto possibile che nemmeno funzioni. Se 4DOS fossero comandi di shell, questo probabilmente funzionerebbe meglio:

    perl -e "print <Ctrl-x>"Ciao mondo\n<Ctrl-x>""

CMD.EXE ha fatto scivolare in WindowsNT molte delle funzionalità Unix standard quando nessuno le stava cercando, si cerchi di trovare della documentazione per capire le sue regole di quoting.

Sotto Macintosh, dipende da che ambiente si sta utilizzando. La shell MacPerl, o MPW, è più simile alle shell Unix nel suo supporto per molte varianti di quoting, eccetto che fa libero uso dei caratteri Macintosh non-ASCII come caratteri di controllo.

Non c'è una soluzione generale a tutto questo. È solo un pasticcio.

La posizione di Perl

Potrebbe sembrare ovvio da dire, ma Perl è utile solo quando gli utenti possono trovarlo facilmente. Quando possibile, è cosa buona per entrambi /usr/bin/perl e /usr/local/bin/perl che siano dei link al vero binario. Se questo non può essere fatto, gli amministratori di sistema sono fortemente incoraggiati a mettere (creare link) perl e le utility a lui annesse in una directory che si trova tipicamente nel PATH dell'utente, o in qualche altro posto ovvio e conveniente.

In questa documentazione, #!/usr/bin/perl sulla prima linea del programma farà le veci di qualunque metodo funzionante nel sistema. Si è invitati ad usare un path specifico se si vuole una versione specifica.

    #!/usr/local/bin/perl5.00554

oppure se si vuole solamente avere l'ultima versione funzionante, si metta una istruzione come questa all'inizio del programma:

    use 5.005_54;

Parametri di comando [command switches, NdT]

Così come con tutti i comandi standard, un parametro costituito da un singolo carattere potrebbe essere raggruppato con il seguente parametro, se presente.

    #!/usr/bin/perl -spi.orig   # lo stesso di -s -p -i.orig

I parametri includono:

-0[ottale/esadecimale]
specifica il separatore del campo di input ($/) come un numero ottale o esadecimale. Se non ci sono numeri, il carattere nullo è il separatore. Altri parametri potrebbero precedere o seguire i caratteri. Per esempio, se si ha una versione di find che può stampare i nomi di file terminati dal carattere nullo, si può dire la seguente cosa:
    find . -name '*.orig' -print0 | perl -n0e unlink

Il valore speciale 00 farà sì che Perl si legga i file in modalità paragrafo [``paragraph mode'', nel quale si imposta $/ come stringa vuota e non come undef, NdR]. Il valore 0777 farà sì che Perl si legga i file per intero, perché non c'è un byte legale con quel valore.

Se si vuole specificare un qualunque carattere Unicode, si usi il formato esadecimale: -0xHHH..., dove H sono cifre esadecimali valide. (Questo significa che non si può usare -x con un nome di directory che consiste di numeri esadecimali).

-a
rende operativa la modalità autosplit quando viene utilizzato con un -n o -p. Viene eseguito un comando implicito di split nell'array @F, quale prima cosa dentro il ciclo while implicito prodotto da -n o -p.
    perl -ane 'print pop(@F), "\n";'

è equivalente a

    while (<>) {
        @F = split(' ');
        print pop(@F), "\n";
    }

Un delimitatore alternativo potrebbe essere specificato utilizzando -F.

-C [numero/lista]
Il flag -C controlla alcune delle caratteristiche Unicode di Perl.

A partire dalla versione 5.8.1, -C può esser seguito o da un numero o da una lista di opzioni letterali. Le lettere, i loro valori numerici e gli effetti sono i seguenti; dare una lista delle lettere è equivalente a sommare i numeri.

    I     1    STDIN si presume sia in UTF-8
    O     2    STDOUT sara` in UTF-8
    E     4    STDERR sara` in UTF-8
    S     7    I + O + E
    i     8    UTF-8 e` lo strato PerlIO di default per gli stream in ingresso
    o    16    UTF-8 e` lo strato PerlIO di default per gli stream in uscita
    D    24    i + o
    A    32    gli elementi di @ARGV si presume siano stringhe codificate in UTF-8
    L    64    di norma gli "IOEioA" sono non condizionali
               la L li rende condizionali per le variabili d'ambienti locali
               (LC_ALL, LC_TYPE, e LANG, in ordine decrescente di precedenza)
                -- se le variabili indicano UTF-8m allora le "IOEioA"
               selezionate sono in funzione

Per esempio, -COE e -C6 metteranno entrambi in funzione UTF-8 su entrambi STDOUT e STDERR. Ripetere le lettere è ridondente, non sono cumulative e nemmeno commutative.

Le opzioni io significano che qualsiasi open() a seguire (oppure operazioni di I/O simili) avrà implicitamente applicato lo strato PerlIO :utf8, in altre parole, ci si aspetta UTF-8 da qualsiasi altro stream in ingresso, e UTF-8 viene prodotto per qualsiasi stream in uscita. Questo vale come default; con espliciti strati in open() e binmode() si possono manipolare gli stream come al solito.

-C di suo (non seguito da alcun numero o lista di opzioni), o la stringa vuota "" per la variabile d'ambiente PERL_UNICODE, ha gli stessi effetti di -CSDL. In altre parole, gli handle di I/O standard e lo strato di default open() sono UTF-izzati ma solo le variabili d'ambiente locali indicano un ``locale'' UTF-8. Questo comportamento segue l'implicito (e problematico) comportamento UTF-8 di Perl 5.8.0.

Si può usare -C0 (o "0" per PERL_UNICODE) per disabilitare esplicitamente tutte le caratteristiche sopra descritte riguardo Unicode.

La magica variabile di sola-lettura ${^UNICODE} riflette il valore numerico di questa impostazione. Questa variabile viene impostata durante l'avvio di Perl e in seguito è disponibile quindi in sola-lettura. Se si vuole degli effetti a tempo di esecuzione, si usi la open() con tre argomenti (si veda perlfunc/open), binmode() con due argomenti (si veda perlfunc/binmode), e la direttiva open (si veda open).

(Nelle versioni di Perl precedenti alla 5.8.1, il parametro -C) era un parametro relativo solamente a Win32 che abilitava l'uso di ``ampie system call'' Win32 API consapevoli della codifica Unicode. Questa caratteristica era praticamente inutilizzata, comunque, e il parametro della linea di comando era quindi ``ricliclato'').

-c
fa in modo che Perl controlli la sintassi del programma e che dopo esca senza eseguirlo. In realtà, eseguirà i blocchi BEGIN, CHECK, e use, perché questi sono considerati come essere al di fuori dell'esecuzione del programma. I blocchi INIT e END, comunque, saranno saltati.

-d
-dt
esegue il programma sotto il debugger Perl. Si veda perldebug. Se viene specificato t, esso indica al debugger che nel codice di cui si sta facendo il debug, verranno utilizzati i threads.

-d:pippo[=pluto,paperino]
-dt:pippo[=pluto,paperino]
esegue il programma sotto il controllo di un modulo di debugging, profiling [analisi, NdR], o tracing installato come Devel::pippo. Ad esempio, -d:DProf esegue il programma utilizzando il profiler Devel::DProf. Come con il flag -M, potrebbero esser passate opzioni al package Devel::pippo dove saranno ricevute e interpretate dalla routine Devel::pippo::import. La lista di opzioni separata da virgola deve seguire un carattere =. Se viene specificato t, esso indica al debugger che nel codice di cui si sta facendo il debug, verranno utilizzati i threads. Si veda perldebug.

-Dlettere
-Dnumeri
imposta i flag di debugging. Per guardare come viene eseguito il proprio programma, si usi -Dtls. (Questo funziona solamente se è stato compilato 'debugging' nel proprio Perl). Un altro bel valore è -Dx, il quale mostra la lista dell'albero sintattico compilato. E -Dr mostra le espressioni regolari compilate; il formato dell'output è spiegato in perldebguts.

Come alternativa, si specifichi un numero invece di una lista di lettere (ad es., -D14 è equivalente a -Dtls):

        1  p  Tokenizing and parsing [isolamento dei simboli e analisi sintattica, NdR]
        2  s  Stack snapshots (with v, displays all stacks) [istantanea dello stack (con v mostra tutti gli stack), NdR]
        4  l  Context (loop) stack processing [elaborazione (in un loop) del contesto dello stack, NdR]
        8  t  Trace execution [esecuzione del codice un passo alla volta, NdR]
       16  o  Risoluzione dei metodi e overload
       32  c  Conversioni tra stringhe/numeri
       64  P  Stampa le informazioni di profiling, il comando del preprocessore per -P, lo stato del file sorgente in input
      128  m  Memory allocation [Allocazione della memoria, NdR]
      256  f  Format processing [Elaborazione dei formati di output, NdR]
      512  r  Analisi sintattica dell'espressione regolare e sua esecuzione
     1024  x  Syntax tree dump [stampa dell'albero sintattico, NdR]
     2048  u  Tainting checks [Controlli di sicurezza, NdR]
     4096     (Obsoleto, precedentemente usato per dei LEAKTEST [verifiche su sprechi di memoria, NdR])
     8192  H  Hash dump -- usurps values() [dump dell'hash - usurpa la funzione values(), NdR]
    16384  X  Scratchpad allocation [allocazione dello scratchpad, NdR]
    32768  D  Cleaning up [dare una ripulita, NdR]
    65536  S  Thread synchronization [sincronizzazione dei Thread, NdR]
   131072  T  Tokenising [Analisi lessicale che porta all'individuazione e catalogazione di stringhe, NdR]
   262144  R  Include il conteggio dei riferimenti delle variabili di cui si e` effettuato il dump (ad es. quando si usa -Ds)
   524288  J  Mostra debug s,t,P delle istruzioni nel package DB (normalmente vengono omessi)
  1048576  v  Verboso: usato in combinazione con altri flag
  8388608  q  silenzioso - al momento sopprime solo il messaggio "EXECUTING" ["in esecuzione", NdR]

Tutti questi flag richiedono -DDEBUGGING quando si compila il proprio eseguibile Perl (ma si dia un'occhiata a the Devel::Peek manpage, re che possono cambiare ciò). Si veda anche il file INSTALL nella distribuzione del codice sorgente Perl per come fare ciò. Questo flag è impostato automaticamente se si include l'opzione -g quando Configure vi interpella sui flag per l'ottimizzatore e il debugger.

Se si sta solamente cercando di ottenere la stampa di ciascuna linea di codice Perl nella maniera in cui viene eseguito, la modalità fornita da sh -x per gli shell script, non si può usare il parametro Perl -D. Invece si faccia così

  # se si ha l'utility "env"
  env PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
  # Sintassi della shell Bourne
  $ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
  # Sintassi csh
  % (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program)

Si veda perldebug per dettagli e variazioni.

-e lineadicomando
potrebbe essere usato per inserire una linea di programma. Se viene fornito -e, Perl non cercherà un nome di file nella lista degli argomenti. -e multipli potrebbero essere forniti sulla stessa linea di comando per costruire uno script multi-linea. Ci si assicuri di usare i punto e virgola laddove li si metterebbe usualmente in un normale programma.

-f
Si disabilita eseguendo $Config{sitelib}/sitecustomize.pl all'avvio.

Perl può essere compilato in maniera che di default esso cercherà di eseguire $Config{sitelib}/sitecustomize.pl all'avvio. Questo è una sorta di ``connessione'' che permette agli amministratori di sistema di personalizzare come si comporta perl. Può per esempio essere usato per aggiungere dei valori all'array @INC per fare in modo che perl trovi i moduli in locazioni non-standard.

-Fpattern
specifica il pattern con il quale eseguire lo split anche se viene utilizzato -a. Il pattern potrebbe essere circondato da //, "", o '', altrimenti verrà messo in apici singoli. Non si può utilizzare spazi bianchi letterali nel pattern.

-h
stampa un sommario delle opzioni.

-i[estensione]
specifica che i file processati dal costrutto <> devono essere modificati sul posto. Questo viene fatto rinominando il file in input, aprendo il file di output con il nome originale, e selezionando quel file di output come quello di default per le istruzioni di print(). L'estensione, se fornita, viene usata per modificare il nome del vecchio file per eseguire una copia di backup, si seguano queste regole:

se non è stata fornita un'estensione, non viene fatto alcun backup e il file corrente viene sovrascritto.

Se l'estensione non contiene *, allora essa viene aggiunta alla fine del nome del file corrente come un suffisso. Se l'estensione contiene uno o più caratteri *, allora ciascun * viene rimpiazzato con il nome del file corrente. In termini Perlistici, si potrebbe pensare a questa cosa come a:

    ($backup = $estensione) =~ s/\*/$nome_file/g;

Questo permette di aggiungere un prefisso al file di backup, invece di (o in aggiunta a) un suffisso:

    $ perl -pi'orig_*' -e 's/pluto/paperino/' fileA     # backup in 'orig_fileA'

O anche di posizionare delle copie di backup dei file originali in un'altra directory (ammesso che la directory esista già):

    $ perl -pi'old/*.orig' -e 's/pluto/paperino/' fileA # backup in 'old/fileA.orig'

Questi insiemi di one-liner [programmi su una linea, NdT] sono equivalenti:

    $ perl -pi -e 's/pluto/paperino/' fileA             # sovrascrive il file corrente
    $ perl -pi'*' -e 's/pluto/paperino/' fileA          # sovrascrive il file corrente
    $ perl -pi'.orig' -e 's/pluto/paperino/' fileA      # esegue il backup in 'fileA.orig'
    $ perl -pi'*.orig' -e 's/pluto/paperino/' fileA     # esegue il backup in 'fileA.orig'

Dalla shell, dire

    $ perl -p -i.orig -e "s/pippo/pluto/; ... "

è la stessa cosa che usare il programma:

    #!/usr/bin/perl -pi.orig
    s/pippo/pluto/;

il quale è equivalente a

    #!/usr/bin/perl
    $estensione = '.orig';
    LINE: while (<>) {
        if ($ARGV ne $vecchioargv) {
            if ($estensione !~ /\*/) {
                $backup = $ARGV . $estensione;
            }
            else {
                ($backup = $estensione) =~ s/\*/$ARGV/g;
            }
            rename($ARGV, $backup);
            open(ARGVOUT, ">$ARGV");
            select(ARGVOUT);
            $vecchioargv = $ARGV;
        }
        s/pippo/pluto/;
    }
    continue {
        print;  # questo stampa nel file originale
    }
    select(STDOUT);

eccetto che la forma -i non ha bisogno di confrontare $ARGV con $vecchioargv per sapere quando il nome del file è stato cambiato. Comunque, esso usa ARGVOUT per il filehandle selezionato. Va notato che STDOUT viene ripristinato come il filehandle di default per l'output dopo il ciclo.

Come mostrato sopra, Perl crea il file di backup sia nel caso che un qualsiasi output sia effettivamente cambiato che nel caso contrario. Così questo è solamente un modo elaborato per copiare dei file:

    $ perl -p -i'/unqualsiasi/percorso/difile/*' -e 1 file1 file2 file3...
o
    $ perl -p -i'.orig' -e 1 file1 file2 file3...

si può usare eof senza parentesi per localizzare la fine di ciascun file di input, nel caso si voglia aggiungere a ciascun file, o azzerare l'enumerazione delle linee (si vedano gli esempi in perlfunc/eof).

Se, per un dato file, Perl non è capace di creare un file di backup come specificato nell'estensione, allora lui salterà quel file e continuerà con il prossimo (se esiste).

Per una discussione sui problemi di contorno riguardo i permessi sui file e -i si dia un'occhiata a perlfaq5/Perché il Perl mi permette di cancellare file di sola lettura? Perché -i sovrascrive i file protetti? Non è un bug del Perl?

Non si può usare -i per creare directory o per togliere estensioni dai file.

Perl non espande ~ in nomi di file, il che è buono, dato che alcune persone lo usano per eseguire i loro backup di file

    $ perl -pi~ -e 's/pippo/pluto/' file1 file2 file3...

Va notato che, siccome -i rinomina o cancella il file originale prima di crearne uno uguale con lo stesso nome di file, non vengono preservati i link soft/hard in stile UNIX.

Alla fine, il parametro -i non impedisce l'esecuzione quando non vengono forniti file sulla linea di comando. In questo caso, non viene eseguito alcun backup (il file originale non può, naturalmente, esser determinato) e l'esecuzione procede da STDIN a STDOUT così come ci si aspetterebbe.

-Idirectory
Le directory specificate con -I sono anteposte nel percorso di ricerca per i moduli (@INC), e il parametro dice anche al preprocessore C dove andare a cercare per includere i file. Il preprocessore C è invocato con -P; di default esso va a cercare in /usr/include e /usr/lib/perl.

-l[numeroottale]
abilita l'elaborazione automatica dei caratteri di fine riga. Esso ha due effetti separati. Primo, taglia automaticamente $/ (il separatore del record in input) quando viene utilizzato con -n o -p. Secondo, assegna $\ (il separatore del record in output) in modo che abbia il valore di numeroottale così che qualsiasi istruzione di print avrà quel separatore aggiunto alla fine. Se numeroottale viene omesso, viene impostata $\ al valore corrente di $/. Per esempio, per tagliare le linee ad 80 colonne:
    perl -lpe 'substr($_, 80) = ""'

Va notato che l'assegnamento di $\ = $/ viene fatto quando il parametro viene processato, quindi il separatore di record in input può esser differente rispetto a quello di output se il parametro -l viene seguito dal parametro -0:

    gnufind / -print0 | perl -ln0e 'print "trovato $_" if -p'

Questo imposta $\ ad un carattere di fine riga e quindi imposta $/ al carattere nullo.

-m[-]modulo
-M[-]modulo
-M[-]'modulo ...'
-[mM][-]modulo=arg[,arg]...
-mmodulo esegue use modulo (); prima di eseguire il programma.

-Mmodulo esegue use modulo ; prima di eseguire il programma. Si può usare le virgolette per aggiungere ulteriore codice dopo il nome del modulo, ad esempio '-Mmodulo qw(pippo pluto)'.

Se il primo carattere dopo -M o -m è un trattino (-) allora 'use' viene rimpiazzato con 'no'.

Un piccolo zucchero sintattico incorporato [in perl, NdR] indica che si può anche dire qualcosa come -mmodulo=pippo,pluto o -Mmodulo=pippo,pluto come scorciatoia per '-Mmodulo qw(pippo pluto)'. Questo aggira il bisogno di utilizzare le virgolette quando si importano i simboli. Il vero codice generato da -Mmodulo=pippo,pluto è use modulo split(/,/,q{pippo,pluto}). Va notato che la forma = rimuove la distinzione tra -m e -M.

Una conseguenza di ciò è che -MPippo=numero non esegue mai un controllo sulla versione (a meno che Pippo::import() stesso sia impostato per eseguire un controllo di questo tipo, il quale potrebbe accadere per esempio se Pippo eredita da Exporter).

-n
fa in modo che Perl assuma il seguente ciclo intorno al programma, il quale fa in modo che esso iteri lungo gli argomenti del nome del file, in qualche modo come sed -n o awk:
  LINE:
    while (<>) {
        ...             # il programma va qui
    }

Va notato che le linee non vengono stampate di default. Si veda -p per avere le linee stampate. Se un file nominato da un argomento per qualche ragione non può essere aperto, Perl vi avvertirà al riguardo e si sposterà al file successivo.

Ecco un modo efficiente per cancellare tutti i file che non sono stati modificati per almeno una settimana:

    find . -mtime +7 -print | perl -nle unlink

Questo è più che usare il parametro -exec di find perché non deve eseguire un processo su ogni file trovato. Esso soffre del bug di maltrattare i caratteri di fine riga nel percorso del file, cosa che si può sistemare se si segue l'esempio sotto -0.

I blocchi BEGIN e END potrebbero essere utilizzati per prendere il controllo prima o dopo il ciclo implicito del programma, proprio come in awk.

-p
fa in modo che Perl assuma il seguente ciclo intorno al vostro programma, il quale fa sì che esso iteri sui nomi di file passatigli come argomento, un po' come sed:
  LINE:
    while (<>) {
        ...             # il programma va qui
    } continue {
        print or die "-p destinazione: $!\n";
    }

Se un file passato come argomento non può essere aperto per qualche ragione, Perl vi avvertirà al riguardo, e procederà oltre al file successivo. Va notato che le linee sono stampate automaticamente. Un errore che si verifica durante la stampa viene trattato come fatale. Se non si vuole stampare si utilizza il parametro -n. Un parametro -p sovrascrive un -n.

I blocchi BEGIN e END potrebbero essere utilizzati per prendere il controllo prima o dopo il ciclo implicito, proprio come in awk.

-P
NOTA: L'utilizzo di -P è fortemente sconsigliato a causa dei problemi che si porta dietro, inclusa la poca portabilità.

Questa opzione fa in modo che il programma venga eseguito tramite il pre-processore C prima che avvenga la compilazione da parte di Perl. Dato che entrambi i commenti in Perl e le direttive cpp in C++ iniziano con il carattere #, si dovrebbe cercare di evitare di iniziare i commenti con quelle parole che possano essere riconosciute dal pre-processore C come "if", "else", o "define".

Se si sta considerando la possibilità di utilizzare -P, si potrebbe anche voler dare un'occhiata al modulo Filter::cpp disponibile su CPAN.

I problemi di -P includono, ma non sono limitati a:

  • La linea che inizia con #! viene tolta, così che qualsiasi parametro messo lì non sia applicato.

  • Un -P su una linea con #! non funziona.

  • Tutte le linee che iniziano con (spazio bianco e) un # ma non assomigliano a comandi C++, vengono tolte, inclusa qualsiasi cosa dentro stringhe Perl, espressioni regolari e testo del tipo 'here-docs'.

  • Su alcune piattaforme il pre-processore C sa troppo: è a conoscenza dello stile C++ fino ai commenti a fine linea che iniziano con "//". Questo provocherà dei problemi con costrutti comuni in Perl come
        s/pippo//;

    perché dopo -P questo diventerà codice non valido

        s/pippo

    Per aggirare questo problema si devono usare altri separatori per il quoting anziché "/", come per esempio "!":

        s!pippo!!;

  • Richiede non solo un pre-processore C funzionante ma anche un sed che funzioni. Se non si è in UNIX, probabilmente si è sfortunati su questo aspetto.

  • I numeri di linea dello script non vengono conservati.

  • il parametro -x non funziona con -P.

-s
abilita un parsing di tipo rudimentale per i parametri sulla linea di comando dopo il nome del programma ma prima di qualsiasi argomento di un file (o prima di un argomento tipo --). Qualunque parametro trovato lì viene rimosso da @ARGV e imposta la variabile corrispondente nel programma Perl. Il seguente programma stampa ``1'' se viene invocato con un parametro -xyz, e ``abc'' se viene invocato con -xyz=abc.
    #!/usr/bin/perl -s
    if ($xyz) { print "$xyz\n" }

Va notato che un parametro come --help crea la variabile ${-help}, che non è compatibile con strict refs. Inoltre, quando si utilizza questa opzione in uno script con i warning abilitati si potrebbe ottenere tanti avvertimenti ``used only once'' [``usato una sola volta'', NdR].

-S
fa sì che Perl utilizzi la variabile d'ambiente PATH per cercare il programma (a meno che il nome del programma contenga dei separatori di directory).

Su alcune piattaforme, questo fa in modo che Perl aggiunga dei suffissi al nome del file mentre lo sta cercando. Per esempio, sulle piattaforme Win32, vengono aggiunte le estensioni ``.bat'' e ``.cmd'' se la ricerca per il nome del file originario fallisce, e se il nome non finisce già con uno di quei suffissi. Se il vostro Perl è stato compilato con il DEBUGGING abilitato, usando il parametro -Dp, Perl mostra come procede la ricerca.

Tipicamente questo viene utilizzato per emulare lo #! su piattaforme che non lo supportano. È anche conveniente quando si esegue il debugging di uno script che utilizza #! e quindi viene di norma trovato dal meccanismo di ricerca della shell che usa la variabile d'ambiente $PATH.

Questo esempio funziona su molte piattaforme che hanno una shell compatibile con la Bourne shell:

    #!/usr/bin/perl
    eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
            if $in_esecuzione_su_qualche_shell;

Il sistema ignora la prima linea e passa il programma a /bin/sh, che procede provando ad eseguire il programma Perl come uno shell script. La shell esegue la seconda linea come un normale comando di shell, e quindi fa partire l'interprete Perl. Su alcuni sistemi, $0 non contiene sempre il percorso completo del nome, così -S dice a Perl di cercare il programma se necessario. Dopo che Perl ha localizzato il programma, fa il parsing delle linee e le ignora, perché la variabile $in_esecuzione_su_qualche_shell non è mai vera. Se il programma sarà interpretato da csh, si aavrà bisogno di rimpiazzare ${1+"$@"} con $*, anche se non capisce gli spazi (e simili) nella lista degli argomenti. Per far partire sh anziché csh, in alcuni sistemi potrebbe essere necessario rimpiazzare la linea con #! con una linea che contenga solamente una virgola, la quale verrà gentilmente ignorata da Perl. Altri sistemi non possono aver controllo su ciò, e necessitano un costrutto completamente contorto che funzionerà in qualsiasi csh, sh, o Perl, come il seguente:

        eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'
        & eval 'exec /usr/bin/perl -wS $0 $argv:q'
                if $in_esecuzione_su_qualche_shell;

Se il nome del file fornito contiene dei separatori di directory (cioè, è un percorso assoluto o relativo), e se quel file non viene trovato, le piattaforme che aggiungono le estensioni dei file le aggiungeranno e cercheranno i file con le estensioni che sono state aggiunte, uno per uno.

Su piattaforme a-la DOS, se il programma non contiene separatori di directory, verrà prima di tutto cercato nella directory corrente prima di venire cercato nel PATH. Su piattaforme Unix, il programma verrà cercato esclusivamente nel PATH.

-t
Come -T, ma i controlli ``taint checks'' [una sorta di controllo di sicurezza sul contenuto di determinate variabili, NdR] stamperanno degli avvertimenti anziché produrre errori fatali. Questi avvertimenti possono essere controllati di norma con no warnings qw(taint).

NOTA: questo non è un sostituto per -T. Questo è inteso per essere usato solo come aiuto temporaneo durante lo sviluppo mentre si mette al sicuro del codice legacy [vecchio codice lasciato in eredità, NdT]: per del vero codice di produzione e per del nuovo codice sicuro scritto da zero, si usi sempre il vero -T.

-T
forza l'abilitazione dei controlli ``taint checks'' così che possiate testarli. Normalmente questi controlli vengono eseguiti solamente quando il programma viene useguito con setuid o setgid. È una buona idea utilizzare esplicitamente questi controlli per programmi che vengono eseguiti con i diritti di qualcun altro di cui si potrebbe non necessariamente avere fiducia, come programmi CGI o qualsiasi altro server internet che si potrebbe scrivere in Perl. Per i dettagli si veda perlsec. Per ragioni di sicurezza questa opzione deve essere vista da Perl piuttosto presto; solitamente questo significa che deve comparire presto sulla linea di comando o nella linea #! per quei sistemi che supportano quel costrutto.

-u
Questo parametro obsoleto fa in modo che Perl esegua il coredump dopo aver compilato il programma. In teoria, poi, si può prendere questo coredump e convertirlo in un file eseguibile utilizzando il programma undump (non fornito). Questo velocizza l'avvio al costo di un po' di spazio su disco (che si può minimizzare snellendo l'eseguibile). (Ancora, un file eseguibile con un ``ciao mondo'' risulta essere intorno ai 200K sulla mia macchina). Se si vuole eseguire una porzione del vostro programma prima di eseguire il dump, si utilizza invece l'operatore dump(). Nota: la disponibilità di undump è specifica della piattaforma e potrebbe non esser disponibile per un port specifico di Perl.

Questo parametro è stato sostituito in favore dei nuovi backend [parti che si occupano della parte terminale di un procedimento, NdR] al compilatore, generatori di codice Perl. Per i dettagli si veda B e the B::Bytecode manpage.

-U
permette al Perl di eseguire operazioni non sicure. Attualmente le sole operazioni non sicure sono quelle che cercano di cancellare directory quando il programma viene eseguito con il privilegio di superuser, e quando i programmi vengono eseguiti con setuid con i controlli ``taint check'' cambiati in avvertimenti. Va notato che per generare veramenete gli avvertimenti taint-check, il parametro -w (o la variabile $^W) deve esser utilizzato con questa opzione.

-v
stampa la versione e il livello di patch del vostro eseguibile perl.

-V
stampa un sommario della maggior parte dei valori di configurazione di perl e il valore corrente di @INC.

-V:vardiconfig
Stampa su STDOUT il valore della/e variabile/i di configurazione, con multipli quando gli argomenti delle variabili di configurazione sembrano come delle espressioni regolari (non aventi le lettere). Per esempio:
    $ perl -V:libc
        libc='/lib/libc-2.2.4.so';
    $ perl -V:lib.
        libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
        libc='/lib/libc-2.2.4.so';
    $ perl -V:lib.*
        libpth='/usr/local/lib /lib /usr/lib';
        libs='-lnsl -lgdbm -ldb -ldl -lm -lcrypt -lutil -lc';
        lib_ext='.a';
        libc='/lib/libc-2.2.4.so';
        libperl='libperl.a';
        ....

In più, per controllare la formattazione possono esser utilizzati due punti aggiuntivi. I due punti finali sopprimono l'avanzamento di riga e il terminatore ';', permettendovi di integrare delle richieste dentro a dei comandi di shell. (mnemonico: separatore di PATH ':'.)

    $ echo "le variabili di compressione: " `perl -V:z.*: ` " sono qui !"
    le variabili di compressione:  zcat='' zip='zip'  sono qui !

I due punti iniziali rimuovono la parte 'name=' della risposta, questo vi permette di mappare il nome di cui avete bisogno (mnemonico: etichetta vuota)

    $ echo "buonovfork="`./perl -Ilib -V::usevfork`
    buonovfork=false;

Se si ha bisogno di valori di parametri posizionali senza nome, possono esser usati insieme due punti iniziali e finali. Va notato che nel caso presentato successivamente, i parametri PERL_API vengono restituiti in ordine alfabetico.

    $ echo compilato_su `perl -V::osname: -V::PERL_API_.*:` ora
    compilato_su 'linux' '5' '1' '9' ora

-w
stampa degli avvertimenti riguardanti costrutti dubbi, come nomi di variabili che sono menzionati solo una volta e variabili scalari che sono state utilizzate prima di essere impostate, subroutine ridefinite, riferimenti a filehandle non definiti o filehandle aperti in modalità di sola lettura sui quali si sta cercando di scrivere, valori utilizzati come un numero che non sembra assomigliare ad un numero, utilizzare un array come fosse uno scalare, se le subroutine hanno delle ricorsioni per più di 100 volte, e innumerevoli altre cose.

Questo parametro abilita in realtà solo la variabile interna $^W. Si può disabilitare o promuovere degli avvertimenti specifici in degli errori fatali usando i collegamanti in __WARN__, come descritto in perlvar e perlfunc/warn. Si vedano anche perldiag e perltrap. Se si vuole manipolare intere classi di avvertimenti è disponibile un nuovo strumento che permette di controllare più accuratamente gli avvertimenti; si vedano warnings o perllexwarn.

-W
Abilita tutti gli avvertimenti incurante di no warnings o $^W. Si veda perllexwarn.

-X
Disabilita tutti gli avvertimenti incurante di use warnings o $^W. Si veda perllexwarn.

-x
-x directory
dice a Perl che il programma è incorporato in una porzione di testo ASCII più grande e senza alcun nesso, come in un messaggio di posta elettronica. La spazzatura che viene per prima verrà scartata fino alla prima linea che inizia con #! e che contiene la stringa ``perl''. Verrà applicato qualsiasi parametro sensato presente su quella linea. Se viene specificato un nome di directory, Perl passerà in quella directory prima di eseguire il programma. Il parametro -x deve esser terminato con un __END__ se c'è della spazzatura finale che deve essere ignorata (se lo si desidera, il programma può processare qualunque parte o tutta la spazzatura finale attraverso il filehandle DATA).


AMBIENTE

HOME
Utilizzata se chdir non contiene argomenti.

LOGDIR
Utilizzata se chdir non contiene argomenti e HOME non è impostata.

PATH
Utilizzata nell'eseguire sotto-processi, e nel trovare il programma se viene utilizzato -S.

PERL5LIB
Una lista di directory nelle quali andare a cercare i file della libreria Perl prima di cercare in quella standard e nella directory corrente. Qualunque directory che sia caratteristica di una particolare architettura che si trovi al di sotto della posizione specificata, se esiste, viene inclusa automaticamente. Se PERL5LIB non è definito, viene usato PERLLIB. Le directory sono separate (come in PATH) dai due punti su piattaforma di tipo unix e da un punto e virgola in Windows (l'appropriato separatore di path che viene fornito dal comando perl -V:path_sep).

Quando si esegue il programma con gli avvertimenti taint-checks (sia perché il programma era in esecuzione con setuid o setgid, o perché è stato usato il parametro -T), non viene utilizzata alcuna variabile. Il programma invece dovrebbe dire:

    use lib "/mia/directory";

PERL5OPT
Opzioni da riga di comando (switch). Gli switch in questa variabile sono presi come se fossero presenti in ogni linea di comando Perl. Sono permessi solo gli switch -[DIMUdmtw]. Quando viene eseguito con i controlli per i dati potenzialmente pericolosi [taint check, NdR] abilitati (perché il programma era in esecuzione con setuid o setgid, oppure era utilizzato il parametro -T), questa variabile viene ignorata. Se PERL5OPT inizia con -T, il controllo per i dati potenzialmente pericolosi verrà abilitato, e qualsiasi opzione seguente ignorata.

PERLIO
Una lista di strati PerlIO separata da spazi (o da due punti). Se perl è compilato per utilizzare il sistema PerlIO per l'IO (di default) questi strati hanno effetto sull'IO di perl.

È convenzione far iniziare i nomi degli strati con i due punti, per esempio :perlio, per enfatizzare la loro somiglianza con gli ``attributi'' della variabile. Ma il codice che esegue il parsing delle stringhe che specificano lo strato (che è anche utilizzato per decodificare la variabile d'ambiente PERLIO) tratta i due punti come un separatore.

Un PERLIO non impostato o vuoto è equivalente a :stdio.

La lista diventa il default per tutti gli IO di perl. Conseguentemente, solo gli strati incorporati possono apparire in questa lista, se sono strati esterni (come :encoding()) hanno bisogno di IO per poter essere caricati! Si veda ``la direttiva open'' sul come aggiungere delle codifiche esterne come default.

Gli strati che ha senso includere nella variabile d'ambiente PERLIO sono brevemente riassunti sotto. Per maggiori dettagli si veda PerlIO.

:bytes
Uno pseudostrato che spegne il flag :utf8 per lo strato sottostante. È improbabile che sia utile da solo nella variabile d'ambiente globale PERLIO. Forse si starà pensando a :crlf:bytes o :perlio:bytes.

:crlf
Uno strato che usa CRLF per la traduzione di ``\n'', distinguendo file di ``testo'' da file ``binari'' alla MS-DOS e sistemi operativi simili. (Al momento non imita MS-DOS nel modo in cui tratta Control-Z come marcatore di fine file).

:mmap
Uno strato che implementa le operazioni di ``lettura'' su file utilizzando mmap() per far sì che un file (completo) appaia nello spazio di indirizzamento del processo, e quindi lo utilizzi come ``buffer'' di PerlIO.

:perlio
Questa è una re-implementazione del sistema di buffering a-la ``stdio'', scritto come ``strato'' PerlIO. Per le sue operazioni chiamerà qualsiasi tipo di strato sottostante (tipicamente :unix).

:pop
Uno pseudostrato sperimentale che rimuove lo strato che si trova in cima a tutti. Lo si utilizzi con la stessa cura che si avrebbe utilizzando la nitroglicerina.

:raw
Uno pseudostrato che manipola altri strati. Applicare lo strato :raw è equivalente a chiamare binmode($fh). Fa in modo che lo stream passi ciascun byte così com'è senza alcuna traslazione. In particolare, sono disabilitate le traslazioni CRLF, e/o :utf8 intuite dal locale.

A differenza delle precedenti versioni di Perl, :raw non è solamente l'inverso di :crlf - inoltre sono rimossi o disabilitati altri strati che influenzerebbero la natura binaria dello stream.

:stdio
Questo strato fornisce un'interfaccia PerlIO facendo un wrapping [sorta di confezione che fornisce astrazione per livelli superiori, NdT] a chiamate di libreria ANSI C ``stdio''. Questo strato fornisce sia buffering che IO. Va notato che lo strato :stdio non esegue la traslazione CRLF anche se ciò è il comportamento normale su quella piattaforma. Per farlo avrete bisogno dello strato :crlf soprastante.

:unix
strato di basso livello che chiama read, write e lseek ecc.

:utf8
Uno pseudostrato che abilita un flag [bandiera, NdT] sullo strato sottostante, comunicando a perl che l'output dovrebbe essere in utf8 e che l'input dovrebbe essere considerato già come in formato utf8. Potrebbe essere utile con variabili d'ambiente PERLIO rendendo UTF-8 la scelta di default. (Per disabilitare quel comportamento si utilizza lo strato :bytes).

:win32
Su piattaforme Win32, questo strato sperimentale utilizza un ``handle'' di IO nativo anziché un descrittore di file numerico a-la unix. È risaputo che in questa versione ha diversi bug.

Su tutte le piattaforme, l'insieme di strati impostato di default dovrebbe fornire risultati accettabili.

Per piattaforme UNIX sarà l'equivalente di ``unix perlio'' o ``stdio''. ``Configure'' è impostato per preferire l'implementazione ``stdio'' se la libreria di sistema fornisce accesso rapido al buffer, altrimenti usa l'implementazione ``unix perlio''.

Su Win32 il default per questa release è ``unix crlf''. Lo ``stdio'' di Win32 ha un numero di bug/caratteristiche mancanti per l'IO perl, che sono in qualche modo dipendenti dalla versione/venditore del compilatore C. Utilizzare il nostro strato crlf come buffer evita questi problemi e rende le cose più uniformi. Lo strato crlf oltre al buffering, fornisce conversioni di CRLF da/a ``\n''.

Questa versione utilizza unix come strato di più basso livello per Win32 e così via, e quindi utilizza ancora le routine con descrittore di file numerico del compilatore C. C'è uno strato nativo Win32 sperimentale che ci si aspetta venga migliorato e dovrebbe eventualmente divenire quello di default in Win32.

PERLIO_DEBUG
Se impostato sul nome di un file o di un device allora in quel file (aperto in modalità append) verrè effettuato il log di certe operazioni del sotto-sistema PerlIO. Tipici utlizzi sono, in UNIX:
   PERLIO_DEBUG=/dev/tty perl script ...

e approssimativamente l'equivalente Win32:

   set PERLIO_DEBUG=CON
   perl script ...

Questa funzionalità è disabilitata per script che sono eseguiti con setuid e per script che utilizzano il parametro -T.

PERLLIB
Una lista di directory nelle quali andare a cercare i file della libreria Perl prima di andare a cercare nella libreria standard e nella directory corrente. Se PERL5LIB è definito, PERLLIB non viene utilizzato.

PERL5DB
Comando utilizzato per caricare il codice del debugger. Il default è:
        BEGIN { require 'perl5db.pl' }

PERL5DB_THREADED
Se impostato ad un valore vero, indica al debugger che il codice di cui si sta facendo il debug, utilizza i thread.

PERL5SHELL (specifico della versione Win32)
Potrebbe essere impostato ad una shell alternativa che perl deve utilizzare internamente per eseguire i comandi con backtick [`, NdT] o system(). Il default è cmd.exe /x/d/c in WindowsNT e command.com /c in Windows95. Il valore viene considerato essere separato da spazio. Precede qualsiasi carattere che ha bisogno di essere protetto (come uno spazio o un backslash [\, NdT]) con un backslash.

Va notato che Perl non utilizza COMSPEC per questo compito, dato che COMSPEC ha un elevato grado di variabilità presso gli utenti, il che porta a problemi di portabilità. Inoltre, perl può utilizzare una shell che potrebbe non esser adeguata per un utilizzo interattivo, ed impostare COMSPEC a tale shell potrebbe interferire con il corretto funzionamento di altri programmi (i quali solitamente vanno a guardare in COMSPEC per trovare una shell che sia adatta ad un utilizzo interattivo).

PERL_ALLOW_NON_IFS_LSP (specifico della versione Win32)
Va impostato ad 1 per permettere l'utilizzo di LSP non compatibili con IFS. Perl di solito va alla ricerca di un LSP compatibile con IFS perché questo viene richiesto per la sua emulazione dei socket Windows come filehandle reali. Ad ogni modo, questo potrebbe causare dei problemi se si sta utilizzando un firewall come McAfee Guardian il quale richiede che tutte le applicazioni utilizzino il suo LSP che non è compatibile IFS, perché evidentemente Perl di norma eviterà di utilizzare tale LSP. Impostare questa variabile d'ambiente ad 1 significa che Perl utilizzerà semplicemente il primo LSP appropriato, elencato nel catalogo, il che rende felice McAfee Guardian (e nel caso particolare anche Perl continua a funzionare perché l'LSP di McAfee Guardian fa davvero altri giochetti che permettono il funzionamento alle applicazioni che richiedono compatibilià IFS).

PERL_DEBUG_MSTATS
Rilevanete solamente se perl é compilato con ``malloc'' incluso nella distribuzione perl (cioé, se perl -V:d_mymalloc è 'define'). Se impostato, questo fa in modo che le statistiche sulla memoria vengano salvate dopo l'esecuzione del programma. Se impostato ad un valore intero maggiore di uno, fa anche in modo che le statistiche sulla memoria vengano salvate dopo la compilazione del programma.

PERL_DESTRUCT_LEVEL
Rilevante solamente se il vostro eseguibile perl è stato compilato con -DDEBUGGING, ciò controlla il comportamento della distruzione globale di oggetti e altri riferimenti. Per maggiori informazioni si veda perlhack/PERL_DESTRUCT_LEVEL.

PERL_DL_NONLAZY
Va impostato ad uno per fare in modo che perl risolva tutti i simboli non definiti quando carica una libreria dinamica. Il comportamento di default è quello di risolvere i simboli quando vengono usati. Impostare questa variabile è utile durante la fase di test delle estensioni, dato che assicura l'ottenimento di un errore sul nome di una funzione scritta male anche se la suite di test che si sta utilizzando non la chiama esplicitamente.

PERL_ENCODING
Se si sta utilizzando la direttiva encoding senza un nome di encoding esplicito, per trovarne uno viene consultata la variabile d'ambiente PERL_ENCODING.

PERL_HASH_SEED
(A partire dal Perl 5.8.1). Viene tilizzato per rendere aleatoria la funzione interna di hashing di Perl. Per emulare il comportamento pre-5.8.1, va impostato ad un intero (zero indica esattamente lo stesso ordine del 5.8.0). ``Pre-5.8.1'' significa, tra le altre cose, che le chiavi dell'hash saranno ordinate allo stesso modo tra differenti esecuzioni di Perl.

Il comportamento di default è quello di essere aleatorio a meno che non sia impostata PERL_HASH_SEED. Se Perl è stato compilato con -DUSE_HASH_SEED_EXPLICIT, il comportamento di default non è quello di essere aleatorio, a meno che non sia impostato PERL_HASH_SEED.

Se PERL_HASH_SEED non è impostato o è impostato ad una stringa non-numerica, Perl utilizza un seme pseudocasuale fornito dal sistema operativo e dalle librerie. Questo significa che ciascuna differente esecuzione di Perl avrà un tipo di ordinamento differente nei risultati di keys(), values() e each().

Per favore si faccia caso che ciascun seme di hash è un'informazione sensibile. Gli hash vengono resi aleatori per proteggersi contro attacchi locali e remoti contro il codice Perl. Impostando manualmente un seme si potrebbe fare in modo che questa protezione sia parzialmente o completamente persa.

Per maggiori informazioni si veda perlsec/``Algorithmic Complexity Attacks'' [``Attacchi basati sulla complessità degli algoritmi'', NdT] e PERL_HASH_SEED_DEBUG.

PERL_HASH_SEED_DEBUG
(A partire dal Perl 5.8.1). Va impostato ad uno per mostrare (su STDERR) il valore del seme dell'hash all'inizio dell'esecuzione. Questo, combinato con PERL_HASH_SEED ha lo scopo di dare una mano nei comportamenti di debugging non deterministici causati dall'aver reso aleatorio l'hash.

Va notato che ciascun seme di hash è un'informazione sensibile: conoscendolo, una persona potrebbe pensare di architettare un attacco denial-of-service contro del codice Perl, anche da remoto, per maggiori informazioni si veda perlsec/``Algorithmic Complexity Attacks'' [``Attacchi basati sulla complessità degli algoritmi'', NdT]. Non svelate il seme dell'hash a persone che non hanno bisogno di conoscerlo. Si veda anche hash_seed() di the Hash::Util manpage.

PERL_ROOT (specifico della versione VMS)
Un nome logico nascosto [in originale ``translation concealed rooted logical name'', NdR] che contiene perl ed il dispositivo logico per il path di @INC, disponibile solo su VMS. Altri nomi logici che hanno influenza sul perl nella versione VMS includono PERLSHR, PERL_ENV_TABLES, e SYS$TIMEZONE_DIFFERENTIAL, ma sono facoltativi e discussi ulteriormente in perlvms e in README.vms nella distribuzione sorgente di Perl.

PERL_SIGNALS
Nelle versioni di Perl 5.8.1 e successive. Se impostato a unsafe viene reimpostato il comportamento dei segnali pre-Perl-5.8.0 (immediato ma insicuro). Se impostato a safe, vengono utilizzati i segnali sicuri (o differiti). Si veda perlipc/``Segnali Differiti (Segnali Sicuri)''.

PERL_UNICODE
Equivalente al parametro -C da linea di comando. Va notato che questo non è una variabile booleana - impostarlo a "1" non è il modo corretto per ``abilitare Unicode'' (qualunque cosa questo significherebbe). Tuttavia si può usare "0" per ``disabilitare Unicode'' (o alternativamente de-impostare PERL_UNICODE nella propria shell prima di avviare Perl). Per ulteriori informazioni si consulti la descrizione del parametro -C.

SYS$LOGIN (specifico della versione VMS)
Utilizzato se chdir non ha argomenti e HOME e LOGDIR non sono impostati.

Perl ha anche delle variabili d'ambiente che controllano come Perl gestisca dati, specifici di particolari linguaggi naturali. Si veda perllocale.

Oltre a questo, Perl non usa altre variabili d'ambiente, eccetto che per renderle disponibili al programma in esecuzione, e ai processi figli. Tuttavia, i programmi in esecuzione con setuid impostato farebbero bene ad eseguire le seguenti linee prima di fare qualsiasi altra cosa, giusto per far restare le persone oneste:

    $ENV{PATH}  = '/bin:/usr/bin';    # o qualsiasi cosa si abbia bisogno
    $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL};
    delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};


TRADUZIONE

Versione

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

   perl -MPOD2::IT -e print_pod perlrun

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

Traduttore

Traduzione a cura di Daniele Ludovici.

Revisore

Revisione a cura di dree, dada.


Mon Jun 11 22:02:18 2012