perlrun - come eseguire l'interprete Perl
| perl | [ -sTtuUWX ]
| | [ -hv ] [ -V[:configvar] ]
| | [ -cw ] [ -d[t][:debugger] ] [ -D[number/list] ]
| | [ -pna ] [ -Fpattern ] [ -l[octal] ] [ -0[octal/hexadecimal] ]
| | [ -Idir ] [ -m[-]module ] [ -M[-]'module...' ] [ -f ]
| | [ -C [number/list] ]
| | [ -P ]
| | [ -S ]
| | [ -x[dir] ]
| | [ -i[extension] ]
| | [ -e 'command' ] [ -- ] [ programfile ] [ argument ]... |
La maniera usuale di eseguire un programma Perl è quella di renderlo direttamente
eseguibile, o altrimenti 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 su come farlo).
In fase di avvio, Perl cerca il vostro programma in uno dei seguenti posti:
-
Specificato linea per linea tramite lo switch -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 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 esplicitamente specificare 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 abbiate 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 messggio più ampio. (In questo caso indichereste la fine del
programma utilizzando il simbolo __END__).
La linea #! viene comunque esaminata per trovare degli switch durante il parsing
della stessa. Quindi, se siete su una macchina che permette solamente un
argomento con la linea #!, o peggio ancora, se nemmeno
riconosce la linea #!, potete ancora ottenere un comportamento consistente con
gli switch senza curarvi di come Perl sia stato invocato, anche se è stato
utilizzato -x per trovare l'inizio del programma.
Dato che storicamente alcuni sistemi operativi tagliano silenziosamente fuori
l'interpretazione da parte del kernel della linea #! dopo i 32 caratteri,
alcuni switch potrebbero esser passati sulla linea di comando e altri no;
potreste anche ottenere un ``-'' senza la sua lettera, se non fate attenzione.
Probabilmente volete esser sicuri che tutti i vostri switch ricadano o prima o
dopo il limite dei 32 caratteri. Molti switch non tengono conto del fatto di
esser processati ridondantemente, ma ottenere un ``-'' invece di uno switch completo
potrebbe far sì che Perl cerchi di eseguire lo standard input invece del
vostro programma. E uno switch parziale come -I potrebbe anch'esso causare
dei risultati bizzarri.
Alcuni switch tengono conto del fatto di esser stati processati due volte, per
esempio combinazioni di -l e -0. Quindi o si mettono tutti gli switch dopo il
limite dei 32 caratteri (se possibile), oppure si rimpiazza l'uso di
-0cifre con BEGIN{ $/ = "\0cifre"; }.
Il parsing dello switch #! inizia ovunque ``perl'' viene menzionato nella linea.
Le sequenze ``-*'' e ``- '' sono specificatamente ignorate così che possiate, se
foste così inclini a farlo, dire
#!/bin/sh -- # -*- perl -*- -p
eval 'exec perl -wS $0 ${1+"$@"}'
if $in_esecuzione_in_una_qualche_shell;
per permettere che Perl veda lo switch -p.
Un trucco simile coinvolge il programma env, se lo avete.
#!/usr/bin/env perl
Gli esempi sopra usano un percorso relativo all'interprete perl, ottenendo
qualunque versione compaia per prima nel path dell'utente [``percorso nel quale
vengono cercati i file eseguibili'', N.d.T.]. Se volete una specifica versione di
Perl, diciamo, perl5.005_57, dovreste 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 vostro programma, Perl compila l'intero programma
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ò esser simulata in altri sistemi:
- OS/2
-
Mettete
extproc perl -S -i_vostri_switch
come prima linea nei file *.cmd (-S a causa di un bug nella gestione di
'extproc' da parte di cmd.exe).
- MS-DOS
-
Create un file batch per eseguire il vostro programma, e codificatelo in
ALTERNATE_SHEBANG (vedete il file dosish.h nella distribuzione sorgente
per maggiori informazioni).
- 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 installate Perl con altri intenti
(incluso il compilarlo da sorgenti), potreste dover modificare voi stessi il
registro. Notate che questo significa che non potete più dire quale sia la
differenza tra un programma eseguibile Perl e una libreria Perl.
- Macintosh
-
Sotto il ``classico'' MacOS, 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 esser fatte da un qualsiasi
script del tipo
#! usando DropScript, l'utility di Wil Sanchez: http://www.wsanchez.net/software/ .
- VMS
-
Mettete
$ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
$ exit++ + ++$status != 0 and $exit = $status = undef;
in cima al vostro programma, dove -mysw sono qualasiasi switch da linea di
comando vogliate passare a Perl. Potete ora invocare il programma
direttamente, dicendo perl program, o come una procedura DCL, dicendo @program
(o implicitamente via DCL$PATH utilizzando semplicemente il nome del
programma).
Questo incantesimo è un po' troppo da ricordare, ma Perl ve lo mostrerà se
dite perl "-V:startperl".
Gli interpreti su sistemi non-Unix hanno delle idee piuttosto differenti sul
come quotare rispetto alle shell Unix. Avrete bisogno di imparare i caratteri
speciali nel vostro interprete (*, \ e " sono comuni)
a come proteggere gli spazi bianchi a questi caratteri per eseguire i
programmi su singola linea (oneliner) (vedete -e sotto).
In alcuni sistemi, potreste dover cambiare i quote singoli in quelli doppi,
che non dovete fare in sistemi Unix o Plan 9. Potreste anche dover cambiare
un singolo % in due %%.
Per esempio:
# Unix
perl -e 'print "Hello world\n"'
# MS-DOS, ecc.
perl -e "print \"Hello world\n\""
# Macintosh
print "Hello world\n"
(poi Run "Myscript" or Shift-Command-R)
# VMS
perl -e "print ""Hello world\n"""
Il problema è che nessuno di questi è affidabile: dipende dal comando ed è
completamente possibile che nemmeno funzioni. Se 4DOS fossero comandi di
shell, questo probabilmente funzionarebbe meglio:
perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
CMD.EXE ha fatto scivolare dentro WindowsNT molte delle funzionalità Unix standard
quando nessuno le stava cercando, cercate di trovare documentazione
per capire le sue regole di quoting.
Sotto Macintosh, dipende da che ambiente state utilizzando. La shell MacPerl,
o MPW, è più simile alle shell Unix nel suo supporto per molte varianti di
quoting, eccetto che fa uso libero dei caratteri non-ASCII Macintosh come
caratteri di controllo.
Non c'è una soluzione generale a tutto questo. È solo un casino.
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ò esser 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 funzioni nel vostro sistema. Siete invitati
ad usare un path specifico se volete una versione specifica.
#!/usr/local/bin/perl5.00554
oppure se volete solamente aver l'ultima versione funzionante, piazzate una
istruzione come questa all'inizio del vostro programma:
use 5.005_54;
Così come con tutti i comandi standard, uno switch costituito da un singolo
carattere potrebbe esser raggruppato con il seguente switch.
#!/usr/bin/perl -spi.orig # lo stesso di -s -p -i.orig
Gli switch includono:
- -0[octal/hexadecimal]
-
specifica il separatore del campo di input (
$/) come un numero ottale o
esadecimale. Se non ci sono numeri, il carattere nullo è il separatore. Altri
switch potrebbero precedere o seguire i caratteri. Per esempio, se avete una
versione di find che può stampare i nomi di file terminati dal carattere
nullo, potete 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à
paragraph[?]. Il valore 0777 farà sì che Perl si legga i file completamente
perché non c'è un byte legale con quel valore.
Se volete specificare un qualunque carattere Unicode, usate il formato
esadecimale: -0xHHH..., dove H sono cifre esadecimali valide. (Questo
significa che non potete usare -x con un nome di directory che consiste di
numeri esadecimali).
- -a
-
accende la modalità autosplit quando viene utilizzato con un -n o -p.
Viene eseguito un comando implicito di split nell'array @F come 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 esser specificato utilizzando -F.
- -C [number/list]
-
Il
-C flag 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; listing[?] le lettere è uguale a sommare i numeri.
[As of 5.8.1, the -C can be followed either by a number or a list
of option letters. The letters, their numeric values, and effects
are as follows; listing the letters is equal to summing the numbers.]
I 1 STDIN e` assunto essere 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` il strato di default PerlIO strato per gli stream in ingresso
o 16 UTF-8 e` il PerlIO di default per gli stream in uscita
D 24 i + o
A 32 the @ARGV elements are expected to be strings encoded in UTF-8
A 32 gli elementi di @ARGV son supposti essere delle stringhe codificate in UTF-8
L 64 normally the "IOEioA" are unconditional,
L 64 normalmente gli "IOEioA" sono incondizionali
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"
selezionati 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 alternanti.
Le opzioni io significano che qualsiasi open() a seguire (oppure operazioni
di IO simili) avranno il strato :utf8 PerlIO implicitamente applcato ad
esse, in altre parole, ci si aspetta UTF-8 da qualsiasi altro stream in
ingresso, e UTF-8 viene prodotto per qualsiasi stream in uscita. Questa vale
come default, con strato espliciti in open() e binmode() si possono manipolare
gli stream come al solito.
-C di suo (non seguito da nessun 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, lo standard I/O gestisce e il 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.
Potete usare -C0 (o "0" per PERL_UNICODE) per disabilitare
esplicitamente tutte le caratteristiche sopra descritte riguardo Unicode.
La magica variabile in sola-lettura ${^UNICODE} riflette il valore numerico
di questo settaggio. Questa variabile viene settata durante l'avvio di Perl e
dopo è quindi disponibile in sola-lettura. Se volete degli effetti a tempo di
esecuzione, usate la open() con tre argomenti (vedete perlfunc/open),
binmode() con due argomenti (vedete perlfunc/binmode), e la direttiva
open (vedete open).
(Nelle versioni di Perl precedenti alla 5.8.1, lo switch -C) era uno switch
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 la linea di comanda era quindi ``ricliclata'').
- -c
-
fa in modo che Perl controlli la sintassi del programma e che dopo esca senza
eseguirlo. Veramente, lui eseguirà i blocchi
BEGIN, CHECK, e use,
perché questi sono considerati come esser al di fuori dell'esecuzione del
programma. I blocchi INIT e END, comunque, saranno saltati.
- -d
-
- -dt
-
fa girare il programma sotto il debugger Perl. Si veda perldebug.
Se t viene specificato, indica al debugger che verranno utilizzati i
threads nel codice che si sta debuggando.
- -d:foo[=bar,baz]
-
- -dt:foo[=bar,baz]
-
esegue il programma sotto il controllo di un modulo di debugging, profiling, o
tracing installacome come Devel::foo E.g., -d:DProf esegue il programma
utilizzando il profiler Devel::DProf. Come con il flag -M, potrebbero esser
passate opzioni al package Devel::foo dove saranno ricevute e interpretate
dalla routine Devel::foo::import. La lista di opzioni separata da virgola deve
seguire un carattere
=. Se t viene specificato, indica al debugger che
verranno utilizzati i thread nel codice che si sta debuggando.
Si veda perldebug.
- -Dletters
-
- -Dnumber
-
setta i flag di debugging. Per guardare come viene eseguito il vostro
programma, usate -Dtls. (Questo funziona solamente se 'debugging' è
compilato nel vostro Perl.) Un altro bel valore e' -Dx, il quale mostra la
lista del vostro albero sintattico compilato. E -Dr mostra le espressioni
regolari compilate; il formato dell'output e' spiegato in perldebguts.
Come alternativa, specificate un numbero invece di una lista di lettere (ad es.,
-D14 è equivalente a -Dtls):
1 p Tokenizing and parsing
2 s Stack snapshots (with v, displays all stacks)
4 l Context (loop) stack processing
8 t Trace execution
16 o Method and overloading resolution
32 c String/numeric conversions
64 P Print profiling info, preprocessor command for -P, source file input state
128 m Memory allocation
256 f Format processing
512 r Regular expression parsing and execution
1024 x Syntax tree dump
2048 u Tainting checks
4096 (Obsolete, previously used for LEAKTEST)
8192 H Hash dump -- usurps values()
16384 X Scratchpad allocation
32768 D Cleaning up
65536 S Thread synchronization
131072 T Tokenising
262144 R Include reference counts of dumped variables (eg when using -Ds)
524288 J Do not s,t,P-debug (Jump over) opcodes within package DB
1048576 v Verbose: use in conjunction with other flags
8388608 q quiet - currently only suppresses the "EXECUTING" message
Tutti questi flag richiedono -DDEBUGGING quando compilate il vostro
eseguibile Perl (ma vedete the Devel::Peek manpage, re che potrebbero cambiare
questo). Si veda anche il file INSTALL nella distribuzione del codice
sorgente Perl per come fare questo. Questo flag è impostato
automaticamente se includete l'opzione -g quando Configure vi chiede
riguardo i flag optimizer/debugger.
Se state solamente provando ad ottenere la stampa di ciascuna linea di codice
Perl come esso viene eseguito, il modo che sh -x fornisce per gli shell
script, non potete usare lo switch Perl -D. Invece fate così
# Se avete 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 commandline
-
potrebbe essere usato per avere un programma di una linea. Se -e viene
dato, Perl non cercherà per un nome di file nella lista degli
argomenti. -e multipli potrebbero esser dati sulla stessa linea di comando
per costruire uno script multi-linea. Assicuratevi di usare il 'punto e
virgola' laddove lo mettereste usualmente in un normale programma.
- -f
-
Disabilitato eseguendo $Config{sitelib}/sitecustomize.pl all'avvio.
Perl può esser compilato in maniera che di default esso
cercherà di eseguire $Config{sitelib}/sitecustomize.pl all'avvio.
Questo è un aggancio che permette agli amministratori di sistema di
personalizzare come perl si comporta. Esso 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 se anche -a viene
utilizzato. Il pattern potrebbe esser circondato da
//, "", o '',
altrimenti verrà messo in apici singoli. Non potete utilizzare
spazi bianchi letterali nel pattern.
- -h
-
stampa un sommario delle opzioni.
- -i[extension]
-
specifica che i file processati dal costrutto
<> devono esser
editati 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, seguite 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 appesa alla fine del nome
di file corrente come un suffisso. Se l'estensione contiene uno o più
caratteri *, allora ciascun * viene rimpiazzato con il nome di file
corrente. In termini Perlistici, potreste pensare a questa cosa come:
($backup = $extension) =~ s/\*/$file_name/g;
Questo vi permette di aggiungere un prefisso al file di backup, invece di (o
in aggiunta a) un suffisso:
$ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to 'orig_fileA'
O anche di posizionare delle copie di backup dei file originali in un'altra
directory (ammesso che la directory già esista):
$ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup to 'old/fileA.orig'
Questi insiemi di one-liners (programmi su una linea, NdT) sono equivalenti:
$ perl -pi -e 's/bar/baz/' fileA # sovrascrive il file corrente
$ perl -pi'*' -e 's/bar/baz/' fileA # sovrascrive il file corrente
$ perl -pi'.orig' -e 's/bar/baz/' fileA # esegue backup in 'fileA.orig'
$ perl -pi'*.orig' -e 's/bar/baz/' fileA # esegue backup in 'fileA.orig'
Dalla shell dire:
$ perl -p -i.orig -e "s/foo/bar/; ... "
è la stessa cosa che usare il programma:
#!/usr/bin/perl -pi.orig
s/foo/bar/;
il quale è a
#!/usr/bin/perl
$extension = '.orig';
LINE: while (<>) {
if ($ARGV ne $oldargv) {
if ($extension !~ /\*/) {
$backup = $ARGV . $extension;
}
else {
($backup = $extension) =~ s/\*/$ARGV/g;
}
rename($ARGV, $backup);
open(ARGVOUT, ">$ARGV");
select(ARGVOUT);
$oldargv = $ARGV;
}
s/foo/bar/;
}
continue {
print; # this prints to original filename
}
select(STDOUT);
eccetto che la forma -i non ha bisogno di confrontare $ARGV con $oldargv
per sapere quando il nome di file è stato cambiato. Comunque, esso usa
ARGVOUT per il filehandle selezionato. Notate 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 che qualsiasi output sia
stato realmente cambiato o no. Così questo è solamente un modo
elaborato per copiare dei file:
$ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
o
$ perl -p -i'.orig' -e 1 file1 file2 file3...
Potete usare eof senza parentesi per localizzare la fine di ciascun input
file, nel caso vogliate appendere a ciuascun file, o resettare l'enumerazione
delle linea (vedete 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 vedetevi perlfaq5/Perché il Perl mi permette di cancellare file di sola lettura? Perché -i sovrascrive i file protetti? Non è un bug del Perl?
Non potete usare -i per creare directory o per eliminare estensioni dai
file.
Perl non espande ~ nei nomi di file, il che è buono, dato che
alcuni personaggi lo usano per eseguire i loro backup di file
$ perl -pi~ -e 's/foo/bar/' file1 file2 file3...
Notate che siccome -i rinomina o cancella il file originale prima di
crearne uno uguale con lo stesso nome di file, i link soft/hard UNIX-style non
vengono preservati.
Alla fine, lo switch -i non impedisce l'esecuzione quando non vengono dati
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 preposte nel percorso di ricerca
per i moduli (
@INC), ed esso 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[octnum]
-
abilita l'elaborazione automatica del fine-linea. Esso ha due effetti
separati. Primo, taglia automaticamente
$/ (il separatore dell'input
record) quando viene utilizzato con -n o -p. Secondo, esso assegna $\
(il separatore dell'output record) in modo che abbia il valore di octnum
così che qualsiasi istruzione di print avrà quel separatore
aggiunto alla fine. Se octnum viene omesso, viene impostata $\ al valore
corrente di $/. Per esempio, per tagliare le linee ad 80 colonne:
perl -lpe 'substr($_, 80) = ""'
Notate che l'assegnamento di $\ = $/ viene fatto quando lo switch viene
processato, quindi il separatore di input record può esser differente
rispetto a quello di output se lo switch -l è seguito dallo switch
-0:
gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
Questo imposta $\ a un carattere di newline e quindi imposta $/ al
carattere nullo.
- -m[-]module
-
- -M[-]module
-
- -M[-]'module ...'
-
- -[mM][-]module=arg[,arg]...
-
-mmodule esegue
use module (); prima di eseguire il vostro
programma.
-Mmodule exegue use module ; prima di eseguire il vostro
programma. Potete usare le virgolette per aggiungere ulteriore codice dopo il
nome del modulo, e.g., '-Mmodule qw(foo bar)'.
Se il primo carattere dopo -M o -m e' un dash (-) allora 'use' viene
rimpiazzato con 'no'.
Un piccolo zuccherino sintattico builtin significa che potete anche dire
qualcosa come -mmodule=foo,bar or -Mmodule=foo,bar come scorciatoia per
'-Mmodule qw(foo bar)'. Questo aggira il bisogno di utilizzare le
virgolette quando si importano i simboli. Il vero codice generato da
-Mmodule=foo,bar è use module split(/,/,q{foo,bar}). Notate che
la forma = rimuove la distinzione tra -m e -M.
Una conseguenza di questo è che -MFoo=number non esegue mai un
controllo sulla versione (a meno che Foo::import() stesso sia settato per
eseguire un controllo di questo tipo, il quale potrebbe accedere per
esempio se Foo eredita da Exporter.)
- -n
-
fa in modo che Perl assuma il seguente ciclo intorno al vostro programma, il
quale fa in modo che esso iteri sopra gli argomenti del nome di file in
qualche modo come sed -n o awk:
LINE:
while (<>) {
... # il vostro programma va qui
}
Notate che le linee non vengono stampate di default. Si veda -p per avere le
linee stampate. Se un file nominato da un argomento non può esser
aperto per qualche ragione, 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 lo switch -exec di find
perché non dovete eseguire un processo su ogni file trovato. Esso
soffre del bug di maltrattare i caratteri di 'nuova linea' nel percorso del
file, cosa che potete sistemare se seguite l'esempio sotto -0.
I blocchi BEGIN e END potrebbero esser usati per ottenere controllo
prima o dopo il ciclo implicito del programma, proprio come in awk.
- -p
-
fa in modo che Perl assuma ci sia il seguente intorno al vostro program, il
quale fa si che esso iteri sui nomi di file che gli avete passato come
argomento un po' come sed:
LINE:
while (<>) {
... # il vostro 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. Notate che le linee sono stampate automaticamente. Un errore
che occorra durante la stampa viene trattato come fatale. Se non volete
stampare utilizzate lo switch -n. Uno switch -p sovrascrive un -n.
I blocchi BEGIN e END potrebbero essere utilizzati per avere controllo
prima o dopo il ciclo implicito, giusto come in awk.
- -P
-
NOTATE: 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 vostro 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 #, dovreste cercare di evitare di iniziare i commenti con qualsiasi
parola possa esser riconosciuta dal pre-processore C come "if", "else", o "define".
Se state considerando la possibilit à di utilizzare -P, potreste
anche voler guardare 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 switch
non funzioni
-
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, incluso qualsiasi cosa dentro
stringhe Perl, espressioni regolari, e documentazione.
-
Su alcune piattaforme il pre-processore C ne sa troppe: capisce dallo stile
C++ fino ai commenti a afine linea che iniziano con
"//". Questo
provocherà problemi con costrutti comuni in Perl come
s/foo//;
perché dopo -P questo diventerà codice non valido
s/foo
Per aggirare questo problema si devono usare altri separatori per il quoting
anziché "/", come per esempio "!":
s!foo!!;
-
Esso richiede non solo un pre-processore C funzionante ma anche un sed che
funzioni. Se non siete in UNIX, probabilmente siete sfortunati per questa
cosa.
-
I numeri di linea dello script non vengono conservati.
-
Lo switch
-x non funziona con -P.
- -s
-
abilita un parsing di tipo rudimentale per gli switch sulla linea di comando
dopo il nome del programma ma prima degli argomenti di nome di file (o prima
di un argomento tipo --). Qualunque switch trovato lì viene rimosso
da @ARGV e imposta la variabile corrispondente nel programma Perl. Il seguente
programma stampa ``1'' se viene invocato con uno switch -xyz, e ``abc'' se
viene invocato con -xyz=abc.
#!/usr/bin/perl -s
if ($xyz) { print "$xyz\n" }
Notate che uno switch come --help crea la variabile ${-help}, che non
è compatibile con strict refs. Ancora, quando utilizzate questa
opzione in uno script con gli avvertimenti abilitati potreste ottenere tanti
``used only once'' avvertimenti.
- -S
-
fa si 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 appenda dei suffissi al nome
del file mentre sta cercando per lui. Per esempio, su piattaforma Win32,
vengono appese 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
quelli. Se il vostro Perl era stato compilato con il DEBUGGING abilitato,
usando lo switch -Dp mostra come la ricerca procede.
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 trovato normalmente 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 $girando_in_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
path del nome completo, così -S dice a Perl di cercare per il
programma se è necessario. Dopo che Perl ha localizzato il programma,
parsa le linee e le ignora perché la variabile
$running_under_some_shell non è mai vera. Se il programma sarà
interpretato da csh, avrete bisogno di rimpiazzare ${1+"$@"} con $*,
anche se lui non capisce gli spazi (e simili) nella lista degli argomenti. Per
far partire sh anziché csh, in alcuni sistemi potrebbe esser
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 questo, 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 $running_under_some_shell;
Se il nome di file fornito contiene dei separatori di directory (i.e.,
è un pathname assoluto o relativo), e se quel file non viene trovato,
le piattaforme che appendono l'estensione del file alla fine lo faranno e
cercheranno i file con quelle estensioni che sono state aggiunte, uno per uno.
Su piattaforme DOS-like, se il programma non contiene separatori di directory,
verrà prima di tutto cercato nella directory corrente prima di venir
cercato nel PATH. Su piattaforme Unix, il programma verrà
esclusivamente nel PATH.
- -t
-
Come -T, ma i controlli ``taint checks'' stamperanno degli avvertimenti
anziché produrre errori fatali. Questi avvertimenti possono esser
controllati normalmente con
no warnings qw(taint).
NOTA: questo non è un sostituto per -T. Questo è inteso
essere usato solo come aiuto temporaneo durante lo sviluppo mentre si mette al
sicuro codice legacy (NdT. vecchio codice lasciato in eredità): per
vero codice di produzione e per nuovo codice sicuro scritto da zero, usate
sempre il vero -T.
- -T
-
forza l'abilitazione dei controlli ``taint checks'' così che potete
testarli. Normalmente questi controlli vengono eseguiti solamente quando il
programma viene useguito con setuid o setgid. È una buona idea
utilizzare questi controlli esplicitamente per programmi che girano con i
diritti di qualcun altro di cui potreste necessariamente non fidarvi, come
programmi CGI o qualsiasi altro server internet che potreste scrivere in Perl.
Si veda perlsec per dettagli. Per ragioni di sicurezza, questa opzione deve
esser vista da Perl abbastanza presto; normalmente questo significa che deve
comparire presto sulla linea di comando o nella linea #! per quei sistemi che
supportano quel costrutto.
- -u
-
Questo switch obsoleto fa in modo che Perl esegua il coredump dopo aver compilato
il vostro programma. In teoria poi, potete 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
potete minimizzare snellendo l'eseguibile). (Ancora, un file eseguibile con un
``hello world'' viene ad essere intorno ai 200K sulla mia macchina.) Se volete
eseguire una porzione del vostro programma prima di eseguire il dump,
utilizzate invece l'operatore dump(). Nota: la disponibilità di
undump è specifica della piattaforma e potrebbe non esser
disponibile per un port specifico di Perl.
Questo switch è stato sostituito in favore del nuovo backend
disponibile nel compilatore. Si veda B e the B::Bytecode manpage per i dettagli.
- -U
-
permette a Perl di eseguire operazioni non sicure. Attualmente le sole
operazioni non sicure sono quelle che cercano di cancellare directory quando
il programma gira con il privilegio di superuser, e quando girano programmi con
setuid con i controlli ``taint checks'' cambiati in avvertimenti. Notate che lo
switch -w (o la variabile
$^W) deve esser utilizzato con questa opzione
per generare veramenete gli avvertimenti taint-check.
- -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:configvar
-
Stampa su STDOUT il valore della/e variabile/i di configurazione, con multipli
quando gli argomenti delle vostre variabili di configurazione sembrano come
delle espressioni regolari (non hanno 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ù , due punti aggiuntivi possono esser utilizzati per controllare
la formattazione. I due punti dietro sopprimono il linefeed e il terminatore
';', permettendovi di integrare delle richieste dentro dei comandi di shell.
(mnemonicamente: separatore di PATH ':'.)
$ echo "compression-vars: " `perl -V:z.*: ` " are here !"
compression-vars: zcat='' zip='zip' are here !
I due punti davanti rimuovono la parte 'name=' della risposta, questo vi permette
di fare il mapping al nome di cui avete bisogno (mnemonicamente: etichetta vuota)
$ echo "goodvfork="`./perl -Ilib -V::usevfork`
goodvfork=false;
Due punti davanti e dietro possono esser usati insieme se avete bisogno di valori
di parametri 'posizionali' senza i nomi. Notate che nel caso presentato successivamente,
i parametri PERL_API vengono restituiti in ordine alfabetico.
$ echo building_on `perl -V::osname: -V::PERL_API_.*:` now
building_on 'linux' '5' '1' '9' now
- -w
-
stampa degli avvertimenti riguardo costrutti dubbi, come nomi di
variabili che sono menzionati solo una volta e variabili scalari
che sono utilizzate prima di esser impostate, subroutine ridefinite,
riferimenti a filehandle non definiti o filehandle aperti in modalità
di sola lettura sui quali state cercando di scrivere, valori utilizzati come un numero
che non sembra assomigliare ad un numero, utilizzare un array come fosse uno
scalare, se le vostre subroutines hanno delle ricorsioni per più di
100 volte, e innumerevoli altre cose.
Questo switch abilita veramente soltanto la variabile interna $^W/
Potete disabilitare o promuovere degli avvertimenti specifici in
degli errori fatali usando __WARN__, come descritto in perlvar e
perlfunc/warn. Si veda anche perldiag e perltrap. Un nuovo strumento
che permette di controllare piu' accuratamente gli avvertimenti è
disponibile se volete manipolare classi intere di avvertimenti;
vedete warnings o perllexwarn.
- -W
-
Abilita tutti gli avvertimenti noncurante di
no warnings o $^W.
Si veda perllexwarn.
- -X
-
Disabilita tutti gli avvertimenti noncurante di
use warnings o $^W.
Si veda perllexwarn.
- -x
-
- -x directory
-
dice a Perl che il programma è integrato in una più grande
porzione di testo ASCII che non vi è correlata, come in un messaggio
di posta elettronica. La spazzatura che viene prima verrà scartata
fino alla prima linea che inizia con #! e contiene la stringa ``perl''.
Qualsiasi switch sensato su quella linea verrà applicato.
Se viene specificato un nome di directory, Perl passerà in quella
directory prima di eseguire il programma. Lo switch -x deve esser
terminato con un
__END__ se c'è della spazzatura alla fine
che deve essere ignorata (il programma può processare qualsiasi
o tutta la spazzatura alla fine via DATA filehandle se lo desiderate).
- 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 la i file della
libreria Perl prima di cercare in quella standard e nella directory corrente.
Qualunque directory specifica ad una particolare architettura che si trovi
sotto la posizione specificata viene automaticamente inclusa se esiste. Se PERL5LIB non
è definito, viene usato PERLLIB. Le directory sono separata (come in PATH)
da dei due punti su piattaforma unix e da un punto e virgola in Windows (l'appropriato
separatore di path che viene fornito dal comando
perl -V:path_sep).
Quando fate girare il programma con i avvertimenti taint-checks (sia perché
il programma stava girando con setuid o setgid, o lo switch -T era usato), nessuna
variabile viene utilizzata.
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 in ogni linea di comando Perl. Sono permessi solo gli switch -[DIMUdmtw].
Quando viene eseguito con i controlli per i dati potenzialmente pericolosi abilitati
(perché il programma stava girando con setuid o setgid, oppure era utilizzato lo
switch -T), questa variabile è ignorata. Se PERL5OPT inizia con -T, il
controllo per i dati potenzialmente pericolosi varrà 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 alle variabili ``attributo''. 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 built-in possono apparire in questa lista, come strati esterni (come :encoding())
hanno bisogno di IO per poterli caricare! Si veda ``la direttiva open'' sul come aggiungere
degli encoding esterni 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 starete pensando a :crlf:bytes o :perlio:bytes.
- :crlf
-
Uno strato che fa CRLF per la traduzione di ``\n'', distinguendo file di ``testo''
da file ``binari'' alla MS-DOS e sistemi operativi simili.
(Attualmente 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.
Utilizzatelo con la stessa cura che avreste 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.
Non come nella precedenti versioni di Perl, :raw non è
solamente l'inverso di :crlf - altri strati che influirebbero
la natura binaria dello stream sono rimossi o disabilitati.
- :stdio
-
Questo strato fornisce un'interfaccia PerlIO facendo un wrapping [sorta di confezione
che fornisce astrazione per livelli superiori, N.d.T.] a chiamate di libreria ANSI C ``stdio''.
Questo strato fornisce sia buffering che IO. Notate che lo strato
:stdio non esegue la
traslazione CRLF anche se quello è il comportamento normale su quella piattaforma.
Avrete bisogno del strato :crlf soprastante, per farlo.
- :unix
-
strato di basso livello che chiama
read, write e lseek ecc.
- :utf8
-
Uno pseudostrato che abilita un flag (bandiera, N.d.T.) sullo strato sottostante, comunicando a perl
che l'output dovrebbe essere in utf8 e che l'input dovrebbe esser
considerato già come in formato utf8. Potrebbe esser utile con variabili
d'ambiente PERLIO rendendo UTF-8 la scelta di default. (Per disabilitare
quel comportamento utilizzate lo strato
:bytes).
- :win32
-
Su piattaforme Win32 native, questo strato sperimentale utilizza un ``handle'' di IO
nativo anziché un descrittore di file numerico a-la unix.
È risaputo avere diversi bug in questa versione.
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 perl IO 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 fornisce conversione da/a CRLF così come il buffering.
Questa versione utilizza unix come strato di più basso livello per Win32
e così via, e quindi utilizza ancora le routine a 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 al nome di un file o di un device allora di certe operazioni del
sotto-sistema PerlIO verrè effettuato il log in quel file (aperto
in modalità append). 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 lo switch -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 è utilizzato.
- PERL5DB
-
Comando utilizzato per caricare 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 esser impostato ad una shell alternativa che perl deve utilizzare
internamente per eseguire i comandi con backtick [`, N.d.T.] o system(). Il default
è
cmd.exe /x/d/c in WindowsNT e command.com /c in Windows95.
Il valore è considerato essere separato da spazio. Precede qualsiasi
carattere che ha bisogno di esser protetto (come uno spazio o un backslash [\, N.d.T.])
con un backslash.
Va notato che Perl non utilizza COMSPEC per questo compito dato che COMSPEC ha un
elevato grado di variabilità tra 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 questa shell potrebbe interferire con il funzionamento corretto 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)
-
Impostatelo ad 1 per permettere l'utilizzo di LSP non compatibili con IFS.
Perl di solito va alla ricerca di un LSP non compatibile con IFS perché questo
viene richiesto per la sua emulazione dei socket Windows come filehandle reali. Comunque,
questo potrebbe causare dei problemi se state utilizzando un firewall come McAfee Guardian il
quale richiede che tutte le applicazioni utilizzino il suo LSP che non è compatibile IFS,
perché chiaramente Perl di norma eviterà di utilizzare tale LSP.
Impostare questa variabile d'ambiente ad 1 significa che Perl semplicemente utilizzerà
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 veramente
altri giochetti che permettono di funzionare 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 era stato e compilato
con -DDEBUGGING, questo controlla il comportamento della distruzione globale
di oggetti e altri riferimenti. Si veda perlhack/PERL_DESTRUCT_LEVEL per maggiori
informazioni.
- PERL_DL_NONLAZY
-
Impostatelo 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 sono usati. Impostare questa variabile
è utile durante la fase di test delle estensioni, dato che vi assicura
di ottenere un errore sul nome di una funzione scritto male anche se
la suite di test che state utilizzando non la chiama esplicitamente.
- PERL_ENCODING
-
Se state 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). Utilizzato per rendere aleatoria la funzione interna di hashing
di Perl. Per emulare il comportamento pre-5.8.1, impostatelo ad un intero
(zero significa 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 dei risultati di keys(), values(), e each().
Per favore fate 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.
Si veda perlsec/``Algorithmic Complexity Attacks'' [``Attacchi basati sulla complessità
degli algoritmi'', NdT] e PERL_HASH_SEED_DEBUG per maggiori informazioni.
- PERL_HASH_SEED_DEBUG
-
(A partire dal Perl 5.8.1). Impostatelo ad uno per mostrare (su STDERR) il valore
del seme dell'hash all'inizio dell'esecuzione. Questo, combinato con
PERL_HASH_SEED è inteso per dare una mano in fase di debugging
dei comportamenti 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
codice Perl, anche da remoto, si veda perlsec/``Algorithmic Complexity Attacks'' [``Attacchi basati
sulla complessità degli algoritmi'', NdT] per maggiori informazioni. 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 path logico assoluto nascosto dalla traduzione che contiene perl ed il dispositivo logico per il
percorso @INC solo su VMS. Altri nomi logici che influiscono perl su VMS includono PERLSHR,
PERL_ENV_TABLES, e SYS$TIMEZONE_DIFFERENTIAL ma sono opzionali e discussi maggiormente 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 il
comportamento dei segnali pre-Perl-5.8.0 (immediato ma insicuro) viene
reimpostato. Se impostato a safe, vengono utilizzati i segnali sicuri (o differiti).
Si veda perlipc/``Segnali Differiti (Segnali Sicuri)''.
- PERL_UNICODE
-
Equivalente allo switch -C da linea di comando. Notate che questo non
è una variabile booleana-- impostare questo a
"1" non è il
modo giusto per ``abilitare Unicode'' (o alternativamente de-impostate
PERL_UNICODE nella vostra shell prima di avviare Perl). Per ulteriori informazioni
si veda la descrizione dello switch -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.
A parte queste cose, Perl non usa altre variabili d'ambiente, eccetto per
renderle disponibili al programma che si sta eseguendo, e per creare un
processo figlio. Comunque, programmi che girano 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 abbiate 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.
Wed Jan 28 14:17:56 2009
|
