perlrun - come eseguire l'interprete Perl
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 ]...
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:
-
Specificato linea per linea tramite il parametro -e sulla linea di comando.
-
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).
-
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.
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.
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;
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).
- 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)};
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/ .
Traduzione a cura di Daniele Ludovici.
Revisione a cura di dree, dada.
Mon Jun 11 22:02:18 2012
|
