Kentaro Shirakata
argra****@users*****
2006年 4月 8日 (土) 23:44:57 JST
Index: docs/perl/5.8.4/perlrun.pod
diff -u /dev/null docs/perl/5.8.4/perlrun.pod:1.1
--- /dev/null Sat Apr 8 23:44:57 2006
+++ docs/perl/5.8.4/perlrun.pod Sat Apr 8 23:44:57 2006
@@ -0,0 +1,2794 @@
+=head1 NAME
+
+=begin original
+
+perlrun - how to execute the Perl interpreter
+
+=end original
+
+perlrun - Perl ƒCƒ“ƒ^ƒvƒŠƒ^‚Ì‹N“®•û–@
+
+=head1 SYNOPSIS
+
+B<perl> S<[ B<-sTtuUWX> ]>
+ S<[ B<-hv> ] [ B<-V>[:I<configvar>] ]>
+ S<[ B<-cw> ] [ B<-d>[:I<debugger>] ] [ B<-D>[I<number/list>] ]>
+ S<[ B<-pna> ] [ B<-F>I<pattern> ] [ B<-l>[I<octal>] ] [ B<-0>[I<octal/hexadecimal>] ]>
+ S<[ B<-I>I<dir> ] [ B<-m>[B<->]I<module> ] [ B<-M>[B<->]I<'module...'> ]>
+ S<[ B<-P> ]>
+ S<[ B<-S> ]>
+ S<[ B<-x>[I<dir>] ]>
+ S<[ B<-i>[I<extension>] ]>
+ S<[ B<-e> I<'command'> ] [ B<--> ] [ I<programfile> ] [ I<argument> ]...>
+ S<[ B<-C [I<number/list>] >]> ]>
+
+=head1 DESCRIPTION
+
+=begin original
+
+The normal way to run a Perl program is by making it directly
+executable, or else by passing the name of the source file as an
+argument on the command line. (An interactive Perl environment
+is also possible--see L<perldebug> for details on how to do that.)
+Upon startup, Perl looks for your program in one of the following
+places:
+
+=end original
+
+Perl ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚·‚é•’Ê‚Ì•û–@‚ÍA’¼ÚŽÀs‚Å‚«‚éŒ`‚É‚·‚é‚©A
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“‚̈ø”‚Æ‚µ‚ă\[ƒXƒtƒ@ƒCƒ‹‚Ì–¼‘O‚ð“n‚·‚±‚Æ‚Å‚·B
+(‘Θb“I‚È Perl ŠÂ‹«‚à‚ ‚è‚Ü‚· -- ‚ǂ̂悤‚É‚·‚é‚©‚ÌÚׂɂ‚¢‚Ä‚Í
+L<perldebug> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B)
+ŽÀs‚É‚ ‚½‚Á‚ÄAPerl ‚ÍŽw’肳‚ꂽƒvƒƒOƒ‰ƒ€‚ðˆÈ‰º‚ÉŽ¦‚·êŠ‚Å
+’T‚µ‚Ü‚·:
+
+=over 4
+
+=item 1.
+
+=begin original
+
+Specified line by line via B<-e> switches on the command line.
+
+=end original
+
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ã‚Å -e ƒXƒCƒbƒ`‚ÅŽw’肳‚ꂽsB
+
+=item 2.
+
+=begin original
+
+Contained in the file specified by the first filename on the command line.
+(Note that systems supporting the #! notation invoke interpreters this
+way. See L<Location of Perl>.)
+
+=end original
+
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ã‚Åʼn‚̃tƒ@ƒCƒ‹–¼‚Æ‚µ‚ÄŽ¦‚³‚ꂽƒtƒ@ƒCƒ‹‚Ì’†B
+(#! ‹L–@‚ðƒTƒ|[ƒg‚µ‚Ä‚¢‚éƒVƒXƒeƒ€‚Å‚ÍA‚±‚̂悤‚É‚µ‚Ä
+ƒCƒ“ƒ^ƒvƒŠƒ^‚ðŒÄ‚Ño‚µ‚Ü‚·BL<Location of Perl> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B)
+
+=item 3.
+
+=begin original
+
+Passed in implicitly via standard input. This works only if there are
+no filename arguments--to pass arguments to a STDIN-read program you
+must explicitly specify a "-" for the program name.
+
+=end original
+
+•W€“ü—Í‚©‚çˆÃ–Ù‚É“n‚³‚ê‚éB
+ƒtƒ@ƒCƒ‹–¼‚ðŽ¦‚·ˆø”‚ª–³‚¢ê‡‚É‚Ì‚Ý‚¤‚Ü‚‚¢‚«‚Ü‚·B
+STDIN ‚©‚ç“Ç‚Ýž‚ÞƒvƒƒOƒ‰ƒ€‚Ɉø”‚ð“n‚·‚É‚ÍA
+ƒvƒƒOƒ‰ƒ€–¼‚Æ‚µ‚Ä–¾Ž¦“I‚É "-" ‚ðŽw’肵‚È‚‚Ä‚Í‚È‚è‚Ü‚¹‚ñA
+
+=back
+
+=begin original
+
+With methods 2 and 3, Perl starts parsing the input file from the
+beginning, unless you've specified a B<-x> switch, in which case it
+scans for the first line starting with #! and containing the word
+"perl", and starts there instead. This is useful for running a program
+embedded in a larger message. (In this case you would indicate the end
+of the program using the C<__END__> token.)
+
+=end original
+
+2 ”Ô–ÚA3 ”Ô–Ú‚Ì•û–@‚Å‚ÍAB<-x> ƒXƒCƒbƒ`‚ðŽw’肵‚½ê‡‚𜂢‚ÄA
+Perl ‚Í“ü—̓tƒ@ƒCƒ‹‚ðʼn‚©‚ç‰ðÍ‚µŽn‚ß‚Ü‚·B@B<-x> ƒXƒCƒbƒ`‚ð
+Žw’肵‚½ê‡‚É‚ÍA‚Ü‚¸Aʼn‚É #! ‚Æ "perl" ‚Æ‚¢‚¤•¶Žš—ñ‚ð
+ŠÜ‚Þs‚ð’T‚µA‚»‚±‚©‚ç‰ðÍ‚ðŽn‚ß‚Ü‚·B
+‚±‚ê‚ÍA‘å‚«‚ȃeƒLƒXƒg‚ɃvƒƒOƒ‰ƒ€‚ð–„‚ßž‚ñ‚ÅAŽÀs‚·‚é‚悤‚È‚Æ‚«‚É•Ö—˜‚Å‚·B
+(‚±‚Ìê‡AƒvƒƒOƒ‰ƒ€‚ÌI‚í‚è‚ÍAƒg[ƒNƒ“ C<__END__> ‚ðŽg‚Á‚Ä
+Ž¦‚·‚Æ‚æ‚¢‚Å‚µ‚傤B)
+
+=begin original
+
+The #! line is always examined for switches as the line is being
+parsed. Thus, if you're on a machine that allows only one argument
+with the #! line, or worse, doesn't even recognize the #! line, you
+still can get consistent switch behavior regardless of how Perl was
+invoked, even if B<-x> was used to find the beginning of the program.
+
+=end original
+
+#! ‚ðŠÜ‚Þs‚̃XƒCƒbƒ`‚ª•K‚¸‰ðÍ‚³‚ê‚é‚悤‚É‚È‚è‚Ü‚µ‚½B
+‚‚܂èA#! ‚Ìs‚ňø”‚ªˆê‚‚µ‚©‹–‚³‚ê‚È‚¢A‚ ‚é‚¢‚Í
+‚à‚Á‚ƈ«‚A#! ‚Ìs‚ª”FŽ¯‚³‚ê‚È‚¢‚Æ‚¢‚Á‚½ƒVƒXƒeƒ€‚ʼn^—p‚µ‚Ä‚¢‚é
+ꇂɂàAB<-x> ‚ŃvƒƒOƒ‰ƒ€‚ÌŠJŽnˆÊ’u‚ðŒ©‚Â‚¯‚½ê‡‚ð
+ŠÜ‚ßA‚ǂ̂悤‚É Perl ‚ª‹N“®‚³‚ꂽ‚©‚É‚æ‚炸AˆêŠÑ‚µ‚½
+ƒXƒCƒbƒ`‚Ì“®ì‚ðŠú‘Ò‚Å‚«‚é‚悤‚É‚È‚Á‚Ä‚¢‚Ü‚·B
+
+=begin original
+
+Because historically some operating systems silently chopped off
+kernel interpretation of the #! line after 32 characters, some
+switches may be passed in on the command line, and some may not;
+you could even get a "-" without its letter, if you're not careful.
+You probably want to make sure that all your switches fall either
+before or after that 32-character boundary. Most switches don't
+actually care if they're processed redundantly, but getting a "-"
+instead of a complete switch could cause Perl to try to execute
+standard input instead of your program. And a partial B<-I> switch
+could also cause odd results.
+
+=end original
+
+—ðŽj“I‚ȃIƒyƒŒ[ƒeƒBƒ“ƒOƒVƒXƒeƒ€‚Ì’†‚É‚Í
+ƒJ[ƒlƒ‹‚É‚æ‚é #! s‚̉ðŽß‚ªAƒGƒ‰[‚È‚µ‚É 32 •¶Žš‚Å
+‘Å‚¿Ø‚ç‚ê‚Ä‚µ‚Ü‚¤‚à‚Ì‚ª‚ ‚è‚Ü‚·‚Ì‚ÅA‚ ‚éƒXƒCƒbƒ`‚̓Rƒ}ƒ“ƒhƒ‰ƒCƒ“‚É
+“n‚³‚êA‚ ‚éƒXƒCƒbƒ`‚Í“n‚³‚ê‚È‚¢‚Æ‚¢‚Á‚½‚±‚Æ‚ª‹N‚±‚è‚Ü‚·B
+’ˆÓ‚µ‚È‚¢‚ÆA•¶Žš‚ª‘±‚©‚È‚¢ "-" ‚¾‚¯‚ª“n‚³‚ê‚é‚Æ‚¢‚Á‚½‚±‚Æ‚à
+‹N‚±‚蓾‚Ü‚·B
+‚·‚ׂẴXƒCƒbƒ`‚ªAŠmŽÀ‚É 32 •¶Žš‹«ŠE‚Ì‘O‚©Œã‚ë‚©‚Ì‚Ç‚¿‚ç‚©‚É
+‚È‚é‚悤‚É‚µ‚½‚¢‚±‚Æ‚Å‚µ‚傤B
+‘½‚‚̃XƒCƒbƒ`‚ÍA—]•ª‚Ɉ—‚³‚ê‚Ä‚à–â‘è‚ ‚è‚Ü‚¹‚ñ‚ªA
+Š®‘S‚ȃXƒCƒbƒ`‚Ì‘ã‚í‚è‚É "-" ‚ª“ü‚Á‚Ä‚¢‚½ê‡‚É‚ÍA
+ƒvƒƒOƒ‰ƒ€‚Ì‘ã‚í‚è‚ÉA•W€“ü—Í‚ð Perl ‚É
+ŽÀs‚³‚¹‚邱‚Æ‚É‚È‚Á‚Ä‚µ‚Ü‚¢‚Ü‚·B
+B<-I> ƒXƒCƒbƒ`‚ª’†“r”¼’[‚É‚È‚Á‚½ê‡‚É‚à‚¨‚©‚µ‚ÈŒ‹‰Ê‚ƂȂ蓾‚Ü‚·B
+
+=begin original
+
+Some switches do care if they are processed twice, for instance
+combinations of B<-l> and B<-0>. Either put all the switches after
+the 32-character boundary (if applicable), or replace the use of
+B<-0>I<digits> by C<BEGIN{ $/ = "\0digits"; }>.
+
+=end original
+
+2 ‰ñŽÀs‚³‚ê‚邱‚Æ‚É’ˆÓ‚·‚é•K—v‚Ì‚ ‚éƒXƒCƒbƒ`‚à‚ ‚è‚Ü‚·B
+—Ⴆ‚Î B<-l> ‚Æ B<-0> ‚Ì‘g‚݇‚킹‚Å‚·B
+(‰Â”\‚È‚ç) —¼•û‚̃XƒCƒbƒ`‚ª 32 •¶Žš‹«ŠE‚ÌŒã‚ë‚É‚¢‚‚悤‚É‚·‚é‚©A
+B<-0>I<digits> ‚ð C<BEGIN{ $/ = "\0digits"; }> ‚Å’u‚«Š·‚¦‚Ä‚‚¾‚³‚¢B
+
+=begin original
+
+Parsing of the #! switches starts wherever "perl" is mentioned in the line.
+The sequences "-*" and "- " are specifically ignored so that you could,
+if you were so inclined, say
+
+=end original
+
+#! ƒXƒCƒbƒ`‚̉ðÍ‚ÍAs“à‚Å "perl" ‚ªŽ¦‚³‚ꂽˆÊ’u‚©‚çŽn‚Ü‚è‚Ü‚·B
+‚Æ‚è‚킯 "-*" ‚Æ "- " ‚Æ‚¢‚¤•¶Žš‚Ì•À‚Ñ‚Í–³Ž‹‚³‚ê‚Ü‚·‚Ì‚ÅA
+
+ #!/bin/sh -- # -*- perl -*- -p
+ eval 'exec perl -wS $0 ${1+"$@"}'
+ if $running_under_some_shell;
+
+=begin original
+
+to let Perl see the B<-p> switch.
+
+=end original
+
+‚̂悤‚É‘‚¯‚ÎAPerl ‚É B<-p> ƒXƒCƒbƒ`‚ð“n‚·‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=begin original
+
+A similar trick involves the B<env> program, if you have it.
+
+=end original
+
+Ž—‚½‚悤‚ȃgƒŠƒbƒN‚Í(Ž‚Á‚Ä‚¢‚ê‚Î) B<env> ƒvƒƒOƒ‰ƒ€‚Å‚àŽg‚¦‚Ü‚·B
+
+ #!/usr/bin/env perl
+
+=begin original
+
+The examples above use a relative path to the perl interpreter,
+getting whatever version is first in the user's path. If you want
+a specific version of Perl, say, perl5.005_57, you should place
+that directly in the #! line's path.
+
+=end original
+
+ã‚Ì—á‚Í Perl ƒCƒ“ƒ^ƒvƒŠƒ^‚É‘Š‘΃pƒX‚ðŽg‚Á‚ÄA
+ƒ†[ƒU[‚Ì PATH ‚Åʼn‚É‚ ‚Á‚½ƒo[ƒWƒ‡ƒ“‚ðŽg‚¢‚Ü‚·B
+‚à‚µ“Á’è‚̃o[ƒWƒ‡ƒ“‚Ì PerlA—Ⴆ‚Î perl5.005_57 ‚ªŽg‚¢‚½‚¢‚È‚çA
+#! s‚̃pƒX‚É’¼Ú‘‚‚ׂ«‚Å‚·B
+
+=begin original
+
+If the #! line does not contain the word "perl", the program named after
+the #! is executed instead of the Perl interpreter. This is slightly
+bizarre, but it helps people on machines that don't do #!, because they
+can tell a program that their SHELL is F</usr/bin/perl>, and Perl will then
+dispatch the program to the correct interpreter for them.
+
+=end original
+
+#! s‚É "perl" ‚Æ‚¢‚¤Œê‚ªŠÜ‚Ü‚ê‚Ä‚¢‚È‚¯‚ê‚ÎA#! ‚ÌŒã‚ÉŽw’肳‚ꂽ
+ƒvƒƒOƒ‰ƒ€‚ª Perl ƒCƒ“ƒ^ƒvƒŠƒ^‚Ì‘ã‚í‚è‚ÉŽÀs‚³‚ê‚Ü‚·B
+‚±‚ê‚Í‚µ•Ï‚í‚Á‚Ä‚¢‚Ü‚·‚ªA#! ‚ªs‚È‚¦‚È‚¢ƒ}ƒVƒ“‚ðŽg‚Á‚Ä‚¢‚é•û‚É‚Í
+—LŒø‚Å‚µ‚傤B
+ƒvƒƒOƒ‰ƒ€‚ɑ΂µ‚ÄŽg‚Á‚Ä‚¢‚é SHELL ‚ª F</usr/bin/perl> ‚¾‚ÆŒ¾‚Á‚Ä‚¨‚¯‚ÎA
+Perl ‚ª³‚µ‚¢ƒCƒ“ƒ^ƒvƒŠƒ^‚ð‹N“®‚µ‚Ä‚‚ê‚é‚©‚ç‚Å‚·B
+
+=begin original
+
+After locating your program, Perl compiles the entire program to an
+internal form. If there are any compilation errors, execution of the
+program is not attempted. (This is unlike the typical shell script,
+which might run part-way through before finding a syntax error.)
+
+=end original
+
+ƒvƒƒOƒ‰ƒ€‚Ìꊂª“Á’è‚Å‚«‚½‚È‚çAPerl ‚̓vƒƒOƒ‰ƒ€‘S‘Ì‚ð“à•”Œ`Ž®‚É
+ƒRƒ“ƒpƒCƒ‹‚µŽn‚ß‚Ü‚·B
+ƒRƒ“ƒpƒCƒ‹ƒGƒ‰[‚ªŒ©‚‚©‚Á‚½Žž‚É‚ÍAƒvƒƒOƒ‰ƒ€‚ÌŽÀs‚Ís‚È‚í‚ê‚Ü‚¹‚ñB
+(‚±‚ê‚ÍA\•¶ƒGƒ‰[‚ª‚ ‚éꇂɂàA“r’†‚Ü‚ÅŽÀs‚³‚ê‚é‰Â”\«‚Ì‚ ‚éA
+“TŒ^“I‚ȃVƒFƒ‹‚̃XƒNƒŠƒvƒg‚ƈقȂé“_‚Å‚·B)
+
+=begin original
+
+If the program is syntactically correct, it is executed. If the program
+runs off the end without hitting an exit() or die() operator, an implicit
+C<exit(0)> is provided to indicate successful completion.
+
+=end original
+
+ƒvƒƒOƒ‰ƒ€‚ª\•¶“I‚ɳ‚µ‚¯‚ê‚ÎAŽÀs‚³‚ê‚邱‚Æ‚É‚È‚è‚Ü‚·B
+ƒvƒƒOƒ‰ƒ€‚ªAexit() ‰‰ŽZŽq‚É‚à die() ‰‰ŽZŽq‚É‚à“–‚½‚ç‚È‚¢‚Å
+ÅŒã‚Ü‚Å“ž’B‚·‚é‚ÆA³í‚ÉŠ®—¹‚µ‚½‚±‚Æ‚ðŽ¦‚·‚½‚ß‚ÉAˆÃ–Ù‚Ì
+C<exit(0)> ‚ªs‚È‚í‚ê‚Ü‚·B
+
+=head2 #! and quoting on non-Unix systems
+
+(”ñ Unix ƒVƒXƒeƒ€‚Å‚Ì #! ‚ƃNƒH[ƒg)
+
+=begin original
+
+Unix's #! technique can be simulated on other systems:
+
+=end original
+
+Unix ‚Ì #! ‚̃eƒNƒjƒbƒN‚Í‘¼‚̃VƒXƒeƒ€‚Å‚àƒVƒ~ƒ…ƒŒ[ƒg‚³‚ê‚Ä‚¢‚Ü‚·B
+
+=over 4
+
+=item OS/2
+
+=begin original
+
+Put
+
+=end original
+
+C<*.cmd> ƒtƒ@ƒCƒ‹‚Ìʼn‚Ìs‚É
+
+ extproc perl -S -your_switches
+
+=begin original
+
+as the first line in C<*.cmd> file (B<-S> due to a bug in cmd.exe's
+`extproc' handling).
+
+=end original
+
+‚Æ‘‚¢‚Ä‚‚¾‚³‚¢ (B<-S> ‚Í cmd.exe ‚Ì `extproc' ‚̈µ‚¢‚Ì
+ƒoƒO‚ðˆø‚«‹N‚±‚µ‚Ü‚·)B
+
+=item MS-DOS
+
+=begin original
+
+Create a batch file to run your program, and codify it in
+C<ALTERNATE_SHEBANG> (see the F<dosish.h> file in the source
+distribution for more information).
+
+=end original
+
+ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚·‚éƒoƒbƒ`ƒtƒ@ƒCƒ‹‚ðì‚Á‚ÄA
+C<ALTERNATE_SHEBANG> ‚ŃR[ƒh‰»‚µ‚Ä‚‚¾‚³‚¢
+(‚³‚ç‚È‚éî•ñ‚ɂ‚¢‚Ă̓\[ƒX”z•zƒpƒbƒP[ƒW‚Ì F<dosish.h> ƒtƒ@ƒCƒ‹‚ð
+ŽQÆ‚µ‚ĉº‚³‚¢)B
+
+=item Win95/NT
+
+=begin original
+
+The Win95/NT installation, when using the ActiveState installer for Perl,
+will modify the Registry to associate the F<.pl> extension with the perl
+interpreter. If you install Perl by other means (including building from
+the sources), you may have to modify the Registry yourself. Note that
+this means you can no longer tell the difference between an executable
+Perl program and a Perl library file.
+
+=end original
+
+Win95/NT ‚ł̃Cƒ“ƒXƒg[ƒ‹‚É‚¨‚¢‚ÄAActiveState ‚Ì Perl —pƒCƒ“ƒXƒg[ƒ‰[‚ð
+Žg‚Á‚½ê‡‚ÍAŠg’£Žq F<.pl> ‚ð Perl ƒCƒ“ƒ^ƒvƒŠƒ^‚ÉŠÖ˜A•t‚¯‚é‚悤
+ƒŒƒWƒXƒgƒŠ‚ð•ÏX‚µ‚Ü‚·B
+‘¼‚Ì•û–@‚Å Perl ‚ðƒCƒ“ƒXƒg[ƒ‹‚µ‚½ê‡(ƒ\[ƒX‚©‚ç\’z‚µ‚½ê‡‚ðŠÜ‚Ý‚Ü‚·)A
+ƒŒƒWƒXƒgƒŠ‚ðŽ©•ª‚Å•ÏX‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B
+‚±‚ê‚ÍŽÀs‰Â”\‚È Perl ƒvƒƒOƒ‰ƒ€‚Æ Perl ƒ‰ƒCƒuƒ‰ƒŠƒtƒ@ƒCƒ‹‚Æ‚Ì
+ˆá‚¢‚ª‚È‚‚È‚Á‚Ä‚µ‚Ü‚¤‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item Macintosh
+
+=begin original
+
+A Macintosh perl program will have the appropriate Creator and
+Type, so that double-clicking them will invoke the perl application.
+
+=end original
+
+Macintosh perl ƒvƒƒOƒ‰ƒ€‚Í“KØ‚È Creator ‚Æ Type ‚ðŽ‚Á‚Ä‚¢‚é‚Ì‚ÅA
+ƒ_ƒuƒ‹ƒNƒŠƒbƒN‚·‚ê‚Î Perl ƒAƒvƒŠƒP[ƒVƒ‡ƒ“‚ð‹N“®‚Å‚«‚Ü‚·B
+
+=item VMS
+
+=begin original
+
+Put
+
+=end original
+
+ƒvƒƒOƒ‰ƒ€‚Ì擪‚ÉA
+
+ $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
+ $ exit++ + ++$status != 0 and $exit = $status = undef;
+
+=begin original
+
+at the top of your program, where B<-mysw> are any command line switches you
+want to pass to Perl. You can now invoke the program directly, by saying
+C<perl program>, or as a DCL procedure, by saying C<@program> (or implicitly
+via F<DCL$PATH> by just using the name of the program).
+
+=end original
+
+‚Æ‘‚¢‚Ä‚‚¾‚³‚¢B‚±‚±‚Å B<-mysw> ‚Í Perl ‚É“n‚µ‚½‚¢
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ƒXƒCƒbƒ`‚Å‚·B‚±‚ê‚Å C<perl program> ‚Æ‚µ‚Ä’¼Ú
+ƒvƒƒOƒ‰ƒ€‚ð‹N“®‚Å‚«‚Ü‚·‚µA
+C<@program> ‚Æ‚µ‚Ä(‚ ‚é‚¢‚Í F<DCL$PATH> Œo—R‚ŃvƒƒOƒ‰ƒ€–¼‚ðŽg‚Á‚Ä)
+DSL Žè‘±‚«‚Æ‚µ‚Ä‹N“®‚Å‚«‚Ü‚·B
+
+=begin original
+
+This incantation is a bit much to remember, but Perl will display it for
+you if you say C<perl "-V:startperl">.
+
+=end original
+
+‚±‚ÌŒˆ‚܂蕶‹å‚ÍŠo‚¦‚é‚É‚ÍX’·‚·‚¬‚Ü‚·‚ªA
+C<perl "-V:startperl"> ‚Æ‚·‚ê‚Î Perl ‚ª‚±‚ê‚ð•\Ž¦‚µ‚Ä‚‚ê‚Ü‚·B
+
+=back
+
+=begin original
+
+Command-interpreters on non-Unix systems have rather different ideas
+on quoting than Unix shells. You'll need to learn the special
+characters in your command-interpreter (C<*>, C<\> and C<"> are
+common) and how to protect whitespace and these characters to run
+one-liners (see B<-e> below).
+
+=end original
+
+”ñ Unix ƒVƒXƒeƒ€‚̃Rƒ}ƒ“ƒhƒCƒ“ƒ^ƒvƒŠƒ^‚̓NƒH[ƒg‚ÉŠÖ‚µ‚Ä
+Unix ƒVƒFƒ‹‚ƈقȂÁ‚½l‚¦•û‚ð‚µ‚Ä‚¢‚Ü‚·B
+‚¨Žg‚¢‚̃Rƒ}ƒ“ƒhƒCƒ“ƒ^ƒvƒŠƒ^‚̃XƒyƒVƒƒƒ‹ƒLƒƒƒ‰ƒNƒ^‚ɂ‚¢‚Ä
+(C<*>, C<\>, C<"> ‚͈ê”Ê“I‚Å‚·)A‚»‚µ‚Ä
+ˆês‚Å‹N“®‚·‚邽‚ß‚É(Œãq‚·‚é B<-e> ‚ðŽQÆ‚µ‚ĉº‚³‚¢)‹ó”’‚â
+ƒXƒyƒVƒƒƒ‹ƒLƒƒƒ‰ƒNƒ^‚ð•ÛŒì‚·‚é•û–@‚ɂ‚¢‚ÄŠw‚Ô•K—v‚ª‚ ‚é‚Å‚µ‚傤B
+
+=begin original
+
+On some systems, you may have to change single-quotes to double ones,
+which you must I<not> do on Unix or Plan 9 systems. You might also
+have to change a single % to a %%.
+
+=end original
+
+ƒVƒXƒeƒ€‚É‚æ‚Á‚Ă̓Vƒ“ƒOƒ‹ƒNƒH[ƒg‚ðƒ_ƒuƒ‹ƒNƒH[ƒg‚É•ÏX‚·‚é•K—v‚ª
+‚ ‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñB‚µ‚©‚µ Unix ‚â Plan9 ‚̃VƒXƒeƒ€‚Å‚Í
+I<‚µ‚Ä‚Í‚¢‚¯‚Ü‚¹‚ñ>B
+‚Ü‚½A’P‘Ì‚Ì % ‚ð %% ‚É•ÏX‚·‚é•K—v‚ª‚ ‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+
+=begin original
+
+For example:
+
+=end original
+
+—Ⴆ‚Î:
+
+ # Unix
+ perl -e 'print "Hello world\n"'
+
+ # MS-DOS, etc.
+ perl -e "print \"Hello world\n\""
+
+ # Macintosh
+ print "Hello world\n"
+ (then Run "Myscript" or Shift-Command-R)
+
+ # VMS
+ perl -e "print ""Hello world\n"""
+
+=begin original
+
+The problem is that none of this is reliable: it depends on the
+command and it is entirely possible neither works. If B<4DOS> were
+the command shell, this would probably work better:
+
+=end original
+
+–â‘è‚ÍA‚±‚ê‚ç‚Í‚Ç‚ê‚àM—Š«‚ª‚È‚¢‚±‚Æ‚Å‚·B
+‚±‚ê‚̓Rƒ}ƒ“ƒh‚Ɉˑ¶‚µA‚Ç‚ê‚à“®‚©‚È‚¢‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+B<4DOS> ‚ªƒRƒ}ƒ“ƒhƒVƒFƒ‹‚È‚çA‚¨‚»‚ç‚‚æ‚è‚æ‚“®‚«‚Ü‚·:
+
+ perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
+
+=begin original
+
+B<CMD.EXE> in Windows NT slipped a lot of standard Unix functionality in
+when nobody was looking, but just try to find documentation for its
+quoting rules.
+
+=end original
+
+Windows NT ‚Ì B<CMD.EXE> ‚Í’N‚àŒ©‚Ä‚¢‚È‚¢ŠÔ‚É‘½‚‚Ì•W€ Unix ‹@”\‚ª
+“ü‚èž‚ñ‚Å‚¢‚Ü‚·‚ªAƒNƒH[ƒg‚̃‹[ƒ‹‚ÉŠÖ‚µ‚Ä‚Í
+ƒhƒLƒ…ƒƒ“ƒg‚ð’T‚µ‚Ä‚Ý‚Ä‚‚¾‚³‚¢B
+
+=begin original
+
+Under the Macintosh, it depends which environment you are using. The MacPerl
+shell, or MPW, is much like Unix shells in its support for several
+quoting variants, except that it makes free use of the Macintosh's non-ASCII
+characters as control characters.
+
+=end original
+
+Macintosh ‚Å‚ÍAŽg‚Á‚Ä‚¢‚éŠÂ‹«‚Ɉˑ¶‚µ‚Ü‚·B
+MacPerl shell ‚â MPW ‚̓NƒH[ƒgŠÖŒW‚̑Ήž‚ÉŠÖ‚µ‚Ä
+‚©‚È‚è Unix ƒVƒFƒ‹‚ÆŽ—‚Ä‚¢‚Ü‚·B
+‚µ‚©‚µAMacintosh ‚Ì”ñ ASCII •¶Žš‚ðƒRƒ“ƒgƒ[ƒ‹•¶Žš‚Æ‚µ‚Ä
+Ž©—R‚ÉŽg‚¤‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=begin original
+
+There is no general solution to all of this. It's just a mess.
+
+=end original
+
+‚±‚Ì•Ó‚è‚Ì‚±‚Æ‚ÉŠÖ‚·‚éˆê”Ê“I‚È‰ðŒˆ•û–@‚Í‚ ‚è‚Ü‚¹‚ñB
+‚Ü‚Á‚½‚‚®‚¿‚á‚®‚¿‚á‚Å‚·B
+
+=head2 Location of Perl
+
+(Perl ‚̈ʒu)
+
+=begin original
+
+It may seem obvious to say, but Perl is useful only when users can
+easily find it. When possible, it's good for both F</usr/bin/perl>
+and F</usr/local/bin/perl> to be symlinks to the actual binary. If
+that can't be done, system administrators are strongly encouraged
+to put (symlinks to) perl and its accompanying utilities into a
+directory typically found along a user's PATH, or in some other
+obvious and convenient place.
+
+=end original
+
+“–‚½‚è‘O‚̂悤‚É•·‚±‚¦‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñ‚ªA
+Perl ‚̓†[ƒU[‚ªŠÈ’P‚É”Œ©‚Å‚«‚éꇂɂ̂ݗL—p‚Å‚·B
+‰Â”\‚È‚çAF</usr/bin/perl> ‚Æ F</usr/local/bin/perl> ‚Ì—¼•û‚É
+ŽÀۂ̃oƒCƒiƒŠ‚ւ̃Vƒ“ƒ{ƒŠƒbƒNƒŠƒ“ƒN‚ð’u‚‚Æ‚¢‚¤‚Ì‚Í‚æ‚¢l‚¦‚Å‚·B
+‚à‚µ‚±‚ꂪ–³—‚È‚çAƒVƒXƒeƒ€ŠÇ—ŽÒ‚Í Perl ‚Æ
+•t‚·‚郆[ƒeƒBƒŠƒeƒB (‚ւ̃Vƒ“ƒ{ƒŠƒbƒNƒŠƒ“ƒN) ‚ðA
+“TŒ^“I‚Ƀ†[ƒU[‚Ì PATH ‚ÅŒ©•t‚©‚éƒfƒBƒŒƒNƒgƒŠ‚©A
+‚»‚Ì‘¼‚Ì–¾‚ç‚©‚Å•Ö—˜‚Èꊂɒu‚‚ׂ«‚Å‚·B
+
+=begin original
+
+In this documentation, C<#!/usr/bin/perl> on the first line of the program
+will stand in for whatever method works on your system. You are
+advised to use a specific path if you care about a specific version.
+
+=end original
+
+‚±‚̃hƒLƒ…ƒƒ“ƒg‚Å‚ÍAC<#!/usr/bin/perl> ‚ƃvƒƒOƒ‰ƒ€‚Ì擪‚É‘‚¯‚Î
+ƒVƒXƒeƒ€‚Ì‘S‚Ẵƒ\ƒbƒh‚ªŽÀs‚Å‚«‚é‚à‚Ì‚Æ‚µ‚Ä‚¢‚Ü‚·B
+“Á’è‚̃o[ƒWƒ‡ƒ“‚ðŽg‚¢‚½‚¢ê‡‚ÍA“Á’è‚̃pƒX‚ðŽg‚¤‚©:
+
+ #!/usr/local/bin/perl5.00554
+
+=begin original
+
+or if you just want to be running at least version, place a statement
+like this at the top of your program:
+
+=end original
+
+‚ ‚é‚¢‚Í’P‚ÉÅ’áŒÀ‚̃o[ƒWƒ‡ƒ“‚ðŽw’肵‚½ê‡‚ÍA
+ˆÈ‰º‚̂悤‚Ès‚ðƒvƒƒOƒ‰ƒ€‚Ì擪‚É’u‚¢‚Ä‚‚¾‚³‚¢:
+
+ use 5.005_54;
+
+=head2 Command Switches
+
+(ƒRƒ}ƒ“ƒhƒXƒCƒbƒ`)
+
+=begin original
+
+As with all standard commands, a single-character switch may be
+clustered with the following switch, if any.
+
+=end original
+
+‘S‚Ä‚Ì•W€ƒRƒ}ƒ“ƒh‚Æ“¯—l‚ÉA
+1 •¶Žš‚̃XƒCƒbƒ`‚ÍAŽŸ‚É‘±‚ƒXƒCƒbƒ`‚ª‚ ‚ê‚ÎA‚»‚ê‚Ƃ‚Ȃ°‚é
+‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+
+ #!/usr/bin/perl -spi.orig # same as -s -p -i.orig
+
+=begin original
+
+Switches include:
+
+=end original
+
+ƒXƒCƒbƒ`ˆê——:
+
+=over 5
+
+=item B<-0>[I<octal/hexadecimal>]
+
+=begin original
+
+specifies the input record separator (C<$/>) as an octal or
+hexadecimal number. If there are no digits, the null character is the
+separator. Other switches may precede or follow the digits. For
+example, if you have a version of B<find> which can print filenames
+terminated by the null character, you can say this:
+
+=end original
+
+“ü—̓ŒƒR[ƒhƒZƒpƒŒ[ƒ^ (C<$/>) ‚ð 8 i”‚Ü‚½‚Í 16 i”‚ÅŽ¦‚µ‚Ü‚·B
+digits ‚ðŽw’肵‚È‚¢‚ÆAƒkƒ‹•¶Žš‚ªƒZƒpƒŒ[ƒ^‚É‚È‚è‚Ü‚·B
+‘¼‚̃XƒCƒbƒ`‚ð‘O‚É’u‚¢‚Ä‚à‚©‚Ü‚¢‚Ü‚¹‚ñ‚µAdigits ‚Ì‚ ‚Æ‚É
+‚‚Ȃ°‚Ä‚à‚©‚Ü‚¢‚Ü‚¹‚ñB
+‚½‚Æ‚¦‚ÎAƒtƒ@ƒCƒ‹–¼‚ðƒkƒ‹•¶Žš‚Å‹æØ‚Á‚Ä•\Ž¦‚Å‚«‚é find ‚ª‚ ‚ê‚Î:
+
+ find . -name '*.orig' -print0 | perl -n0e unlink
+
+=begin original
+
+The special value 00 will cause Perl to slurp files in paragraph mode.
+The value 0777 will cause Perl to slurp files whole because there is no
+legal byte with that value.
+
+=end original
+
+00 ‚Æ‚¢‚¤“Á•Ê‚È’l‚ÍAPerl ‚Ƀpƒ‰ƒOƒ‰ƒtƒ‚[ƒh‚ÅAƒtƒ@ƒCƒ‹‚ð“Ç‚Ü‚¹‚Ü‚·B
+0777 ‚Æ‚¢‚¤’l‚ÍAŠY“–‚·‚éƒoƒCƒg‚ª‚È‚¢‚½‚ßA
+Perl ‚Ƀtƒ@ƒCƒ‹‘S‘Ì‚ð“Ç‚Ü‚¹‚邱‚Æ‚É‚È‚è‚Ü‚·B
+
+=begin original
+
+If you want to specify any Unicode character, use the hexadecimal
+format: C<-0xHHH...>, where the C<H> are valid hexadecimal digits.
+(This means that you cannot use the C<-x> with a directory name that
+consists of hexadecimal digits.)
+
+=end original
+
+Unicode •¶Žš‚ðŽw’肵‚½‚¢ê‡‚ÍA16 i”‚̃tƒH[ƒ}ƒbƒg C<-0xHHH...> ‚ð
+Žg‚Á‚Ä‚‚¾‚³‚¢B‚±‚±‚Å C<H> ‚Í 16 i”‚Æ‚µ‚Ä—LŒø‚È•¶Žš‚Å‚·
+(‚±‚ê‚Í C<-x> ‚Å 16 i”‚Ì”’l‚©‚ç‚È‚éƒfƒBƒŒƒNƒgƒŠ–¼‚ðŽw’è‚Å‚«‚È‚¢
+‚±‚Æ‚ðˆÓ–¡‚µ‚Ü‚·)B
+
+=item B<-a>
+
+=begin original
+
+turns on autosplit mode when used with a B<-n> or B<-p>. An implicit
+split command to the @F array is done as the first thing inside the
+implicit while loop produced by the B<-n> or B<-p>.
+
+=end original
+
+B<-n> ‚â B<-p> ‚Æ‚¢‚Á‚µ‚å‚É—p‚¢‚é‚ÆAŽ©“® split ƒ‚[ƒh‚É‚È‚è‚Ü‚·B
+B<-n> ‚â B<-p> ‚Åì‚ç‚ê‚éˆÃ–ق̃‹[ƒv“à‚Ìʼn‚Ì•¶‚Æ‚µ‚ÄA
+”z—ñ @F ‚Ö‚ÌˆÃ–Ù‚Ì split ƒRƒ}ƒ“ƒh‚ªŽÀs‚³‚ê‚Ü‚·B
+
+ perl -ane 'print pop(@F), "\n";'
+
+=begin original
+
+is equivalent to
+
+=end original
+
+‚͈ȉº‚Ì‚à‚Ì‚Æ“™‰¿‚Å‚·B
+
+ while (<>) {
+ @F = split(' ');
+ print pop(@F), "\n";
+ }
+
+=begin original
+
+An alternate delimiter may be specified using B<-F>.
+
+=end original
+
+B<-F> ‚ðŽg‚Á‚Ä‹æØ•¶Žš‚ð•ÏX‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=item B<-C [I<number/list>]>
+
+=begin original
+
+The C<-C> flag controls some Unicode of the Perl Unicode features.
+
+=end original
+
+C<-C>ƒtƒ‰ƒO‚Í Perl Unicode ‹@”\‚Ì‚¢‚‚‚©‚Ì Unicode ‚ð§Œä‚µ‚Ü‚·B
+
+=begin original
+
+As of 5.8.1, the C<-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.
+
+=end original
+
+5.8.1 ‚©‚çAC<-C> ƒtƒ‰ƒO‚Í”’l‚Ü‚½‚̓IƒvƒVƒ‡ƒ“•¶Žš‚̃ŠƒXƒg‚ð
+‚‚¯‚邱‚Æ‚ªo—ˆ‚Ü‚·BŽw’è‰Â”\‚È•¶Žš‚Æ”’l‚¨‚æ‚Ñ‚»‚ÌŒø‰Ê‚͈ȉº‚Ì’Ê‚è‚Å‚·;
+•¶Žš‚̃ŠƒXƒg‚Í”’l‚̇Œv‚Æ“¯‚¶‚Å‚·B
+
+ I 1 STDIN is assumed to be in UTF-8
+ O 2 STDOUT will be in UTF-8
+ E 4 STDERR will be in UTF-8
+ S 7 I + O + E
+ i 8 UTF-8 is the default PerlIO layer for input streams
+ o 16 UTF-8 is the default PerlIO layer for output streams
+ D 24 i + o
+ A 32 the @ARGV elements are expected to be strings encoded in UTF-8
+ L 64 normally the "IOEioA" are unconditional,
+ the L makes them conditional on the locale environment
+ variables (the LC_ALL, LC_TYPE, and LANG, in the order
+ of decreasing precedence) -- if the variables indicate
+ UTF-8, then the selected "IOEioA" are in effect
+
+=begin original
+
+For example, C<-COE> and C<-C6> will both turn on UTF-8-ness on both
+STDOUT and STDERR. Repeating letters is just redundant, not cumulative
+nor toggling.
+
+=end original
+
+—Ⴆ‚ÎAC<-COE> ‚Æ C<-C6> ‚Í‚Ç‚¿‚ç‚à STDOUT ‚Æ STDERR ‚ð UTF-8 ‰»‚µ‚Ü‚·B
+“¯‚¶•¶Žš‚ðŒJ‚è•Ô‚µ‚Ä‚àç’·‚È‚¾‚¯‚ÅA‰ÁŽZ‚³‚ꂽ‚èƒgƒOƒ‹‚É‚È‚Á‚½‚è‚Í
+‚µ‚Ü‚¹‚ñB
+
+=begin original
+
+The C<io> options mean that any subsequent open() (or similar I/O
+operations) will have the C<:utf8> PerlIO layer implicitly applied
+to them, in other words, UTF-8 is expected from any input stream,
+and UTF-8 is produced to any output stream. This is just the default,
+with explicit layers in open() and with binmode() one can manipulate
+streams as usual.
+
+=end original
+
+C<io> ƒIƒvƒVƒ‡ƒ“‚͈ø‚«‘±‚ open() (‚ ‚é‚¢‚Í“¯—l‚Ì I/O ‘€ì) ‚É‚¨‚¢‚Ä
+ˆÃ–Ù“I‚É C<:utf8> PerlIO ‘w‚ª“K—p‚³‚ê‚Ü‚·B
+Œ¾‚¢Š·‚¦‚é‚ÆA“ü—̓XƒgƒŠ[ƒ€‚Å‚Í UTF-8 ‚ª‘z’肳‚êAo—̓XƒgƒŠ[ƒ€‚Í
+UTF-8 ‚Åo—Í‚³‚ê‚Ü‚·B
+‚±‚ê‚Í’P‚ɃfƒtƒHƒ‹ƒg‚Å‚ ‚èA’Êí‚Ç‚¨‚è open() ‚Æ binmode() ‚Å–¾Ž¦“I‚É
+•ÏX‚Å‚«‚Ü‚·B
+
+=begin original
+
+C<-C> on its own (not followed by any number or option list), or the
+empty string C<""> for the C<PERL_UNICODE> environment variable, has the
+same effect as C<-CSDL>. In other words, the standard I/O handles and
+the default C<open()> layer are UTF-8-fied B<but> only if the locale
+environment variables indicate a UTF-8 locale. This behaviour follows
+the I<implicit> (and problematic) UTF-8 behaviour of Perl 5.8.0.
+
+=end original
+
+C<-C> ‚ª’P‘Ì‚Å(”’l‚âƒIƒvƒVƒ‡ƒ“ƒŠƒXƒg‚È‚µ)‹N“®‚³‚ê‚é‚©A
+C<PERL_UNICODE> ŠÂ‹«•Ï”‚ª‹ó•¶Žš—ñ C<""> ‚Ìê‡AC<-CSDL> ‚Æ
+“¯‚¶Œø‰Ê‚Æ‚È‚è‚Ü‚·BŒ¾‚¢Š·‚¦‚é‚ÆA•W€ I/O ‘€ì‚Æ
+ƒfƒtƒHƒ‹ƒg‚Ì C<open()> ‘w‚̓ƒP[ƒ‹ŠÂ‹«•Ï”‚ª UTF-8 ƒƒP[ƒ‹‚ð
+Ž¦‚µ‚Ä‚¢‚éê‡ B<‚Ì‚Ý> UTF-8 ‰»‚³‚ê‚Ü‚·B
+‚±‚ÌU‚é•‘‚¢‚Í Perl 5.8.0 ‚Å‚Ì I<ˆÃ–Ù‚Ì> (‚»‚µ‚Ä–â‘è‚Ì‚ ‚é) UTF-8 ‚É
+ŠÖ‚·‚éU‚é•‘‚¢‚Æ“¯‚¶‚Å‚·B
+
+=begin original
+
+You can use C<-C0> (or C<"0"> for C<PERL_UNICODE>) to explicitly
+disable all the above Unicode features.
+
+=end original
+
+C<-C0> (‚ ‚é‚¢‚Í C<PERL_UNICODE> ‚É C<"0">) ‚ðŽw’è‚·‚é‚Æ
+–¾Ž¦“I‚Éã‹L‚Ì‘S‚Ä‚Ì Unicode ‹@”\‚𖳌ø‚É‚µ‚Ü‚·B
+
+=begin original
+
+The read-only magic variable C<${^UNICODE}> reflects the numeric value
+of this setting. This is variable is set during Perl startup and is
+thereafter read-only. If you want runtime effects, use the three-arg
+open() (see L<perlfunc/open>), the two-arg binmode() (see L<perlfunc/binmode>),
+and the C<open> pragma (see L<open>).
+
+=end original
+
+“Ç‚Ýž‚Ýê—p‚̃}ƒWƒbƒN•Ï” C<${^UNICODE}> ‚É‚±‚ÌÝ’è‚Ì”’l•\Œ»‚ª
+”½‰f‚³‚ê‚Ü‚·B‚±‚ê‚Í Perl ‹N“®Žž‚ɃZƒbƒg‚³‚ê‚é•Ï”‚ÅA“Ç‚Ýž‚Ýê—p‚Å‚·B
+ŽÀs’†‚ÉŒø‰Ê‚𓾂½‚¢ê‡‚ÍA3 ˆø”‚Ì open() (L<perlfunc/open> ŽQÆ),
+2 ˆø”‚Ì binmode() (L<perlfunc/binmode> ŽQÆ), C<open> ƒvƒ‰ƒOƒ}
+(L<open> ŽQÆ) ‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B
+
+=begin original
+
+(In Perls earlier than 5.8.1 the C<-C> switch was a Win32-only switch
+that enabled the use of Unicode-aware "wide system call" Win32 APIs.
+This feature was practically unused, however, and the command line
+switch was therefore "recycled".)
+
+=end original
+
+(5.8.1 ˆÈ‘O‚Ì Perl ‚Å‚Í C<-C> ƒXƒCƒbƒ`‚Í Win32 ê—p‚̃XƒCƒbƒ`‚ÅA
+Unicode ‘Ήž‚Ì "ƒƒCƒh•¶ŽšƒVƒXƒeƒ€ƒR[ƒ‹" Win32 API ‚ðŽg‚¤‚½‚ß‚Ì‚à‚Ì‚Å‚µ‚½B
+‚±‚Ì‹@”\‚ÍŽ–ŽÀãŽg‚í‚ê‚Ü‚¹‚ñ‚Å‚µ‚½‚ªAƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ƒXƒCƒbƒ`‚Í
+"Ä—˜—p" ‚³‚ê‚Ü‚µ‚½B)
+
+=item B<-c>
+
+=begin original
+
+causes Perl to check the syntax of the program and then exit without
+executing it. Actually, it I<will> execute C<BEGIN>, C<CHECK>, and
+C<use> blocks, because these are considered as occurring outside the
+execution of your program. C<INIT> and C<END> blocks, however, will
+be skipped.
+
+=end original
+
+Perl ‚ɃXƒNƒŠƒvƒg‚Ì\•¶‚̃`ƒFƒbƒN‚ðs‚Ȃ킹AŽÀs‚¹‚¸‚É
+I—¹‚·‚é‚悤‚É‚µ‚Ü‚·B
+ŽÀÛ‚É‚ÍAC<BEGIN>, C<CHECK>, C<use> ƒuƒƒbƒN‚Í I<ŽÀs‚µ‚Ü‚·>B
+‚±‚ê‚ç‚̓vƒƒOƒ‰ƒ€‚ÌŽÀs‚ÌŠO‘¤‚É‚ ‚é‚à‚Ì‚Æl‚¦‚ç‚ê‚é‚©‚ç‚Å‚·B
+C<INIT> ‚Æ C<END> ƒuƒƒbƒN‚̓XƒLƒbƒv‚³‚ê‚Ü‚·B
+
+=item B<-d>
+
+=begin original
+
+runs the program under the Perl debugger. See L<perldebug>.
+
+=end original
+
+Perl ƒfƒoƒbƒK‚̉º‚ŃvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚Ü‚·B
+L<perldebug> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item B<-d:>I<foo[=bar,baz]>
+
+=begin original
+
+runs the program under the control of a debugging, profiling, or
+tracing module installed as Devel::foo. E.g., B<-d:DProf> executes
+the program using the Devel::DProf profiler. As with the B<-M>
+flag, options may be passed to the Devel::foo package where they
+will be received and interpreted by the Devel::foo::import routine.
+The comma-separated list of options must follow a C<=> character.
+See L<perldebug>.
+
+=end original
+
+Devel::foo ‚Æ‚µ‚ăCƒ“ƒXƒg[ƒ‹‚³‚ê‚é ƒfƒoƒbƒOEƒvƒƒtƒ@ƒCƒŠƒ“ƒOE
+ƒgƒŒ[ƒXƒ‚ƒWƒ…[ƒ‹‚̧Œä‰º‚ŃvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚Ü‚·B
+‚‚܂èAB<-d:DProf> ‚Í Devel::DProf ƒvƒƒtƒ@ƒCƒ‰‚ðŽg‚Á‚Ä
+ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚Ü‚·B
+B<-M> ƒtƒ‰ƒO‚Æ‹¤‚ÉŽg‚¤‚ÆAƒIƒvƒVƒ‡ƒ“‚Í
+Devel::foo ƒpƒbƒP[ƒW‚É“n‚³‚êADevel::foo::import ƒ‹[ƒ`ƒ“‚Å
+‰ðŽß‚³‚ê‚Ü‚·B
+ƒIƒvƒVƒ‡ƒ“‚ðƒRƒ“ƒ}‹æØ‚è‚̃ŠƒXƒg‚É‚·‚é‚Æ‚«‚Í C<=> ‚Ì•¶Žš‚Ì
+Œã‚É‘±‚¯‚È‚¯‚ê‚΂Ȃè‚Ü‚¹‚ñBL<perldebug> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-D>I<letters>
+
+=item B<-D>I<number>
+
+=begin original
+
+sets debugging flags. To watch how it executes your program, use
+B<-Dtls>. (This works only if debugging is compiled into your
+Perl.) Another nice value is B<-Dx>, which lists your compiled
+syntax tree. And B<-Dr> displays compiled regular expressions;
+the format of the output is explained in L<perldebguts>.
+
+=end original
+
+ƒfƒoƒbƒOƒtƒ‰ƒO‚ðݒ肵‚Ü‚·B
+ƒXƒNƒŠƒvƒg‚ª‚ǂ̂悤‚ÉŽÀs‚³‚ê‚é‚©‚ðŒ©‚é‚É‚ÍA
+B<-Dtls> ‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B
+(‚±‚ê‚ÍAƒfƒoƒbƒO‹@”\‚ð·‚èž‚ñ‚Å
+ƒRƒ“ƒpƒCƒ‹‚µ‚½‚Æ‚«‚É‚¾‚¯“‚«‚Ü‚·B)
+‚±‚Ì‘¼‚É–ð‚É—§‚Â’l‚Æ‚µ‚Ä‚ÍAƒRƒ“ƒpƒCƒ‹‚³‚ꂽ\•¶ƒcƒŠ[‚ð•\Ž¦‚·‚éA
+B<-Dx> ‚ª‚ ‚°‚ç‚ê‚Ü‚·B
+B<-Dr> ‚ÍAƒRƒ“ƒpƒCƒ‹‚µ‚½³‹K•\Œ»‚ð•\Ž¦‚µ‚Ü‚·B
+o—ÍŒ`Ž®‚ɂ‚¢‚Ä‚Í L<perldebguts> ‚Éà–¾‚ª‚ ‚è‚Ü‚·B
+
+=begin original
+
+As an alternative, specify a number instead of list of letters (e.g.,
+B<-D14> is equivalent to B<-Dtls>):
+
+=end original
+
+•¶Žš‚̃ŠƒXƒg‚Ì‘ã‚í‚è‚É”Žš‚ðŽw’è‚·‚邱‚Æ‚à‚Å‚«‚Ü‚·
+(‚½‚Æ‚¦‚ÎAB<-D14> ‚Í B<-Dtls> ‚Æ“™‰¿‚Å‚·):
+
+=begin original
+
+ 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
+ 2097152 C Copy On Write
+
+=end original
+
+ 1 p ƒg[ƒNƒ“‰»‚Æ\•¶‰ðÍ
+ 2 s ƒXƒ^ƒbƒN‚Ì•\Ž¦
+ v ‚Æ•¹—p‚³‚ê‚é‚ÆA‘S‚ẴXƒ^ƒbƒN‚Ì•\Ž¦
+ 4 l ƒRƒ“ƒeƒLƒXƒg(ƒ‹[ƒv)ƒXƒ^ƒbƒN‚̈—
+ 8 t ŽÀs‚̃gƒŒ[ƒX
+ 16 o ƒƒ\ƒbƒh‚ƃI[ƒo[ƒ[ƒh‚̉ðŒˆ
+ 32 c •¶Žš—ñ/”’l•ÏŠ·
+ 64 P ƒvƒƒtƒ@ƒCƒŠƒ“ƒOî•ñA-P ‚Ì‚½‚߂̃vƒŠƒvƒƒZƒbƒTƒRƒ}ƒ“ƒhAƒ\[ƒXƒtƒ@ƒCƒ‹“ü—Íó‘Ô‚Ì•\Ž¦
+ 128 m ƒƒ‚ƒŠ”z’u
+ 256 f ƒtƒH[ƒ}ƒbƒg‚̈—
+ 512 r ³‹K•\Œ»‚̉ðÍ‚ÆŽÀŒø
+ 1024 x \•¶ƒgƒŠ[‚̃_ƒ“ƒv
+ 2048 u ‰˜õƒ`ƒFƒbƒN
+ 4096 (ŒÃ‚¢‚à‚Ì: ˆÈ‘O‚Í LEAKTEST ‚ÉŽg‚í‚ê‚Ä‚¢‚½)
+ 8192 H ƒnƒbƒVƒ…‚̃_ƒ“ƒv -- values() ‚̉¡Žæ‚è
+ 16384 X ƒXƒNƒ‰ƒbƒ`ƒpƒbƒh‚Ì”z’u
+ 32768 D ‘SÁ‹Ž
+ 65536 S ƒXƒŒƒbƒh“¯Šú
+ 131072 T ƒg[ƒNƒ“‰»
+ 262144 R ƒ_ƒ“ƒv‚³‚ꂽ•Ï”‚̃Šƒtƒ@ƒŒƒ“ƒXƒJƒEƒ“ƒg‚ðŠÜ‚Þ(-Ds‚Ì‚Æ‚«)
+ 524288 J DB ƒpƒbƒP[ƒW‚Ì’†‚Å‚Í s,t,P ƒfƒoƒbƒOƒR[ƒh‚ðŽÀs‚µ‚È‚¢
+ 1048576 v Ú×: ‘¼‚̃tƒ‰ƒO‚Æ‘g‚݇‚킹‚ÄŽg‚¤
+ 2097152 C ƒRƒs[ƒIƒ“ƒ‰ƒCƒg
+
+=begin original
+
+All these flags require B<-DDEBUGGING> when you compile the Perl
+executable (but see L<Devel::Peek>, L<re> which may change this).
+See the F<INSTALL> file in the Perl source distribution
+for how to do this. This flag is automatically set if you include B<-g>
+option when C<Configure> asks you about optimizer/debugger flags.
+
+=end original
+
+‚±‚ê‚ç‚Ì‘S‚Ẵtƒ‰ƒO‚Í Perl ŽÀsƒtƒ@ƒCƒ‹‚ðƒRƒ“ƒpƒCƒ‹‚·‚é‚Æ‚«‚É
+B<-DDEBUGGING> ‚ªŽw’肳‚ê‚Ä‚¢‚é•K—v‚ª‚ ‚è‚Ü‚·
+(’A‚µ‚±‚ê‚ð•ÏX‚·‚é‚Æ‚«‚Í L<Devel::Peek>, L<re> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢)B
+‚»‚¤‚·‚邽‚ß‚É‚Ç‚¤‚·‚ê‚΂¢‚¢‚©‚ɂ‚¢‚Ä‚Í Perl ‚̃\[ƒX”z•zƒpƒbƒP[ƒW‚Ì
+F<INSTALL> ƒtƒ@ƒCƒ‹‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+‚±‚̃tƒ‰ƒO‚Í C<Configure> ‚ªÅ“K‰»/ƒfƒoƒbƒKƒtƒ‰ƒO‚ðq‚Ë‚½‚Æ‚«‚É
+B<-g> ƒIƒvƒVƒ‡ƒ“ž‚Ý‚ÅŽw’è‚·‚ê‚ÎŽ©“®“I‚ɃZƒbƒg‚³‚ê‚Ü‚·B
+
+=begin original
+
+If you're just trying to get a print out of each line of Perl code
+as it executes, the way that C<sh -x> provides for shell scripts,
+you can't use Perl's B<-D> switch. Instead do this
+
+=end original
+
+ƒVƒFƒ‹ƒXƒNƒŠƒvƒg‚É‚¨‚¯‚é C<sh -x> ‚̂悤‚ÉA
+’P‚É¡ŽÀs‚µ‚Ä‚¢‚é Perl ‚̃R[ƒh‚ð•\Ž¦‚µ‚½‚¢ê‡‚ÍA
+Perl ‚Ì B<-D> ƒXƒCƒbƒ`‚ÍŽg‚¦‚Ü‚¹‚ñB‘ã‚í‚è‚Ɉȉº‚̂悤‚É‚µ‚Ä‚‚¾‚³‚¢:
+
+ # If you have "env" utility
+ env=PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
+
+ # Bourne shell syntax
+ $ PERLDB_OPTS="NonStop=1 AutoTrace=1 frame=2" perl -dS program
+
+ # csh syntax
+ % (setenv PERLDB_OPTS "NonStop=1 AutoTrace=1 frame=2"; perl -dS program)
+
+=begin original
+
+See L<perldebug> for details and variations.
+
+=end original
+
+ÚׂƃoƒŠƒG[ƒVƒ‡ƒ“‚ɂ‚¢‚Ä‚Í L<perldebug> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-e> I<commandline>
+
+=begin original
+
+may be used to enter one line of program. If B<-e> is given, Perl
+will not look for a filename in the argument list. Multiple B<-e>
+commands may be given to build up a multi-line script. Make sure
+to use semicolons where you would in a normal program.
+
+=end original
+
+1 s‚̃vƒƒOƒ‰ƒ€‚ðŽw’è‚·‚é‚Ì‚ÉŽg—p‚µ‚Ü‚·B
+B<-e> ‚ªŽw’肳‚ê‚é‚Æ Perl ‚͈ø”‚̃ŠƒXƒg‚©‚ç‚̓tƒ@ƒCƒ‹–¼‚ð’T‚µ‚Ü‚¹‚ñB
+•¡”‚Ì -e ƒRƒ}ƒ“ƒh‚ÅA•¡”s‚̃XƒNƒŠƒvƒg‚ð\¬‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+’Êí‚̃vƒƒOƒ‰ƒ€‚ŃZƒ~ƒRƒƒ“‚ð’u‚‚Æ‚±‚ë‚É‚ÍAƒZƒ~ƒRƒƒ“‚ðŽg‚¤‚±‚Æ‚É
+‹C‚ð•t‚¯‚Ä‚‚¾‚³‚¢B
+
+=item B<-F>I<pattern>
+
+=begin original
+
+specifies the pattern to split on if B<-a> is also in effect. The
+pattern may be surrounded by C<//>, C<"">, or C<''>, otherwise it will be
+put in single quotes.
+
+=end original
+
+B<-a> ‚à—LŒø‚È‚Æ‚«‚ÉAsplit ‚ðs‚È‚¤³‹K•\Œ»‚ðŽw’肵‚Ü‚·B
+ƒpƒ^[ƒ“‚Í C<//>, C<"">, C<''> ‚ň͂ނ©A
+ƒVƒ“ƒOƒ‹ƒNƒH[ƒg‚Ì’†‚É‘‚«‚Ü‚·B
+
+=item B<-h>
+
+=begin original
+
+prints a summary of the options.
+
+=end original
+
+ƒIƒvƒVƒ‡ƒ“‚̈ꗗ‚ð•\Ž¦‚µ‚Ü‚·B
+
+=item B<-i>[I<extension>]
+
+=begin original
+
+specifies that files processed by the C<E<lt>E<gt>> construct are to be
+edited in-place. It does this by renaming the input file, opening the
+output file by the original name, and selecting that output file as the
+default for print() statements. The extension, if supplied, is used to
+modify the name of the old file to make a backup copy, following these
+rules:
+
+=end original
+
+C<E<lt>E<gt>> ‚Ì\•¶‚ň—‚³‚ꂽƒtƒ@ƒCƒ‹‚ð’u‚«Š·‚¦‚邽‚ß‚ÌŠg’£Žq‚ð
+Žw’肵‚Ü‚·B
+‚±‚ê‚ÍA“ü—̓tƒ@ƒCƒ‹‚ðƒŠƒl[ƒ€‚µAŒ³‚Ì–¼‘O‚Åo—̓tƒ@ƒCƒ‹‚ð open ‚µA
+print() •¶‚̃fƒtƒHƒ‹ƒg‚Æ‚µ‚Ä‚»‚Ìo—̓tƒ@ƒCƒ‹‚ð select ‚·‚邱‚Æ‚Ås‚È‚¢‚Ü‚·B
+extension ‚ªŽw’肳‚ê‚é‚ÆAÌ‚Ì“à—e‚̃oƒbƒNƒAƒbƒv‚ðs‚È‚¤
+ƒtƒ@ƒCƒ‹–¼‚ÌŠg’£Žq‚Æ‚µ‚ÄAŒ³‚̃tƒ@ƒCƒ‹–¼‚É•t‚¯‰Á‚¦‚ç‚ê‚Ü‚·B
+
+=begin original
+
+If no extension is supplied, no backup is made and the current file is
+overwritten.
+
+=end original
+
+extension ‚ªŽw’肳‚ê‚È‚¢‚ÆAƒoƒbƒNƒAƒbƒv‚ðì‚炸A
+Œ»Ý‚̃tƒ@ƒCƒ‹‚ªã‘‚«‚³‚ê‚Ü‚·B
+
+=begin original
+
+If the extension doesn't contain a C<*>, then it is appended to the
+end of the current filename as a suffix. If the extension does
+contain one or more C<*> characters, then each C<*> is replaced
+with the current filename. In Perl terms, you could think of this
+as:
+
+=end original
+
+extension ‚É C<*> ‚ªŠÜ‚Ü‚ê‚Ä‚¢‚È‚¢ê‡AŒ»Ý‚̃tƒ@ƒCƒ‹–¼‚Ì––”ö‚É
+Ú”öŽq‚Æ‚µ‚Ä•t‚¯‰Á‚¦‚ç‚ê‚Ü‚·B
+extension ‚ɈꂈÈã‚Ì C<*> ‚Ì•¶Žš‚ª‚ ‚éê‡A
+‚»‚ꂼ‚ê‚Ì C<*> ‚ÍŒ»Ý‚̃tƒ@ƒCƒ‹–¼‚Å’u‚«Š·‚¦‚ç‚ê‚Ü‚·B
+Perl “I‚É‘‚‚ÆAˆÈ‰º‚̂悤‚É‚È‚è‚Ü‚·:
+
+ ($backup = $extension) =~ s/\*/$file_name/g;
+
+=begin original
+
+This allows you to add a prefix to the backup file, instead of (or in
+addition to) a suffix:
+
+=end original
+
+ˆÈ‰º‚̂悤‚É‚·‚é‚ÆA(Ú”öŽq‚Ì‘ã‚í‚è‚ÉA‚ ‚é‚¢‚ÍÚ”öŽq‚ɉÁ‚¦‚Ä)
+ƒoƒbƒNƒAƒbƒvƒtƒ@ƒCƒ‹‚ÉÚ“ªŽq‚ð‚‚¯‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+
+ $ perl -pi'orig_*' -e 's/bar/baz/' fileA # backup to 'orig_fileA'
+
+=begin original
+
+Or even to place backup copies of the original files into another
+directory (provided the directory already exists):
+
+=end original
+
+Œ³‚̃tƒ@ƒCƒ‹‚̃oƒbƒNƒAƒbƒvƒRƒs[‚ð(Šù‚É‚ ‚é)‘¼‚̃fƒBƒŒƒNƒgƒŠ‚Éì‚邱‚Æ‚à
+‚Å‚«‚Ü‚·:
+
+ $ perl -pi'old/*.orig' -e 's/bar/baz/' fileA # backup to 'old/fileA.orig'
+
+=begin original
+
+These sets of one-liners are equivalent:
+
+=end original
+
+ˆÈ‰º‚̈êsƒXƒNƒŠƒvƒg‚Í‘S‚Ä“™‰¿‚Å‚·:
+
+ $ perl -pi -e 's/bar/baz/' fileA # overwrite current file
+ $ perl -pi'*' -e 's/bar/baz/' fileA # overwrite current file
+
+ $ perl -pi'.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig'
+ $ perl -pi'*.orig' -e 's/bar/baz/' fileA # backup to 'fileA.orig'
+
+=begin original
+
+From the shell, saying
+
+=end original
+
+ƒVƒFƒ‹‚©‚çˆÈ‰º‚̂悤‚É‹N“®‚·‚é‚Æ:
+
+ $ perl -p -i.orig -e "s/foo/bar/; ... "
+
+=begin original
+
+is the same as using the program:
+
+=end original
+
+ƒvƒƒOƒ‰ƒ€‚ňȉº‚̂悤‚É‚·‚é‚Ì‚Æ“¯‚¶‚Å:
+
+ #!/usr/bin/perl -pi.orig
+ s/foo/bar/;
+
+=begin original
+
+which is equivalent to
+
+=end original
+
+ˆÈ‰º‚Æ‚Ù‚Ú“™‰¿‚Å‚·:
+
+ #!/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);
+
+=begin original
+
+except that the B<-i> form doesn't need to compare $ARGV to $oldargv to
+know when the filename has changed. It does, however, use ARGVOUT for
+the selected filehandle. Note that STDOUT is restored as the default
+output filehandle after the loop.
+
+=end original
+
+ˆá‚¤‚Ì‚ÍAB<-i> ‚ÌŒ`Ž®‚ªA‚¢‚ƒtƒ@ƒCƒ‹–¼‚ª•Ï‚í‚Á‚½‚©‚ð’m‚邽‚ß‚ÉA
+$ARGV ‚Æ $oldargv ‚ð”äŠr‚·‚é•K—v‚ª‚È‚¢‚±‚Æ‚Å‚·B
+‚µ‚©‚µ‚È‚ª‚çA‘I‘ð‚·‚éƒtƒ@ƒCƒ‹ƒnƒ“ƒhƒ‹‚Æ‚µ‚Ä ARGVOUT ‚ÍŽg—p‚µ‚Ü‚·B
+ƒ‹[ƒv‚Ì‚ ‚Æ‚ÍASTDOUT ‚ªƒfƒtƒHƒ‹ƒg‚̃tƒ@ƒCƒ‹ƒnƒ“ƒhƒ‹‚Æ‚µ‚ÄÄݒ肳‚ê‚Ü‚·B
+
+=begin original
+
+As shown above, Perl creates the backup file whether or not any output
+is actually changed. So this is just a fancy way to copy files:
+
+=end original
+
+ãq‚Ì’Ê‚èAPerl ‚̓oƒbƒNƒAƒbƒvƒtƒ@ƒCƒ‹‚ðŽÀÛ‚Éo—Í‚ª•ÏX‚³‚ꂽ‚©
+‚Ç‚¤‚©‚ÉŠÖ‚í‚炸쬂µ‚Ü‚·B]‚Á‚ÄAˆÈ‰º‚̓tƒ@ƒCƒ‹‚ðƒRƒs[‚·‚é
+•Ï‚í‚Á‚½•û–@‚Æ‚È‚è‚Ü‚·:
+
+ $ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
+or
+ $ perl -p -i'.orig' -e 1 file1 file2 file3...
+
+=begin original
+
+You can use C<eof> without parentheses to locate the end of each input
+file, in case you want to append to each file, or reset line numbering
+(see example in L<perlfunc/eof>).
+
+=end original
+
+ŒÂX‚̃tƒ@ƒCƒ‹‚ÌI‚í‚è‚ɉ½‚©‚ð•t‚¯‰Á‚¦‚½‚¢‚Æ‚«‚âAs”Ô†‚ð
+ƒŠƒZƒbƒg‚µ‚½‚¢‚悤‚ÈꇂÉAŒÂX‚Ì“ü—̓tƒ@ƒCƒ‹‚ÌI‚í‚è‚ð’m‚邽‚ß‚ÉA
+Š‡ŒÊ‚Ì–³‚¢ C<eof> ‚ðŽg‚¤‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+(L<perlfunc/eof> ‚Ì—á‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B)
+
+=begin original
+
+If, for a given file, Perl is unable to create the backup file as
+specified in the extension then it will skip that file and continue on
+with the next one (if it exists).
+
+=end original
+
+—^‚¦‚ç‚ꂽƒtƒ@ƒCƒ‹‚ɑ΂µ‚ÄAPerl ‚ªŽw’肳‚ꂽŠg’£Žq‚ŃoƒbƒNƒAƒbƒvƒtƒ@ƒCƒ‹‚ð
+ì‚ê‚È‚¢ê‡A‚»‚̃tƒ@ƒCƒ‹‚̓XƒLƒbƒv‚³‚ê‚Ä
+(‚à‚µ‚ ‚ê‚Î)ŽŸ‚̃tƒ@ƒCƒ‹‚ɈڂÁ‚ÄŒp‘±‚µ‚Ü‚·B
+
+=begin original
+
+For a discussion of issues surrounding file permissions and B<-i>,
+see L<perlfaq5/Why does Perl let me delete read-only files? Why does -i clobber protected files? Isn't this a bug in Perl?>.
+
+=end original
+
+ƒtƒ@ƒCƒ‹‚̃p[ƒ~ƒbƒVƒ‡ƒ“‚Æ B<-i> ‚ÉŠÖ‚·‚é‹c˜_‚ɂ‚¢‚Ä‚ÍA
+L<perlfaq5/Why does Perl let me delete read-only files? Why does -i clobber protected files? Isn't this a bug in Perl?> ‚ð
+ŽQÆ‚µ‚ĉº‚³‚¢B
+
+=begin original
+
+You cannot use B<-i> to create directories or to strip extensions from
+files.
+
+=end original
+
+B<-i> ‚ÍAƒfƒBƒŒƒNƒgƒŠ‚ðì‚Á‚½‚èAƒtƒ@ƒCƒ‹‚ÌŠg’£Žq‚ðŽæ‚蜂¢‚½‚è‚Í
+‚Å‚«‚Ü‚¹‚ñB
+
+=begin original
+
+Perl does not expand C<~> in filenames, which is good, since some
+folks use it for their backup files:
+
+=end original
+
+Perl ‚Í C<~> ‚ð“WŠJ‚µ‚Ü‚¹‚ñB
+‚±‚ê‚̓oƒbƒNƒAƒbƒvƒtƒ@ƒCƒ‹‚ðˆÈ‰º‚̂悤‚É‚µ‚Äì‚élX‚Ì‚½‚ß‚É‚Í
+‚æ‚¢‚±‚Æ‚Å‚·B
+
+ $ perl -pi~ -e 's/foo/bar/' file1 file2 file3...
+
+=begin original
+
+Finally, the B<-i> switch does not impede execution when no
+files are given on the command line. In this case, no backup is made
+(the original file cannot, of course, be determined) and processing
+proceeds from STDIN to STDOUT as might be expected.
+
+=end original
+
+ÅŒã‚ÉAB<-i> ƒXƒCƒbƒ`‚ÍAƒRƒ}ƒ“ƒhƒ‰ƒCƒ“‚Ńtƒ@ƒCƒ‹‚ªŽw’肳‚ê‚È‚‚Ä‚à
+ŽÀs‚ð–W‚°‚Ü‚¹‚ñB‚±‚Ìê‡AƒoƒbƒNƒAƒbƒvƒtƒ@ƒCƒ‹‚Í쬂³‚ꂸ
+(‚à‚¿‚ë‚ñAŒ³‚̃tƒ@ƒCƒ‹‚ªŒˆ’è‚Å‚«‚Ü‚¹‚ñ)A
+—\‘z’Ê‚èASTDIN ‚©‚ç STDOUT ‚Ɉ—‚ªs‚í‚ê‚Ü‚·B
+
+=item B<-I>I<directory>
+
+=begin original
+
+Directories specified by B<-I> are prepended to the search path for
+modules (C<@INC>), and also tells the C preprocessor where to search for
+include files. The C preprocessor is invoked with B<-P>; by default it
+searches /usr/include and /usr/lib/perl.
+
+=end original
+
+B<-I> ‚ÅŽw’肳‚ꂽƒfƒBƒŒƒNƒgƒŠ‚̓‚ƒWƒ…[ƒ‹‚ÌŒŸõƒpƒX(C<@INC>)‚É
+‰Á‚¦‚ç‚êA‚Ü‚½ C ƒvƒŠƒvƒƒZƒbƒT‚ɃCƒ“ƒNƒ‹[ƒhƒtƒ@ƒCƒ‹‚ð’T‚·êŠ‚ðŽ¦‚µ‚Ü‚·B
+C ƒvƒŠƒvƒƒZƒbƒT‚Í B<-P> ‚Å‹N“®‚³‚ê‚Ü‚·B
+ƒfƒtƒHƒ‹ƒg‚Å‚Í /usr/include ‚Æ /usr/lib/perl ‚ð’T‚µ‚Ü‚·B
+
+=item B<-l>[I<octnum>]
+
+=begin original
+
+enables automatic line-ending processing. It has two separate
+effects. First, it automatically chomps C<$/> (the input record
+separator) when used with B<-n> or B<-p>. Second, it assigns C<$\>
+(the output record separator) to have the value of I<octnum> so
+that any print statements will have that separator added back on.
+If I<octnum> is omitted, sets C<$\> to the current value of
+C<$/>. For instance, to trim lines to 80 columns:
+
+=end original
+
+Ž©“®‚Ìs––ˆ—‚ðs‚È‚¤‚悤‚É‚µ‚Ü‚·B
+‚±‚ê‚É‚ÍA2 ‚‚̓Ɨ§‚µ‚½‹@”\‚ª‚ ‚è‚Ü‚·B
+1 ‚‚ɂÍAB<-n> ‚â B<-p> ‚ðŽg‚Á‚½‚Æ‚«‚ÉA
+Ž©“®“I‚ÉC<$/>(“ü—̓ŒƒR[ƒhƒZƒpƒŒ[ƒ^)‚ð chomp ‚µ‚Ü‚·B
+2 ‚Â‚ß‚É octnum ‚ð C<$\>(o—̓ŒƒR[ƒhƒZƒpƒŒ[ƒ^) ‚É‘ã“ü‚µA
+print •¶‚ŃZƒpƒŒ[ƒ^‚ð’ljÁ‚Å‚«‚é‚悤‚É‚µ‚Ü‚·B
+octnum ‚ðŽw’肵‚È‚©‚Á‚½ê‡‚É‚ÍA‚»‚ÌŽž“_‚Ì C<$/> ‚Ì’l‚ð
+C<$\> ‚Éݒ肵‚Ü‚·B
+‚½‚Æ‚¦‚ÎAs‚ð 80 ƒJƒ‰ƒ€‚ÉØ‚è‹l‚ß‚é‚ɂ͈ȉº‚̂悤‚É‚µ‚Ü‚·:
+
+ perl -lpe 'substr($_, 80) = ""'
+
+=begin original
+
+Note that the assignment C<$\ = $/> is done when the switch is processed,
+so the input record separator can be different than the output record
+separator if the B<-l> switch is followed by a B<-0> switch:
+
+=end original
+
+C<$\ = $/> ‚Æ‚¢‚¤‘ã“ü‚ÍAB<-l> ƒXƒCƒbƒ`‚ªˆ—‚³‚ê‚é‚Æ‚«‚É
+ŽÀs‚³‚ê‚é‚Æ‚«‚És‚È‚í‚ê‚Ü‚·‚Ì‚ÅAB<-l> ƒXƒCƒbƒ`‚ÌŒã‚É
+B<-0> ƒXƒCƒbƒ`‚ð’u‚‚悤‚É‚·‚ê‚ÎA“ü—̓ŒƒR[ƒhƒZƒpƒŒ[ƒ^‚ðA
+o—̓ŒƒR[ƒhƒZƒpƒŒ[ƒ^‚ƈႤ‚悤‚É‚à‚Å‚«‚Ü‚·:
+
+ gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
+
+=begin original
+
+This sets C<$\> to newline and then sets C<$/> to the null character.
+
+=end original
+
+‚±‚ê‚Í‚Ü‚¸AC<$\> ‚ɉüs (C<$/> ‚̃fƒtƒHƒ‹ƒg’l) ‚ðݒ肵A
+‚»‚ê‚©‚ç C<$/> ‚Ƀkƒ‹•¶Žš‚ðݒ肵‚Ü‚·B
+
+=item B<-m>[B<->]I<module>
+
+=item B<-M>[B<->]I<module>
+
+=item B<-M>[B<->]I<'module ...'>
+
+=item B<-[mM]>[B<->]I<module=arg[,arg]...>
+
+=begin original
+
+B<-m>I<module> executes C<use> I<module> C<();> before executing your
+program.
+
+=end original
+
+B<-m>I<module> ‚̓vƒƒOƒ‰ƒ€‚ÌŽÀs‘O‚É C<use> I<module> C<();> ‚ð
+ŽÀs‚µ‚Ü‚·B
+
+=begin original
+
+B<-M>I<module> executes C<use> I<module> C<;> before executing your
+program. You can use quotes to add extra code after the module name,
+e.g., C<'-Mmodule qw(foo bar)'>.
+
+=end original
+
+B<-M>I<module> ‚̓vƒƒOƒ‰ƒ€‚ÌŽÀs‘O‚É C<use> I<module> C<;> ‚ð
+ŽÀs‚µ‚Ü‚·Bƒ‚ƒWƒ…[ƒ‹–¼‚ÌŒã‚ë‚ɒljÁ‚̃R[ƒh‚ð‰Á‚¦‚邽‚ß‚É
+ƒNƒH[ƒg‚ðŽg‚¤‚±‚Æ‚à‚Å‚«‚Ü‚·B‚‚܂è C<'-Mmodule qw(foo bar)'> ‚È‚Ç‚Å‚·B
+
+=begin original
+
+If the first character after the B<-M> or B<-m> is a dash (C<->)
+then the 'use' is replaced with 'no'.
+
+=end original
+
+B<-M> ‚Ü‚½‚Í B<-m> ‚ÌŒã‚Ìʼn‚Ì•¶Žš‚ªƒ_ƒbƒVƒ…(C<->)‚Ìê‡A
+'use' ‚Ì‘ã‚í‚è‚É 'no' ‚ªŽg‚í‚ê‚Ü‚·B
+
+=begin original
+
+A little builtin syntactic sugar means you can also say
+B<-mmodule=foo,bar> or B<-Mmodule=foo,bar> as a shortcut for
+C<'-Mmodule qw(foo bar)'>. This avoids the need to use quotes when
+importing symbols. The actual code generated by B<-Mmodule=foo,bar> is
+C<use module split(/,/,q{foo,bar})>. Note that the C<=> form
+removes the distinction between B<-m> and B<-M>.
+
+=end original
+
+¬‚³‚¢‘g‚Ýž‚Ý‚Ì•¶–@“IƒVƒ…ƒK[‚Æ‚µ‚ÄA
+C<'-Mmodule qw(foo bar)'> ‚Ì‘ã‚í‚è‚É
+B<-mmodule=foo,bar> ‚Ü‚½‚Í B<-Mmodule=foo,bar> ‚Æ‘‚‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+‚±‚ê‚ÅAƒCƒ“ƒ|[ƒg‚·‚éƒVƒ“ƒ{ƒ‹‚ɃNƒH[ƒg‚ðŽg‚í‚È‚‚Ä‚à‚æ‚¢‚悤‚É‚È‚è‚Ü‚·B
+B<-Mmodule=foo,bar> ‚Ŷ¬‚³‚ê‚éŽÀۂ̃R[ƒh‚Í
+C<use module split(/,/,q{foo,bar})> ‚Å‚·B
+C<=> ‚ÌŒ`‚Í B<-m> ‚Æ B<-M> ‚̊Ԃ̈Ⴂ‚ðŽæ‚蜂‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item B<-n>
+
+=begin original
+
+causes Perl to assume the following loop around your program, which
+makes it iterate over filename arguments somewhat like B<sed -n> or
+B<awk>:
+
+=end original
+
+ˆÈ‰º‚̂悤‚ȃ‹[ƒv‚ªAŽÀۂ̃vƒƒOƒ‰ƒ€‚̉ñ‚è‚É‚ ‚é‚©‚̂悤‚É
+Perl ‚ÉŽwŽ¦‚µ‚Ü‚·B
+B<sed -n> ‚â B<awk> ‚̂悤‚Ƀtƒ@ƒCƒ‹–¼ˆø”ã‚ÅŒJ‚è•Ô‚µ‚ð
+s‚È‚¤‚±‚Æ‚É‚È‚è‚Ü‚·:
+
+ LINE:
+ while (<>) {
+ ... # your program goes here
+ }
+
+=begin original
+
+Note that the lines are not printed by default. See B<-p> to have
+lines printed. If a file named by an argument cannot be opened for
+some reason, Perl warns you about it and moves on to the next file.
+
+=end original
+
+ƒfƒtƒHƒ‹ƒg‚Å‚ÍAŠes‚ªˆóŽš‚³‚ê‚邱‚Æ‚Í‚ ‚è‚Ü‚¹‚ñB
+Šes‚̈󎚂ðs‚È‚¤‚É‚Í B<-p> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+ˆø”‚ÅŽw’肳‚ꂽƒtƒ@ƒCƒ‹‚ª‚È‚ñ‚ç‚©‚Ì——R‚ŃI[ƒvƒ“‚Å‚«‚È‚©‚Á‚½ê‡A
+Perl ‚ÍŒx‚ðo‚µ‚ÄŽŸ‚̃tƒ@ƒCƒ‹‚Ɉڂè‚Ü‚·B
+
+=begin original
+
+Here is an efficient way to delete all files that haven't been modifed for
+at least a week:
+
+=end original
+
+ˆÈ‰º‚É‚ ‚°‚é‚Ì‚ÍA‚È‚‚Æ‚à 1 TŠÔˆÈãXV‚³‚ê‚Ä‚¢‚È‚¢ƒ@ƒCƒ‹‚ðŒø—¦“I‚É
+휂·‚é‚à‚Ì‚Å‚·:
+
+ find . -mtime +7 -print | perl -nle unlink
+
+=begin original
+
+This is faster than using the B<-exec> switch of B<find> because you don't
+have to start a process on every filename found. It does suffer from
+the bug of mishandling newlines in pathnames, which you can fix if
+you follow the example under B<-0>.
+
+=end original
+
+‚±‚ê‚ÍAƒtƒ@ƒCƒ‹–¼‚ªŒ©‚‚©‚邲‚ƂɃvƒƒZƒX‚ð‹N“®‚µ‚È‚‚ÄÏ‚Ý‚Ü‚·‚Ì‚ÅA
+B<find> ‚Ì B<-exec> ƒXƒCƒbƒ`‚ðŽg‚¤‚æ‚è‚à‘¬‚‚È‚è‚Ü‚·B
+‚±‚ê‚̓pƒX–¼‚ɉüsƒR[ƒh‚ª‚ ‚é‚Æ‚¤‚Ü‚ˆµ‚¦‚È‚¢ƒoƒO‚̉e‹¿‚ðŽó‚¯‚Ü‚·‚Ì‚ÅA
+B<-O> ‚Ì—á‚É]‚¤‚±‚Æ‚ÅC³‚Å‚«‚Ü‚·B
+
+=begin original
+
+C<BEGIN> and C<END> blocks may be used to capture control before or after
+the implicit program loop, just as in B<awk>.
+
+=end original
+
+B<awk> ‚Æ“¯‚¶‚悤‚ÉAˆÃ–Ù‚ÉŽÀs‚³‚ê‚éƒvƒƒOƒ‰ƒ€ƒ‹[ƒv‚Ì‘OŒã‚É
+ŽÀs‚³‚ê‚éƒR[ƒh‚ðŽw’è‚·‚邽‚ß‚ÉAC<BEGIN> ƒuƒƒbƒN‚Æ
+C<END> ƒuƒƒbƒN‚ðŽg‚¤‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=item B<-p>
+
+=begin original
+
+causes Perl to assume the following loop around your program, which
+makes it iterate over filename arguments somewhat like B<sed>:
+
+=end original
+
+ˆÈ‰º‚̂悤‚ȃ‹[ƒv‚ªAŽÀۂ̃vƒƒOƒ‰ƒ€‚̉ñ‚è‚É‚ ‚é‚©‚̂悤‚É
+Perl ‚ÉŽwŽ¦‚µ‚Ü‚·B
+B<sed> ‚̂悤‚Ƀtƒ@ƒCƒ‹–¼ˆø”ã‚ÅŒJ‚è•Ô‚µ‚ðs‚È‚¤‚±‚Æ‚É‚È‚è‚Ü‚·:
+
+
+ LINE:
+ while (<>) {
+ ... # your program goes here
+ } continue {
+ print or die "-p destination: $!\n";
+ }
+
+=begin original
+
+If a file named by an argument cannot be opened for some reason, Perl
+warns you about it, and moves on to the next file. Note that the
+lines are printed automatically. An error occurring during printing is
+treated as fatal. To suppress printing use the B<-n> switch. A B<-p>
+overrides a B<-n> switch.
+
+=end original
+
+ˆø”‚ÅŽw’肳‚ꂽƒtƒ@ƒCƒ‹‚ª‰½‚ç‚©‚Ì——R‚ŃI[ƒvƒ“‚Å‚«‚È‚¢ê‡A
+Perl ‚ÍŒx‚ðo‚µAŽŸ‚̃tƒ@ƒCƒ‹‚Ɉڂè‚Ü‚·B
+Šes‚ÍAŽ©“®“I‚Ɉ󎚂³‚ê‚邱‚Æ‚É‚È‚è‚Ü‚·B
+ˆóŽš’†‚̃Gƒ‰[‚Í’v–½“I‚Æ‚Ý‚È‚³‚ê‚Ü‚·B
+ˆóŽš‚ð—}§‚·‚é‚É‚ÍAB<-n> ƒXƒCƒbƒ`‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B
+B<-p> ‚Í B<-n> ƒXƒCƒbƒ`‚𖳌ø‚É‚µ‚Ü‚·B
+
+=begin original
+
+C<BEGIN> and C<END> blocks may be used to capture control before or after
+the implicit loop, just as in B<awk>.
+
+=end original
+
+B<awk> ‚Æ“¯‚¶‚悤‚ÉAˆÃ–Ù‚ÉŽÀs‚³‚ê‚郋[ƒv‚Ì‘OŒã‚É
+ŽÀs‚³‚ê‚éƒR[ƒh‚ðŽw’è‚·‚邽‚ß‚ÉAC<BEGIN> ƒuƒƒbƒN‚Æ
+C<END> ƒuƒƒbƒN‚ðŽg‚¤‚±‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=item B<-P>
+
+=begin original
+
+B<NOTE: Use of -P is strongly discouraged because of its inherent
+problems, including poor portability.>
+
+=end original
+
+B<’ˆÓ: -P ‚ÌŽg—p‚Í‘S‚‘E‚ß‚ç‚ê‚Ü‚¹‚ñB‚È‚º‚È‚ç’á‚¢ˆÚA«‚ðŠÜ‚ÞA
+æ“V“I‚È–â‘肪‚ ‚é‚©‚ç‚Å‚·>
+
+=begin original
+
+This option causes your program to be run through the C preprocessor before
+compilation by Perl. Because both comments and B<cpp> directives begin
+with the # character, you should avoid starting comments with any words
+recognized by the C preprocessor such as C<"if">, C<"else">, or C<"define">.
+
+=end original
+
+Perl ‚É‚æ‚éƒRƒ“ƒpƒCƒ‹‚ðs‚È‚¤‘O‚ÉAƒXƒNƒŠƒvƒg‚ð C ƒvƒŠƒvƒƒZƒbƒT‚É
+‚©‚¯‚é‚悤‚É‚µ‚Ü‚·B
+ƒRƒƒ“ƒg‚à cpp ‚̃fƒBƒŒƒNƒeƒBƒu‚à # ‚ÅŽn‚Ü‚è‚Ü‚·‚©‚çAƒRƒƒ“ƒg‚Ìʼn‚ð
+C ƒvƒŠƒvƒƒZƒbƒT‚ª”FŽ¯‚µ‚Ä‚µ‚Ü‚¤ C<"if">, C<"else">, C<"define">‚Æ‚¢‚Á‚½
+’PŒê‚ÅŽn‚ß‚é‚ׂ«‚Å‚Í‚ ‚è‚Ü‚¹‚ñB
+
+=begin original
+
+If you're considering using C<-P>, you might also want to look at the
+Filter::cpp module from CPAN.
+
+=end original
+
+C<-P> ‚ðŽg‚¤‚±‚Æ‚ðl‚¦‚Ä‚¢‚é‚È‚çACPAN ‚É‚ ‚é Filter::cpp ‚à
+ŽQÆ‚µ‚½‚Ù‚¤‚ª‚æ‚¢‚Å‚µ‚傤B
+
+=begin original
+
+The problems of -P include, but are not limited to:
+
+=end original
+
+-P ‚ªŽ‚–â‘è‚͈ȉº‚̂悤‚È‚à‚Ì‚ª‚ ‚è‚Ü‚·(‚±‚ꂾ‚¯‚Å‚Í‚ ‚è‚Ü‚¹‚ñ):
+
+=over 10
+
+=item *
+
+=begin original
+
+The C<#!> line is stripped, so any switches there don't apply.
+
+=end original
+
+C<#!> s‚ªŽæ‚蜂©‚ê‚é‚Ì‚ÅA‘S‚ẴXƒCƒbƒ`‚Í“K—p‚³‚ê‚Ü‚¹‚ñB
+
+=item *
+
+=begin original
+
+A C<-P> on a C<#!> line doesn't work.
+
+=end original
+
+C<#!> s‚É C<-P> ‚ð‘‚¢‚Ä‚à“®ì‚µ‚Ü‚¹‚ñB
+
+=item *
+
+=begin original
+
+B<All> lines that begin with (whitespace and) a C<#> but
+do not look like cpp commands, are stripped, including anything
+inside Perl strings, regular expressions, and here-docs .
+
+=end original
+
+(‹ó”’‚Æ) C<#> ‚ÅŽn‚Ü‚èAcpp ƒRƒ}ƒ“ƒh‚Å‚È‚¢ B<‘S‚Ä‚Ì> s‚ÍŽæ‚蜂©‚ê‚Ü‚·B
+Perl •¶Žš—ñ‚ⳋK•\Œ»‚âƒqƒ„ƒhƒLƒ…ƒƒ“ƒg‚Ì‚Æ“r’†‚Å‚àA‚Å‚·B
+
+=item *
+
+=begin original
+
+In some platforms the C preprocessor knows too much: it knows about
+the C++ -style until-end-of-line comments starting with C<"//">.
+This will cause problems with common Perl constructs like
+
+=end original
+
+‚Ü‚½AC ƒvƒƒZƒbƒT‚ª’m‚è‚·‚¬‚Ä‚¢‚éƒvƒ‰ƒbƒgƒtƒH[ƒ€‚à‚ ‚è‚Ü‚·B
+C++ ƒXƒ^ƒCƒ‹‚Ì C<"//"> ‚Æ‚¢‚¤us––‚܂ł̃Rƒƒ“ƒgv‚ð’m‚Á‚Ä‚¢‚éꇂł·B
+‚±‚Ìê‡AˆÈ‰º‚̂悤‚È—Ç‚‚ ‚é Perl ‚Ì\‘¢‚Å–â‘肪‹N‚±‚蓾‚Ü‚·:
+
+ s/foo//;
+
+=begin original
+
+because after -P this will became illegal code
+
+=end original
+
+‚È‚º‚È‚ç -P “K—pŒãˆÈ‰º‚̂悤‚È•s³‚ȃR[ƒh‚É‚È‚é‚©‚ç‚Å‚·B
+
+ s/foo
+
+=begin original
+
+The workaround is to use some other quoting separator than C<"/">,
+like for example C<"!">:
+
+=end original
+
+‰ñ”ðô‚Æ‚µ‚Ä‚ÍAƒNƒI[ƒg•¶Žš‚ð C<"/"> ˆÈŠO‚É‚·‚é•û–@‚ª‚ ‚è‚Ü‚·B
+ˆÈ‰º‚Å‚Í C<"!"> ‚É‚µ‚Ä‚¢‚Ü‚·:
+
+ s!foo!!;
+
+
+
+=item *
+
+=begin original
+
+It requires not only a working C preprocessor but also a working
+F<sed>. If not on UNIX, you are probably out of luck on this.
+
+=end original
+
+‚±‚ê‚Í C ƒvƒŠƒvƒƒZƒbƒT‚¾‚¯‚Å‚È‚AF<sed> ‚à“®ì‚·‚é•K—v‚ª‚ ‚è‚Ü‚·B
+UNIX ‚Å‚È‚¢ê‡A‚»‚̂悤‚ÈK‰^‚ÉŒb‚Ü‚ê‚È‚¢‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+
+=item *
+
+=begin original
+
+Script line numbers are not preserved.
+
+=end original
+
+ƒXƒNƒŠƒvƒg‚Ìs”Ô†‚Í•Û‘¶‚³‚ê‚Ü‚¹‚ñB
+
+=item *
+
+=begin original
+
+The C<-x> does not work with C<-P>.
+
+=end original
+
+C<-x> ‚Í C<-P> ‚Æ“¯Žž‚É‚Í“®ì‚µ‚Ü‚¹‚ñB
+
+=back
+
+=item B<-s>
+
+=begin original
+
+enables rudimentary switch parsing for switches on the command
+line after the program name but before any filename arguments (or before
+an argument of B<-->). This means you can have switches with two leading
+dashes (B<--help>). Any switch found there is removed from @ARGV and sets the
+corresponding variable in the Perl program. The following program
+prints "1" if the program is invoked with a B<-xyz> switch, and "abc"
+if it is invoked with B<-xyz=abc>.
+
+=end original
+
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ã‚̃vƒƒOƒ‰ƒ€–¼‚̌ォ‚çAƒtƒ@ƒCƒ‹–¼ˆø”
+(‚Ü‚½‚͈ø” B<-->) ‚Ì‘O‚܂ł̃XƒCƒbƒ`‚Ì‚½‚ß‚ÌAŒ´Žn“I‚ȉðÍ‚ð
+s‚È‚¦‚é‚悤‚É‚µ‚Ü‚·B
+‚±‚ê‚ÍA“ñ‚‚̃_ƒbƒVƒ…‚ª‘O‚ɂ‚ƒXƒCƒbƒ`(B<--help> ‚È‚Ç)‚à
+Žg‚¦‚邱‚Æ‚ðŽ¦‚µ‚Ü‚·B
+‚±‚±‚ÅŒ©‚‚©‚Á‚½ƒXƒCƒbƒ`‚ÍA
+ ＠ ARGV ‚©‚çŽæ‚蜂©‚êA‘Ήž‚·‚é Perl ƒvƒƒOƒ‰ƒ€‚Ì•Ï”‚É
+ݒ肳‚ê‚Ü‚·B@ˆÈ‰º‚̃vƒƒOƒ‰ƒ€‚ÍAB<-xyz> ‚Æ‚¢‚¤ƒXƒCƒbƒ`‚ð
+•t‚¯‚ÄŽÀs‚³‚ꂽŽž‚É‚¾‚¯A"1" ‚Æ•\Ž¦‚µA
+B<-xyz=abc> ‚Æ‹N“®‚³‚ꂽŽž‚É "abc" ‚Æ•\Ž¦‚µ‚Ü‚·B
+
+ #!/usr/bin/perl -s
+ if ($xyz) { print "$xyz\n" }
+
+=begin original
+
+Do note that B<--help> creates the variable ${-help}, which is not compliant
+with C<strict refs>.
+
+=end original
+
+B<--help> ‚Í•Ï” ${-help} ‚ð쬂·‚é‚Ì‚ÅAC<strict refs> ‚ð–ž‚½‚³‚È‚¢
+‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item B<-S>
+
+=begin original
+
+makes Perl use the PATH environment variable to search for the
+program (unless the name of the program contains directory separators).
+
+=end original
+
+Perl ‚ªƒvƒƒOƒ‰ƒ€‚ð’T‚·‚Æ‚«‚Ɋ‹«•Ï” PATH ‚ðŽQÆ‚·‚é‚悤‚É‚µ‚Ü‚·
+(ƒvƒƒOƒ‰ƒ€–¼‚ªƒfƒBƒŒƒNƒgƒŠƒZƒpƒŒ[ƒ^‚ðŠÜ‚Þ‚Æ‚«‚𜂫‚Ü‚·)B
+
+=begin original
+
+On some platforms, this also makes Perl append suffixes to the
+filename while searching for it. For example, on Win32 platforms,
+the ".bat" and ".cmd" suffixes are appended if a lookup for the
+original name fails, and if the name does not already end in one
+of those suffixes. If your Perl was compiled with DEBUGGING turned
+on, using the -Dp switch to Perl shows how the search progresses.
+
+=end original
+
+ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚É‚æ‚Á‚Ä‚ÍAPerl ‚̓tƒ@ƒCƒ‹‚ð’T‚·‚Æ‚«‚ÉŠg’£Žq‚ð
+’ljÁ‚µ‚Ü‚·B
+—Ⴆ‚Î Win32 ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚Å‚ÍA
+Œ³X‚̃tƒ@ƒCƒ‹–¼‚ÅŒŸõ‚ªŽ¸”s‚µ‚½ê‡A".bat" ‚Æ ".cmd" ‚ÌŠg’£Žq‚ª
+’ljÁ‚³‚ê‚Ü‚·B’A‚µŠù‚É‚»‚̂悤‚ÈŠg’£Žq‚ª‚‚¢‚Ä‚¢‚È‚¢ê‡‚¾‚¯‚Å‚·B
+Perl ‚ª DEBUGGING ‚ð—LŒø‚É‚µ‚ăRƒ“ƒpƒCƒ‹‚³‚ê‚Ä‚¢‚½ê‡A
+-Dp ƒXƒCƒbƒ`‚ðŽg‚¤‚±‚Ƃłǂ̂悤‚ÉŒŸõ‚ªs‚í‚ê‚Ä‚¢‚é‚©‚ð
+•\Ž¦‚³‚¹‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+
+=begin original
+
+Typically this is used to emulate #! startup on platforms that
+don't support #!. This example works on many platforms that
+have a shell compatible with Bourne shell:
+
+=end original
+
+‚±‚ê‚ÍA#! ‚ðƒTƒ|[ƒg‚µ‚Ä‚¢‚È‚¢ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚ÅA#! ‚É
+‚æ‚éŽÀs‚ðƒGƒ~ƒ…ƒŒ[ƒg‚·‚邽‚ß‚ÉŽg‚¢‚Ü‚·B
+‚±‚Ì—á‚Í Bourne shell ŒÝŠ·‚̃VƒFƒ‹‚ðŽ‚‘½‚‚̃vƒ‰ƒbƒgƒtƒH[ƒ€‚Å“®‚«‚Ü‚·:
+
+ #!/usr/bin/perl
+ eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
+ if $running_under_some_shell;
+
+=begin original
+
+The system ignores the first line and feeds the program to F</bin/sh>,
+which proceeds to try to execute the Perl program as a shell script.
+The shell executes the second line as a normal shell command, and thus
+starts up the Perl interpreter. On some systems $0 doesn't always
+contain the full pathname, so the B<-S> tells Perl to search for the
+program if necessary. After Perl locates the program, it parses the
+lines and ignores them because the variable $running_under_some_shell
+is never true. If the program will be interpreted by csh, you will need
+to replace C<${1+"$@"}> with C<$*>, even though that doesn't understand
+embedded spaces (and such) in the argument list. To start up sh rather
+than csh, some systems may have to replace the #! line with a line
+containing just a colon, which will be politely ignored by Perl. Other
+systems can't control that, and need a totally devious construct that
+will work under any of B<csh>, B<sh>, or Perl, such as the following:
+
+=end original
+
+ƒVƒXƒeƒ€‚ÍAʼn‚Ìs‚𖳎‹‚µAƒvƒƒOƒ‰ƒ€‚ð F</bin/sh> ‚É“n‚µA
+F</bin/sh> ‚Í Perl ƒvƒƒOƒ‰ƒ€‚ðƒVƒFƒ‹ƒvƒƒOƒ‰ƒ€‚Æ‚µ‚ÄŽÀs‚µ‚悤‚Æ‚µ‚Ü‚·B
+ƒVƒFƒ‹‚Í 2 s–Ú‚ð’Êí‚̃VƒFƒ‹ƒRƒ}ƒ“ƒh‚Æ‚µ‚ÄŽÀs‚µAPerl ƒCƒ“ƒ^ƒvƒŠƒ^‚ð
+‹N“®‚·‚邱‚Æ‚É‚È‚è‚Ü‚·B
+$0 ‚Ƀtƒ‹ƒpƒX–¼‚ª“ü‚Á‚Ä‚¢‚é‚Æ‚ÍŒÀ‚ç‚È‚¢ƒVƒXƒeƒ€‚à
+‚ ‚è‚Ü‚·‚Ì‚ÅA-S ‚ª Perl ‚É•K—v‚ɉž‚¶‚ăvƒƒOƒ‰ƒ€‚ð’T‚·‚悤‚ÉŽwŽ¦‚µ‚Ü‚·B
+Perl ‚ªƒvƒƒOƒ‰ƒ€‚ðŒ©‚Â‚¯‚é‚ÆA‚±‚ê‚ç‚Ìs‚̉ðÍ‚ðŽn‚ß‚Ü‚·‚ªA
+$running_under_some_shell ‚ª^‚ɂȂ邱‚Æ‚ª‚È‚¢‚½‚ßA
+–³Ž‹‚·‚邱‚Æ‚É‚È‚è‚Ü‚·B
+ƒvƒƒOƒ‰ƒ€‚ª csh ‚ʼnðŽß‚³‚ê‚éꇂɂÍA
+‚½‚Æ‚¦ƒtƒ@ƒCƒ‹–¼“à‚É–„‚ßž‚܂ꂽƒXƒy[ƒX‚È‚Ç‚ðˆµ‚¤‚±‚Æ‚ª‚Å‚«‚È‚‚Ä‚à
+C<${1+"$@"}> ‚ð C<$*> ‚Å’u‚«Š·‚¦‚é•K—v‚ª‚ ‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+csh ‚Å‚Í‚È‚Ash ‚ð‹N“®‚·‚é‚悤‚ÉA‚¢‚‚‚©‚̃VƒXƒeƒ€‚Å‚ÍA#! ‚Ìs‚ð
+Perl ‚à–³Ž‹‚·‚邱‚Æ‚É‚È‚Á‚Ä‚¢‚éAƒRƒƒ“‚¾‚¯‚Ìs‚Å’u‚«Š·‚¦‚é•K—v‚ª
+‚ ‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+‚»‚¤‚¢‚Á‚½§Œä‚ªŒø‚©‚È‚¢ƒVƒXƒeƒ€‚Å‚ÍAB<csh> ‚Å‚à B<sh> ‚Å‚à
+Perl ‚Å‚àŽg‚¦‚éA‰ñ‚è‚‚Ç‚¢•û–@‚ðŽg‚¤‚±‚Æ‚ª•K—v‚Å‚·:
+
+ eval '(exit $?0)' && eval 'exec perl -wS $0 ${1+"$@"}'
+ & eval 'exec /usr/bin/perl -wS $0 $argv:q'
+ if $running_under_some_shell;
+
+=begin original
+
+If the filename supplied contains directory separators (i.e., is an
+absolute or relative pathname), and if that file is not found,
+platforms that append file extensions will do so and try to look
+for the file with those extensions added, one by one.
+
+=end original
+
+ƒtƒ@ƒCƒ‹–¼‚ɃfƒBƒŒƒNƒgƒŠƒZƒpƒŒ[ƒ^‚ªŠÜ‚Ü‚ê‚Ä‚¢‚½ê‡
+(‚‚܂èâ‘΃pƒX‚Ü‚½‚Í‘Š‘΃pƒX‚¾‚Á‚½ê‡)A‚»‚µ‚Ä‚»‚̃tƒ@ƒCƒ‹‚ª
+‚È‚©‚Á‚½ê‡Aƒtƒ@ƒCƒ‹Šg’£Žq‚ð’ljÁ‚·‚éƒvƒ‰ƒbƒgƒtƒH[ƒ€‚Å‚Í
+‚ЂƂ‚¸‚Šg’£Žq‚ð’ljÁ‚µ‚ÄAƒtƒ@ƒCƒ‹‚ð’T‚µ‚Ü‚·B
+
+=begin original
+
+On DOS-like platforms, if the program does not contain directory
+separators, it will first be searched for in the current directory
+before being searched for on the PATH. On Unix platforms, the
+program will be searched for strictly on the PATH.
+
+=end original
+
+DOS •—‚̃vƒ‰ƒbƒgƒtƒH[ƒ€‚Å‚ÍAƒvƒƒOƒ‰ƒ€‚ɃfƒBƒŒƒNƒgƒŠƒZƒpƒŒ[ƒ^‚ª
+ŠÜ‚Ü‚ê‚Ä‚¢‚È‚©‚Á‚½ê‡APATH ‚ð’T‚·‘O‚Éʼn‚ɃJƒŒƒ“ƒgƒfƒBƒŒƒNƒgƒŠ‚ð
+’T‚µ‚Ü‚·B
+Unix ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚Å‚ÍAƒvƒƒOƒ‰ƒ€‚ÍŒµ–§‚É PATH ‚©‚ç‚Ì‚Ý
+’T‚³‚ê‚Ü‚·B
+
+=item B<-t>
+
+=begin original
+
+Like B<-T>, but taint checks will issue warnings rather than fatal
+errors. These warnings can be controlled normally with C<no warnings
+qw(taint)>.
+
+=end original
+
+B<-T> ‚Æ“¯—l‚Å‚·‚ªA‰˜õƒ`ƒFƒbƒN‚Í’v–½“IƒGƒ‰[‚Å‚Í‚È‚Œx‚ð
+”¶‚³‚¹‚Ü‚·B‚±‚ÌŒx‚Í’Êí’Ê‚è C<no warnings qw(taint)>‚ŧŒä‚Å‚«‚Ü‚·B
+
+=begin original
+
+B<NOTE: this is not a substitute for -T.> This is meant only to be
+used as a temporary development aid while securing legacy code:
+for real production code and for new secure code written from scratch
+always use the real B<-T>.
+
+=end original
+
+B<’ˆÓ: ‚±‚ê‚Í -T ‚Ì‘ã—p•i‚Å‚Í‚ ‚è‚Ü‚¹‚ñB> ‚±‚ê‚Í
+̂̃R[ƒh‚ðˆÀ‘S‚É‚·‚é‚̂𕂯‚邽‚߂Ɉꎞ“I‚ÉŽg—p‚³‚ê‚邽‚ß‚¾‚¯‚Ì‚à‚Ì‚Å‚·:
+–{“–‚Ì»•i”ŃR[ƒh‚Æʼn‚©‚ç‘‚ˆÀ‘S‚ȃR[ƒh‚Ì‚½‚ß‚É‚Í
+í‚É–{“–‚Ì B<-T> ‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B
+
+=item B<-T>
+
+=begin original
+
+forces "taint" checks to be turned on so you can test them. Ordinarily
+these checks are done only when running setuid or setgid. It's a
+good idea to turn them on explicitly for programs that run on behalf
+of someone else whom you might not necessarily trust, such as CGI
+programs or any internet servers you might write in Perl. See
+L<perlsec> for details. For security reasons, this option must be
+seen by Perl quite early; usually this means it must appear early
+on the command line or in the #! line for systems which support
+that construct.
+
+=end original
+
+u‰˜õvƒ`ƒFƒbƒN‚ðƒIƒ“‚É‚µ‚ÄAƒeƒXƒg‚Å‚«‚é‚悤‚É‚µ‚Ü‚·B
+’ÊíA‚±‚̃`ƒFƒbƒN‚Í setuid ‚â setgid ‚̃XƒNƒŠƒvƒg‚ðŽÀs‚·‚é‚Æ‚«‚É‚¾‚¯A
+s‚È‚í‚ê‚Ü‚·B
+CGI ƒvƒƒOƒ‰ƒ€‚âƒCƒ“ƒ^[ƒlƒbƒgƒT[ƒo[‚ð Perl ‚Å‘‚‚Æ‚«‚̂悤‚ÉA
+M—p‚Å‚«‚é‚Æ‚ÍŒÀ‚ç‚È‚¢l‚ª“®‚©‚·‚悤‚ȃvƒƒOƒ‰ƒ€‚Å‚Í
+‚±‚ê‚𖾎¦“I‚É—LŒø‚É‚·‚é‚Ì‚Í‚¢‚¢l‚¦‚Å‚·B
+Úׂɂ‚¢‚Ä‚Í L<perlsec> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+ƒZƒLƒ…ƒŠƒeƒBã‚Ì——R‚©‚çA‚±‚̃IƒvƒVƒ‡ƒ“‚Í Perl ‚É‚©‚È‚è
+‘‚“n‚³‚È‚¯‚ê‚ά‚è‚Ü‚¹‚ñB
+‚±‚ê‚Í’ÊíƒRƒ}ƒ“ƒhƒ‰ƒCƒ“‚Ìʼn‚Ì•û‚ɂ‚¯‚é‚©A
+#! \‘¢‚ɑΉž‚·‚éƒVƒXƒeƒ€‚Å‚Í‚±‚±‚É‘‚‚©‚Å‚·B
+
+=item B<-u>
+
+=begin original
+
+This obsolete switch causes Perl to dump core after compiling your
+program. You can then in theory take this core dump and turn it
+into an executable file by using the B<undump> program (not supplied).
+This speeds startup at the expense of some disk space (which you
+can minimize by stripping the executable). (Still, a "hello world"
+executable comes out to about 200K on my machine.) If you want to
+execute a portion of your program before dumping, use the dump()
+operator instead. Note: availability of B<undump> is platform
+specific and may not be available for a specific port of Perl.
+
+=end original
+
+‚±‚̌¢ƒXƒCƒbƒ`‚̓vƒƒOƒ‰ƒ€‚̃Rƒ“ƒpƒCƒ‹ŒãA
+ƒRƒAƒ_ƒ“ƒv‚ðs‚È‚¤‚悤‚É‚µ‚Ü‚·B
+—˜_“I‚É‚ÍA‚±‚̃RƒAƒ_ƒ“ƒv‚ðŽ‚Á‚Ä‚«‚Ä(Perl ‚Ì”z•z‚Å‚Í’ñ‹Ÿ‚³‚ê‚Ä‚¢‚Ü‚¹‚ñ‚ª)
+B<undump> ƒvƒƒOƒ‰ƒ€‚ðŽg‚Á‚ÄAŽÀsƒtƒ@ƒCƒ‹‚É•ÏŠ·‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+‚±‚ê‚Í‘½ƒfƒBƒXƒN—e—Ê‚ðH‚¢‚Ü‚·‚ª (ŽÀsƒtƒ@ƒCƒ‹‚ð sprit ‚·‚邱‚Æ‚Å
+‚µ‚ÍŒ¸‚è‚Ü‚·)AŽÀsŠJŽn‚𑬂‚·‚邱‚Æ‚ª‚Å‚«‚Ü‚·B
+(Œ¸‚炵‚Ä‚àA"hello world" ‚ÌŽÀsƒtƒ@ƒCƒ‹‚ÍAŽ„‚̃}ƒVƒ“‚Å 200K ’ö‚É
+‚È‚è‚Ü‚·B)
+ƒ_ƒ“ƒv‚·‚é‘O‚É•”•ª“I‚ɃvƒƒOƒ‰ƒ€‚ðŽÀs‚µ‚Ä‚¨‚«‚½‚¢ê‡‚É‚ÍA
+‚±‚̃XƒCƒbƒ`‚Ì‘ã‚í‚è‚É dump() ‰‰ŽZŽq‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B
+’ˆÓ:B<undump> ‚ªŽÀs‚Å‚«‚é‚Ì‚Í“Á’è‚̊‹«‰º‚Å‚·‚µA
+‚±‚ꂪŽg‚¦‚È‚¢ˆÚAƒo[ƒWƒ‡ƒ“‚Ì Perl ‚à‚ ‚é‚Å‚µ‚傤B
+
+=begin original
+
+This switch has been superseded in favor of the new Perl code
+generator backends to the compiler. See L<B> and L<B::Bytecode>
+for details.
+
+=end original
+
+‚±‚̃XƒCƒbƒ`‚̓Rƒ“ƒpƒCƒ‰‚̃oƒbƒNƒGƒ“ƒh‚Æ‚È‚éV‚µ‚¢ Perl ƒR[ƒh
+ƒWƒFƒlƒŒ[ƒ^‚Ì‹@”\‚É’u‚«Š·‚¦‚ç‚ê‚Ä‚¢‚Ü‚·B
+Úׂɂ‚¢‚Ä‚Í L<B> ‚Æ L<B::Bytecode> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-U>
+
+=begin original
+
+allows Perl to do unsafe operations. Currently the only "unsafe"
+operations are the unlinking of directories while running as superuser,
+and running setuid programs with fatal taint checks turned into
+warnings. Note that the B<-w> switch (or the C<$^W> variable) must
+be used along with this option to actually I<generate> the
+taint-check warnings.
+
+=end original
+
+Perl ‚ɈÀ‘S‚Å‚È‚¢‘€ì‚ð‹–‰Â‚µ‚Ü‚·B
+Œ»Ý‚Ì‚Æ‚±‚ëAuˆÀ‘S‚Å‚È‚¢v‘€ì‚É‚ÍA
+ƒX[ƒp[ƒ†[ƒU‚Æ‚µ‚ÄŽÀs’†‚ɃfƒBƒŒƒNƒgƒŠ‚ð휂·‚邱‚Æ‚ÆA
+’v–½“I‚ȉ˜õƒ`ƒFƒbƒN‚ðŒx‚É‘Ö‚¦‚ÄA
+setuid ƒvƒƒOƒ‰ƒ€‚ðŽÀs‚·‚邱‚Æ‚Å‚·B
+B<-w> ƒXƒCƒbƒ`(‚ ‚é‚¢‚Í C<$^W> •Ï”)‚Í
+‰˜õƒ`ƒFƒbƒN‚ÌŒx‚ªŽÀÛ‚É I<¶¬‚³‚ê‚é> ‚½‚ß‚É
+‚±‚̃IƒvƒVƒ‡ƒ“‚Æ‹¤‚ÉŽg‚í‚ê‚È‚¯‚ê‚΂Ȃè‚Ü‚¹‚ñB
+
+=item B<-v>
+
+=begin original
+
+prints the version and patchlevel of your perl executable.
+
+=end original
+
+Perl ŽÀsƒtƒ@ƒCƒ‹‚̃o[ƒWƒ‡ƒ“‚ƃpƒbƒ`ƒŒƒxƒ‹‚ð•\Ž¦‚µ‚Ü‚·B
+
+=item B<-V>
+
+=begin original
+
+prints summary of the major perl configuration values and the current
+values of @INC.
+
+=end original
+
+Perl ‚ÌŽå‚ÈÝ’è’l‚Æ @INC ‚ÌŒ»Ý‚Ì’l‚ð•\Ž¦‚µ‚Ü‚·B
+
+=item B<-V:>I<name>
+
+=begin original
+
+Prints to STDOUT the value of the named configuration variable.
+For example,
+
+=end original
+
+Žw’肳‚ꂽݒè•Ï”‚Ì’l‚ð STDOUT ‚É•\Ž¦‚µ‚Ü‚·B—Ⴆ‚Î:
+
+ $ perl -V:man.dir
+
+=begin original
+
+will provide strong clues about what your MANPATH variable should
+be set to in order to access the Perl documentation.
+
+=end original
+
+‚Í MANPATH ŠÂ‹«•Ï”‚ª Perl ‚̃hƒLƒ…ƒƒ“ƒg‚ɃAƒNƒZƒX‚·‚é‚Æ‚«‚É
+‚ǂ̂悤‚ɃZƒbƒg‚³‚ê‚é‚ׂ«‚©‚ɂ‚¢‚Ä‹—͂Ȏ肪‚©‚è‚ð—^‚¦‚Ü‚·B
+
+=item B<-w>
+
+=begin original
+
+prints warnings about dubious constructs, such as variable names
+that are mentioned only once and scalar variables that are used
+before being set, redefined subroutines, references to undefined
+filehandles or filehandles opened read-only that you are attempting
+to write on, values used as a number that doesn't look like numbers,
+using an array as though it were a scalar, if your subroutines
+recurse more than 100 deep, and innumerable other things.
+
+=end original
+
+1 “x‚µ‚©Žg‚í‚ê‚È‚¢•Ï”–¼Aݒ肳‚ê‚é‘O‚ÉŽg‚í‚ê‚Ä‚¢‚é•Ï”A
+ƒTƒuƒ‹[ƒeƒBƒ“‚ÌÄ’è‹`A–¢’è‹`‚̃tƒ@ƒCƒ‹ƒnƒ“ƒhƒ‹‚ÌŽQÆ‚âA
+read-only ‚ŃI[ƒvƒ“‚µ‚½ƒtƒ@ƒCƒ‹ƒnƒ“ƒhƒ‹‚Ö‚Ì‘‚«ž‚ÝA
+”’l‚ÉŒ©‚¦‚È‚¢’l‚ð”’l‚Æ‚µ‚ÄŽg‚Á‚½ê‡A”z—ñ‚ð
+ƒXƒJƒ‰‚Å‚ ‚é‚©‚̂悤‚ÉŽg‚Á‚½ê‡A
+100 ’iŠKˆÈã‚̃Tƒuƒ‹[ƒeƒBƒ“‚ÌÄ‹AA
+‚»‚Ì‘¼‚½‚‚³‚ñ‚Ì‹^‚킵‚¢Ž–‚ÉŒx‚ðo‚µ‚Ü‚·B
+
+=begin original
+
+This switch really just enables the internal C<$^W> variable. You
+can disable or promote into fatal errors specific warnings using
+C<__WARN__> hooks, as described in L<perlvar> and L<perlfunc/warn>.
+See also L<perldiag> and L<perltrap>. A new, fine-grained warning
+facility is also available if you want to manipulate entire classes
+of warnings; see L<warnings> or L<perllexwarn>.
+
+=end original
+
+‚±‚̃XƒCƒbƒ`‚ÍŽÀÛ‚É‚Í“à•”‚Ì C<$^W> •Ï”‚ð—LŒø‚É‚·‚邾‚¯‚Å‚·B
+C<__WARN__> ƒtƒbƒN‚ðŽg‚Á‚Ä“Á’è‚ÌŒx‚𖳌ø‚É‚µ‚½‚è
+’v–½“IƒGƒ‰[‚É‚µ‚½‚è‚Å‚«‚Ü‚·B
+‚±‚ê‚ɂ‚¢‚Ä‚Í L<perlvar> ‚Æ L<perlfunc/warn> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+L<perldiag> ‚Æ L<perltrap> ‚àŽQÆ‚µ‚ĉº‚³‚¢B
+‚à‚µŒx‚̃Nƒ‰ƒX‘S‘Ì‚ð‘€ì‚µ‚½‚¢‚È‚çAV‚µ‚—±“x‚Ìׂ©‚¢
+Œx‹@”\‚à‚ ‚è‚Ü‚·BL<warnings> ‚â L<perllexwarn> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-W>
+
+=begin original
+
+Enables all warnings regardless of C<no warnings> or C<$^W>.
+See L<perllexwarn>.
+
+=end original
+
+C<no warnings> ‚â C<$^W> ‚ÌÝ’è‚ÉŠÖ‚í‚炸‘S‚Ä‚ÌŒx‚ð—LŒø‚É‚µ‚Ü‚·B
+L<perllexwarn> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-X>
+
+=begin original
+
+Disables all warnings regardless of C<use warnings> or C<$^W>.
+See L<perllexwarn>.
+
+=end original
+
+C<use warnings> ‚â C<$^W> ‚ÌÝ’è‚ÉŠÖ‚í‚炸‘S‚Ä‚ÌŒx‚𖳌ø‚É‚µ‚Ü‚·B
+L<perllexwarn> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=item B<-x> I<directory>
+
+=begin original
+
+tells Perl that the program is embedded in a larger chunk of unrelated
+ASCII text, such as in a mail message. Leading garbage will be
+discarded until the first line that starts with #! and contains the
+string "perl". Any meaningful switches on that line will be applied.
+If a directory name is specified, Perl will switch to that directory
+before running the program. The B<-x> switch controls only the
+disposal of leading garbage. The program must be terminated with
+C<__END__> if there is trailing garbage to be ignored (the program
+can process any or all of the trailing garbage via the DATA filehandle
+if desired).
+
+=end original
+
+ƒ[ƒ‹‚̂悤‚È‘å‚«‚È–³ŠÖŒW‚ÌASCII ƒeƒLƒXƒg‚Ì‚©‚½‚Ü‚è‚Ì’†‚É
+ƒvƒƒOƒ‰ƒ€‚ª–„‚ßž‚Ü‚ê‚Ä‚¢‚鎖‚ð Perl ‚ɂ‚½‚¦‚Ü‚·B
+ʼn‚Ì #! ‚ÅŽn‚Ü‚èA"perl" ‚Æ‚¢‚¤•¶Žš—ñ‚ðŠÜ‚Þs‚Ü‚Å‚ÌA
+æs‚·‚éƒSƒ~‚ÍŽÌ‚Ä‚ç‚ê‚Ü‚·B
+‚»‚Ìs‚É‚ ‚éˆÓ–¡‚ðŽ‚ƒXƒCƒbƒ`‚Í“K—p‚³‚ê‚Ü‚·B
+directory ‚ªŽw’肳‚ê‚é‚ÆAPerl ‚̓vƒƒOƒ‰ƒ€‚ÌŽÀs‘O‚ÉA
+‚»‚̃fƒBƒŒƒNƒgƒŠ‚Ɉڂè‚Ü‚·B
+C<-x> ƒXƒCƒbƒ`‚Íæs‚·‚éƒSƒ~‚̈•ª‚ð§Œä‚·‚邾‚¯‚Å‚·B
+ƒvƒƒOƒ‰ƒ€‚ÌŒã‚É–³Ž‹‚·‚ׂ«ƒSƒ~‚ª‚ ‚éꇂɂÍA
+C<__END__> ‚ŃvƒƒOƒ‰ƒ€‚ðI—¹‚·‚é•K—v‚ª‚ ‚è‚Ü‚· (‚»‚ÌAŒã‚É‘±‚
+ƒSƒ~‚̈ꕔ‚Ü‚½‚Í‘S•”‚ÍA•K—v‚ɉž‚¶‚Ä DATA ƒtƒ@ƒCƒ‹ƒnƒ“ƒhƒ‹‚ð’Ê‚µ‚ÄA
+‚»‚̃vƒƒOƒ‰ƒ€‚ň—‚·‚鎖‚ª‚Å‚«‚Ü‚·)B
+
+=back
+
+=head1 ENVIRONMENT
+
+(ŠÂ‹«•Ï”)
+
+=over 12
+
+=item HOME
+
+=begin original
+
+Used if chdir has no argument.
+
+=end original
+
+chdir ‚̈ø”‚ª‚È‚¢‚Æ‚«‚ÉŽg‚í‚ê‚Ü‚·B
+
+=item LOGDIR
+
+=begin original
+
+Used if chdir has no argument and HOME is not set.
+
+=end original
+
+chdir ‚̈ø”‚ª‚È‚AHOME ‚ªƒZƒbƒg‚³‚ê‚Ä‚¢‚È‚¢‚Æ‚«‚ÉŽg‚í‚ê‚Ü‚·B
+
+=item PATH
+
+=begin original
+
+Used in executing subprocesses, and in finding the program if B<-S> is
+used.
+
+=end original
+
+ƒTƒuƒvƒƒZƒX‚ðŽÀs‚·‚é‚Æ‚«‚ÆAB<-S> ‚ªŽw’肳‚ꂽ‚Æ‚«‚ɃvƒƒOƒ‰ƒ€‚ð
+’T‚·‚Ì‚ÉŽg‚í‚ê‚Ü‚·B
+
+=item PERL5LIB
+
+=begin original
+
+A list of directories in which to look for Perl library
+files before looking in the standard library and the current
+directory. Any architecture-specific directories under the specified
+locations are automatically included if they exist. If PERL5LIB is not
+defined, PERLLIB is used. Directories are separated (like in PATH) by
+a colon on unixish platforms and by a semicolon on Windows (the proper
+path separator being given by the command C<perl -V:path_sep>).
+
+=end original
+
+Perl ‚̃‰ƒCƒuƒ‰ƒŠƒtƒ@ƒCƒ‹‚ð’T‚·‚Æ‚«‚É•W€ƒ‰ƒCƒuƒ‰ƒŠƒfƒBƒŒƒNƒgƒŠ‚Æ
+ƒJƒŒƒ“ƒgƒfƒBƒŒƒNƒgƒŠ‚ð’T‚·‘O‚É’T‚·ƒfƒBƒŒƒNƒgƒŠ‚̃ŠƒXƒg‚Å‚·B
+“Á’è‚Ìꊂɂ¨‚¯‚éƒA[ƒLƒeƒNƒ`ƒƒˆË‘¶‚̃fƒBƒŒƒNƒgƒŠ‚Í
+‚à‚µ‚ ‚ê‚ÎŽ©“®“I‚ɒljÁ‚³‚ê‚Ü‚·B
+PERL5LIB ‚ª’è‹`‚³‚ê‚Ä‚¢‚È‚¯‚ê‚ÎAPERLLIB ‚ªŽg‚í‚ê‚Ü‚·B
+ƒfƒBƒŒƒNƒgƒŠ‚Í(PATH ‚Æ“¯—l‚É)unix •—‚̃vƒ‰ƒbƒgƒtƒH[ƒ€‚ł̓Rƒƒ“‚Å‹æØ‚ç‚êA
+Windows ‚ł̓Zƒ~ƒRƒƒ“‚Å‹æØ‚ç‚ê‚Ü‚·(“K؂ȃpƒX‹æ؂蕶Žš‚Í
+C<perl -V:path_sep> ƒRƒ}ƒ“ƒh‚Å‚í‚©‚è‚Ü‚·)B
+
+=begin original
+
+When running taint checks (either because the program was running setuid
+or setgid, or the B<-T> switch was used), neither variable is used.
+The program should instead say:
+
+=end original
+
+(ƒvƒƒOƒ‰ƒ€‚ª setuid ‚Ü‚½‚Í setgid ‚ÅŽÀs‚³‚ê‚Ä‚¢‚é‚©A
+B<-T> ƒXƒCƒbƒ`‚ªŽw’肳‚ê‚Ä)‰˜õƒ`ƒFƒbƒN•t‚«‚Å“®ì‚µ‚Ä‚¢‚éê‡A
+‚Ç‚¿‚ç‚̊‹«•Ï”‚àŽg‚í‚ê‚Ü‚¹‚ñB
+‘ã‚í‚è‚ɃvƒƒOƒ‰ƒ€’†‚ňȉº‚̂悤‚É‚·‚é‚ׂ«‚Å‚·:
+
+ use lib "/my/directory";
+
+=item PERL5OPT
+
+=begin original
+
+Command-line options (switches). Switches in this variable are taken
+as if they were on every Perl command line. Only the B<-[DIMUdmtw]>
+switches are allowed. When running taint checks (because the program
+was running setuid or setgid, or the B<-T> switch was used), this
+variable is ignored. If PERL5OPT begins with B<-T>, tainting will be
+enabled, and any subsequent options ignored.
+
+=end original
+
+ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ƒIƒvƒVƒ‡ƒ“(ƒXƒCƒbƒ`)‚Å‚·B
+‚±‚Ì•Ï”‚̃XƒCƒbƒ`‚Í‘S‚Ä‚Ì Perl ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“‚ÅŽw’肳‚ꂽ‚©‚̂悤‚É
+ˆµ‚í‚ê‚Ü‚·B
+B<-[DIMUdmtw]> ƒIƒvƒVƒ‡ƒ“‚Ì‚Ý‚ª—LŒø‚Å‚·B
+(ƒvƒƒOƒ‰ƒ€‚ª setuid ‚Ü‚½‚Í setgid ‚ÅŽÀs‚³‚ê‚Ä‚¢‚é‚©A
+B<-T> ƒXƒCƒbƒ`‚ªŽw’肳‚ê‚Ä)‰˜õƒ`ƒFƒbƒN•t‚«‚Å“®ì‚µ‚Ä‚¢‚éê‡A
+‚±‚Ì•Ï”‚Í–³Ž‹‚³‚ê‚Ü‚·B
+PERL5OPT ‚ª B<-T> ‚ÅŽn‚Ü‚Á‚Ä‚¢‚éê‡A
+‰˜õƒ`ƒFƒbƒN‚ª—LŒø‚Æ‚È‚èAŽc‚è‚̃IƒvƒVƒ‡ƒ“‚Í–³Ž‹‚³‚ê‚Ü‚·B
+
+=item PERLIO
+
+=begin original
+
+A space (or colon) separated list of PerlIO layers. If perl is built
+to use PerlIO system for IO (the default) these layers effect perl's IO.
+
+=end original
+
+‹ó”’(‚Ü‚½‚̓Rƒƒ“)‚Å‹æØ‚ç‚ꂽ PerlIO ‘w‚̃ŠƒXƒg‚Å‚·B
+perl ‚ª IO ‚É PerlIO ƒVƒXƒeƒ€‚ðŽg‚¤‚悤‚ɃRƒ“ƒpƒCƒ‹‚³‚ê‚Ä‚¢‚éê‡
+(‚±‚ꂪƒfƒtƒHƒ‹ƒg‚Å‚·)A‚±‚ê‚ç‚Ì‘w‚ª perl ‚Ì IO ‚ɉe‹¿‚ð—^‚¦‚Ü‚·B
+
+=begin original
+
+It is conventional to start layer names with a colon e.g. C<:perlio> to
+emphasise their similarity to variable "attributes". But the code that parses
+layer specification strings (which is also used to decode the PERLIO
+environment variable) treats the colon as a separator.
+
+=end original
+
+•Ï”"‘®«"‚Æ‚Ì—ÞŽ—«‚ð‹’²‚·‚邽‚ß‚É‘w–¼‚ð C<:perlio> ‚̂悤‚ɃRƒƒ“‚Å
+Žn‚߂銵K‚ª‚ ‚è‚Ü‚·B‚µ‚©‚µƒvƒƒOƒ‰ƒ€‚Í‘w‚ð’è‹`‚·‚镶Žš—ñ‚̃p[ƒX‚·‚é
+(PERLIO ŠÂ‹«•Ï”‚̃fƒR[ƒh‚É‚àŽg‚í‚ê‚Ü‚·)‚Æ‚«‚ɃRƒƒ“‚ðƒZƒpƒŒ[ƒ^‚Æ‚µ‚Ä
+ˆµ‚¢‚Ü‚·B
+
+=begin original
+
+An unset or empty PERLIO is equivalent to C<:stdio>.
+
+=end original
+
+PERLIO ‚ðƒZƒbƒg‚µ‚È‚¢A‚Ü‚½‚͋󕶎š—ñ‚ðƒZƒbƒg‚·‚é‚ÆAC<:stdio> ‚Æ“™‰¿‚Å‚·B
+
+=begin original
+
+The list becomes the default for I<all> perl's IO. Consequently only built-in
+layers can appear in this list, as external layers (such as :encoding()) need
+IO in order to load them!. See L<"open pragma"|open> for how to add external
+encodings as defaults.
+
+=end original
+
+‚±‚̃ŠƒXƒg‚Í I<‘S‚Ä‚Ì> perl ‚Ì IO ‚̃fƒtƒHƒ‹ƒg‚Æ‚È‚è‚Ü‚·B
+]‚Á‚Ä‘g‚Ýž‚Ý‚Ì‘w‚Ì‚Ý‚ª‚±‚̃ŠƒXƒg‚É‹Lq‰Â”\‚Å‚·B
+‚È‚º‚È‚ç(:encoding() ‚̂悤‚È)ŠO•”“Ç‚Ýž‚Ý‚Ì‘w‚̓[ƒh‚·‚邽‚ß‚É
+IO ‚ª•K—v‚¾‚©‚ç‚Å‚·BƒfƒtƒHƒ‹ƒg‚Æ‚µ‚ÄŠO•”ƒGƒ“ƒR[ƒfƒBƒ“ƒO‚ð
+’ljÁ‚·‚é•û–@‚ɂ‚¢‚Ä‚Í L<"open pragma"|open> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=begin original
+
+The layers that it makes sense to include in the PERLIO environment
+variable are briefly summarised below. For more details see L<PerlIO>.
+
+=end original
+
+PERLIO ŠÂ‹«•Ï”‚ɉÁ‚¦‚邱‚Æ‚ª‘Ó–‚È‘w‚ÌŠÈ’P‚Ȉꗗ‚ðˆÈ‰º‚ÉŽ¦‚µ‚Ü‚·B
+Úׂɂ‚¢‚Ä‚Í L<PerlIO> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=over 8
+
+=item :bytes
+
+=begin original
+
+A pseudolayer that turns I<off> the C<:utf8> flag for the layer below.
+Unlikely to be useful on its own in the global PERLIO environment variable.
+You perhaps were thinking of C<:crlf:bytes> or C<:perlio:bytes>.
+
+=end original
+
+ˆÈ‰º‚ÉŽ¦‚· C<:utf8> ƒtƒ‰ƒO‚ð I<–³Œø‚É‚·‚é> ‚½‚ß‚Ì‹[Ž—‘w‚Å‚·B
+ƒOƒ[ƒoƒ‹‚È PERLIO ŠÂ‹«•Ï”‚É‚±‚ê‚ðŠÜ‚ß‚é‚Ì‚ª—L—p‚Èꇂ͂ ‚è‚»‚¤‚à‚È‚¢‚Å‚·B
+‚¨‚»‚ç‚ C<:crlf:bytes> ‚© C<:perlio:bytes> ‚Ì‚±‚Æ‚ðl‚¦‚Ä‚¢‚é‚Ì‚Å‚µ‚傤B
+
+=item :crlf
+
+=begin original
+
+A layer which does CRLF to "\n" translation distinguishing "text" and
+"binary" files in the manner of MS-DOS and similar operating systems.
+(It currently does I<not> mimic MS-DOS as far as treating of Control-Z
+as being an end-of-file marker.)
+
+=end original
+
+"ƒeƒLƒXƒg"‚Æ"ƒoƒCƒiƒŠ"ƒtƒ@ƒCƒ‹‚ðŽ¯•Ê‚·‚é CRLF ‚©‚ç "\n" ‚Ö‚Ì•ÏŠ·‚ð
+MS-DOS ‹y‚ÑŽ—‚½‚悤‚ȃIƒyƒŒ[ƒeƒBƒ“ƒOƒVƒXƒeƒ€‚Ì•ûŽ®‚Ås‚¤‘w‚Å‚·B
+(Œ»Ý‚Ì‚Æ‚±‚ë Control-Z ‚ðƒtƒ@ƒCƒ‹‚ÌI‚í‚è‚ÆŒ©‚È‚·‚Æ‚±‚ë‚Ü‚Å MS-DOS ‚ð
+‚Ü‚Ë‚Ä‚Í‚¢‚Ü‚¹‚ñB)
+
+=item :mmap
+
+=begin original
+
+A layer which implements "reading" of files by using C<mmap()> to
+make (whole) file appear in the process's address space, and then
+using that as PerlIO's "buffer".
+
+=end original
+
+ƒtƒ@ƒCƒ‹‚Ì"“Ç‚Ýž‚Ý"‚É C<mmap()> ‚ðŽg‚Á‚ătƒ@ƒCƒ‹(‘S‘Ì)‚ð
+ƒvƒƒZƒX‚̃AƒhƒŒƒX‹óŠÔ‚ÉŠ„‚è“–‚ÄA‚»‚ê‚ð PerlIO ‚Ì"ƒoƒbƒtƒ@"‚Æ‚µ‚Ä
+Žg‚¤‚½‚ß‚Ì‘w‚Å‚·B
+
+=item :perlio
+
+=begin original
+
+This is a re-implementation of "stdio-like" buffering written as a
+PerlIO "layer". As such it will call whatever layer is below it for
+its operations (typically C<:unix>).
+
+=end original
+
+‚±‚ê‚Í"stdio•—"‚̃oƒbƒtƒ@ƒŠƒ“ƒO‚ð PerlIO "‘w" ‚Æ‚µ‚ÄÄŽÀ‘•‚µ‚½‚à‚Ì‚Å‚·B
+]‚Á‚Ăǂ̂悤‚È‘w‚©‚ç‚à‘€ìŽž‚ɌĂÑo‚³‚ê‚Ü‚·(“TŒ^“I‚É‚Í C<:unix>)B
+
+=item :pop
+
+=begin original
+
+An experimental pseudolayer that removes the topmost layer.
+Use with the same care as is reserved for nitroglycerin.
+
+=end original
+
+擪‚Ì‘w‚𜋎‚·‚邽‚ß‚ÌŽÀŒ±“I‚È‹[Ž—‘w‚Å‚·B
+ƒjƒgƒƒOƒŠƒZƒŠƒ“‚ɑ΂·‚é‚Ì‚Æ“¯—l‚ÌTd‚³‚ðŽ‚Á‚ÄŽg‚Á‚Ä‚‚¾‚³‚¢B
+
+=item :raw
+
+=begin original
+
+A pseudolayer that manipulates other layers. Applying the <:raw>
+layer is equivalent to calling C<binmode($fh)>. It makes the stream
+pass each byte as-is without any translation. In particular CRLF
+translation, and/or :utf8 intuited from locale are disabled.
+
+=end original
+
+‘¼‚Ì‘w‚ð‘€ì‚·‚邽‚ß‚Ì‹[Ž—‘w‚Å‚·B C<:raw> ‘w‚ð“K—p‚·‚邱‚Æ‚Í
+C<binmode($fh)> ‚ðŒÄ‚Ño‚·‚Ì‚Æ“™‰¿‚Å‚·B
+‚±‚ê‚̓XƒgƒŠ[ƒ€‚ÌŠeƒoƒCƒg‚ð‰½‚Ì•ÏŠ·‚à‚È‚µ‚ɒʉ߂³‚¹‚Ü‚·B
+“Á‚É CRLF •ÏŠ·‚⃃P[ƒ‹‚©‚ç‚Ì :utf8 ‚ª–³Œø‚É‚È‚è‚Ü‚·B
+
+=begin original
+
+Unlike in the earlier versions of Perl C<:raw> is I<not>
+just the inverse of C<:crlf> - other layers which would affect the
+binary nature of the stream are also removed or disabled.
+
+=end original
+
+̂̃o[ƒWƒ‡ƒ“‚Ì Perl ‚ƈقȂèAC<:raw> ‚Í C<:crlf> ‚Ì‹t
+I<‚Å‚Í‚ ‚è‚Ü‚¹‚ñ> - ƒXƒgƒŠ[ƒ€‚̃oƒCƒiƒŠ‚Ì«Ž¿‚ɉe‹¿‚ð—^‚¦‚é
+‚»‚Ì‘¼‚Ì‘w‚àœ‹Ž‚³‚ê‚é‚©–³Œø‚É‚È‚è‚Ü‚·B
+
+=item :stdio
+
+=begin original
+
+This layer provides PerlIO interface by wrapping system's ANSI C "stdio"
+library calls. The layer provides both buffering and IO.
+Note that C<:stdio> layer does I<not> do CRLF translation even if that
+is platforms normal behaviour. You will need a C<:crlf> layer above it
+to do that.
+
+=end original
+
+‚±‚Ì‘w‚̓VƒXƒeƒ€‚Ì ANSI C "stdio" ƒ‰ƒCƒuƒ‰ƒŠƒR[ƒ‹‚ðƒ‰ƒbƒv‚µ‚½
+PerlIO ƒCƒ“ƒ^[ƒtƒF[ƒX‚ð’ñ‹Ÿ‚µ‚Ü‚·B
+‚±‚Ì‘w‚̓oƒbƒtƒ@ƒŠƒ“ƒO‚Æ IO ‚Ì—¼•û‚ð’ñ‹Ÿ‚µ‚Ü‚·B
+C<:stdio> ‘w‚Í CRLF •ÏŠ·‚ð I<s‚í‚È‚¢> ‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢B
+‚½‚Æ‚¦‚»‚ꂪƒvƒ‰ƒbƒgƒtƒH[ƒ€‚Ì’Êí‚ÌU‚é•‘‚¢‚Å‚ ‚Á‚Ä‚àA‚Å‚·B
+‚±‚ê‚ðs‚¤‚½‚ß‚É‚Í C<:crlf> ‘w‚ª•K—v‚Å‚·B
+
+=item :unix
+
+=begin original
+
+Low level layer which calls C<read>, C<write> and C<lseek> etc.
+
+=end original
+
+C<read>, C<write>, C<lseek> ‚È‚Ç‚ðŒÄ‚Ño‚·’჌ƒxƒ‹‘w‚Å‚·B
+
+=item :utf8
+
+=begin original
+
+A pseudolayer that turns on a flag on the layer below to tell perl
+that output should be in utf8 and that input should be regarded as
+already in utf8 form. May be useful in PERLIO environment
+variable to make UTF-8 the default. (To turn off that behaviour
+use C<:bytes> layer.)
+
+=end original
+
+o—Í‚ª utf8 ‚ÅA“ü—Í‚ÍŠù‚É utf8 ‚ÌŒ`‚É‚È‚Á‚Ä‚¢‚é‚ƉºˆÊ‚Ì‘w‚É“`‚¦‚é
+ƒtƒ‰ƒO‚ðƒIƒ“‚É‚·‚é‹[Ž—‘w‚Å‚·BPERLIO ŠÂ‹«•Ï”‚Å UTF-8 ‚ªƒfƒtƒHƒ‹ƒg‚Å‚ ‚é‚Æ
+ݒ肳‚ê‚Ä‚¢‚éꇂɗL—p‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+(‚±‚ÌU‚é•‘‚¢‚ðƒIƒt‚É‚·‚邽‚ß‚É‚Í C<:bytes> ‘w‚ðŽg‚Á‚Ä‚‚¾‚³‚¢B)
+
+=item :win32
+
+=begin original
+
+On Win32 platforms this I<experimental> layer uses native "handle" IO
+rather than unix-like numeric file descriptor layer. Known to be
+buggy in this release.
+
+=end original
+
+Win32 ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚É‚¨‚¢‚ÄA‚±‚Ì I<ŽÀŒ±“I> ‘w‚Í
+unix •—‚Ì”’l‚̃tƒ@ƒCƒ‹‹LqŽq‘w‚Ì‘ã‚í‚è‚ɃlƒCƒeƒBƒu‚È
+"ƒnƒ“ƒhƒ‹" IO ‚ðŽg—p‚µ‚Ü‚·B
+‚±‚̃ŠƒŠ[ƒX‚ł̓oƒO‚ª‚ ‚邱‚Æ‚ª‚í‚©‚Á‚Ä‚¢‚Ü‚·B
+
+=back
+
+=begin original
+
+On all platforms the default set of layers should give acceptable results.
+
+=end original
+
+‘S‚Ẵvƒ‰ƒbƒgƒtƒH[ƒ€‚ŃfƒtƒHƒ‹ƒg‚Ì‘w‚Ì‘g‚݇‚킹‚Í”[“¾‚Å‚«‚é
+Œ‹‰Ê‚É‚È‚Á‚Ä‚¢‚é‚Í‚¸‚Å‚·B
+
+=begin original
+
+For UNIX platforms that will equivalent of "unix perlio" or "stdio".
+Configure is setup to prefer "stdio" implementation if system's library
+provides for fast access to the buffer, otherwise it uses the "unix perlio"
+implementation.
+
+=end original
+
+UNIX ƒvƒ‰ƒbƒgƒtƒH[ƒ€‚Å‚Í‚±‚ê‚Í "unix perlio" ‚Ü‚½‚Í "stdio" ‚Æ“™‰¿‚Å‚·B
+configure ƒXƒNƒŠƒvƒg‚̓VƒXƒeƒ€‚̃‰ƒCƒuƒ‰ƒŠ‚ªƒoƒbƒtƒ@‚Ö‚Ì‚‘¬ƒAƒNƒZƒX•û–@‚ð
+’ñ‹Ÿ‚·‚éꇂÍ"stdio"ŽÀ‘•‚ðŽg‚¤‚悤ݒ肵A‚»‚¤‚Å‚È‚¯‚ê‚Î"unix perlio"
+ŽÀ‘•‚ðŽg‚¢‚Ü‚·B
+
+=begin original
+
+On Win32 the default in this release is "unix crlf". Win32's "stdio"
+has a number of bugs/mis-features for perl IO which are somewhat
+C compiler vendor/version dependent. Using our own C<crlf> layer as
+the buffer avoids those issues and makes things more uniform.
+The C<crlf> layer provides CRLF to/from "\n" conversion as well as
+buffering.
+
+=end original
+
+Win32 ‚ł̓fƒtƒHƒ‹ƒg‚Í"unix crlf"‚Å‚·B
+Win32 ‚Ì"stdio" ‚Í perl IO ‚É‚Æ‚Á‚ÄA
+C ƒRƒ“ƒpƒCƒ‰‚̃xƒ“ƒ_[/ƒo[ƒWƒ‡ƒ“ˆË‘¶‚Ì‘å—ʂ̃oƒO/Žd—l˜R‚ꂪ‚ ‚è‚Ü‚·B
+ƒoƒbƒtƒ@‚Æ‚µ‚ÄŽ©g‚Ì C<crlf> ‘w‚ðŽg‚¤‚±‚Æ‚Å‚±‚ê‚ç‚Ì–â‘è‚ð‰ñ”ð‚µA
+•¨Ž–‚ð‚æ‚èˆêŠÑ‚µ‚½‚à‚Ì‚É‚µ‚Ü‚·B
+C<crlf> ‘w‚̓oƒbƒtƒ@ƒŠƒ“ƒOŽž‚É CRLF ‚Æ "\n" ‚Ì•ÏŠ·‚ðs‚¢‚Ü‚·B
+
+=begin original
+
+This release uses C<unix> as the bottom layer on Win32 and so still uses C
+compiler's numeric file descriptor routines. There is an experimental native
+C<win32> layer which is expected to be enhanced and should eventually be
+the default under Win32.
+
+=end original
+
+‚±‚̃ŠƒŠ[ƒX‚Å‚Í Win32 ‚Å‚ÌŠî’ê‘w‚Æ‚µ‚Ä C<unix> ‚ðŽg‚¤‚±‚Æ‚ÅA
+–¢‚¾‚É C ƒRƒ“ƒpƒCƒ‰‚Ì”’l‚̃tƒ@ƒCƒ‹‹LqŽqƒ‹[ƒ`ƒ“‚ðŽg‚¢‚Ü‚·B
+Šg’£‚ð—\’肳‚ê‚Ä‚¢‚éŽÀŒ±“I‚ȃlƒCƒeƒBƒu‚Ì C<win32> ‘w‚ª‚ ‚èA
+ÅI“I‚É‚Í‚±‚ꂪ Win32 ‚ł̃fƒtƒHƒ‹ƒg‚Æ‚È‚é—\’è‚Å‚·B
+
+=item PERLIO_DEBUG
+
+=begin original
+
+If set to the name of a file or device then certain operations of PerlIO
+sub-system will be logged to that file (opened as append). Typical uses
+are UNIX:
+
+=end original
+
+ƒtƒ@ƒCƒ‹‚Ü‚½‚̓fƒoƒCƒX‚Ì–¼‘O‚ðƒZƒbƒg‚·‚é‚ÆAPerlIO ƒTƒuƒVƒXƒeƒ€‚Ì
+‚¢‚‚‚©‚Ì‘€ì‚ª‚»‚̃tƒ@ƒCƒ‹‚É(’Ç‹Lƒ‚[ƒh‚Å)‹L˜^‚³‚ê‚Ü‚·B
+UNIX ‚Å‚Ì“TŒ^“I‚ÈŽg‚¢•û‚͈ȉº‚Ì’Ê‚è‚Å‚·:
+
+ PERLIO_DEBUG=/dev/tty perl script ...
+
+=begin original
+
+and Win32 approximate equivalent:
+
+=end original
+
+Win32 ‚ł͈ȉº‚ª‚Ù‚Ú“™‰¿‚Å‚·:
+
+ set PERLIO_DEBUG=CON
+ perl script ...
+
+
+=item PERLLIB
+
+=begin original
+
+A list of directories in which to look for Perl library
+files before looking in the standard library and the current directory.
+If PERL5LIB is defined, PERLLIB is not used.
+
+=end original
+
+Perl ƒ‰ƒCƒuƒ‰ƒŠ‚ð’T‚·‚Ì‚É•W€ƒ‰ƒCƒuƒ‰ƒŠ‚ƃJƒŒƒ“ƒgƒfƒBƒŒƒNƒgƒŠ‚Ì‘O‚É
+ŒŸõ‚·‚éƒfƒBƒŒƒNƒgƒŠ‚̃ŠƒXƒg‚Å‚·B
+PERL5LIB ‚ª’è‹`‚³‚ê‚Ä‚¢‚é‚ÆAPERLLIB ‚ÍŽg‚í‚ê‚Ü‚¹‚ñB
+
+=item PERL5DB
+
+=begin original
+
+The command used to load the debugger code. The default is:
+
+=end original
+
+ƒfƒoƒbƒKƒR[ƒh‚ð“Ç‚Ýž‚Þ‚Ì‚ÉŽg‚í‚ê‚éƒRƒ}ƒ“ƒh‚Å‚·B
+ƒfƒtƒHƒ‹ƒg‚͈ȉº‚Ì’Ê‚è:
+
+ BEGIN { require 'perl5db.pl' }
+
+=item PERL5SHELL (specific to the Win32 port)
+
+=begin original
+
+May be set to an alternative shell that perl must use internally for
+executing "backtick" commands or system(). Default is C<cmd.exe /x/d/c>
+on WindowsNT and C<command.com /c> on Windows95. The value is considered
+to be space-separated. Precede any character that needs to be protected
+(like a space or backslash) with a backslash.
+
+=end original
+
+"ƒoƒbƒNƒNƒH[ƒg" ƒRƒ}ƒ“ƒh‚â system() ‚ðŽÀs‚·‚邽‚ß‚É
+Perl ‚ª“à•”“I‚ÉŽg‚í‚È‚¯‚ê‚΂Ȃç‚È‚¢‘ã‘ÖƒVƒFƒ‹‚ðŽw’肵‚Ü‚·B
+ƒfƒtƒHƒ‹ƒg‚Í WindowsNT ‚Å‚Í C<cmd.exe /x/d/c>AWindows95 ‚Å‚Í
+C<command.com /c> ‚Å‚·B
+’l‚̓Xƒy[ƒX‹æØ‚è‚Æl‚¦‚ç‚ê‚Ü‚·B
+(‹ó”’‚âƒoƒbƒNƒXƒ‰ƒbƒVƒ…‚̂悤‚È) •ÛŒì‚·‚é•K—v‚ª‚ ‚镶Žš‚Ì‘O‚É‚Í
+ƒoƒbƒNƒXƒ‰ƒbƒVƒ…‚ª‚‚¯‚ç‚ê‚Ü‚·B
+
+=begin original
+
+Note that Perl doesn't use COMSPEC for this purpose because
+COMSPEC has a high degree of variability among users, leading to
+portability concerns. Besides, perl can use a shell that may not be
+fit for interactive use, and setting COMSPEC to such a shell may
+interfere with the proper functioning of other programs (which usually
+look in COMSPEC to find a shell fit for interactive use).
+
+=end original
+
+COMSPEC ‚Ì’l‚̓†[ƒU[‚É‚æ‚Á‚Ä‚©‚È‚è—lX‚ÅAˆÚA«‚Ì–â‘è‚ðˆø‚«‹N‚±‚·‚Ì‚ÅA
+Perl ‚Í‚±‚Ì–Ú“I‚É COMSPEC ‚ÍŽg‚í‚È‚¢‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢B
+‚³‚ç‚ÉAPerl ‚͑Θb“I‚È—p“r‚É‚ÍŒü‚©‚È‚¢ƒVƒFƒ‹‚à—˜—p‚Å‚«‚Ü‚·‚ªA
+COMSPEC ‚É‚»‚̂悤‚ȃVƒFƒ‹‚ðŽw’è‚·‚é‚Æ‘¼‚̃vƒƒOƒ‰ƒ€
+(•’ʂ͑Θb“I‚È—p“r‚É“K‚µ‚½ƒVƒFƒ‹‚ð’T‚·‚Ì‚É COMSPEC ‚ðŽg‚¢‚Ü‚·)‚Ì“KØ‚È—˜—p‚ð
+Ž×–‚‚·‚é‚©‚à‚µ‚ê‚Ü‚¹‚ñB
+
+=item PERL_DEBUG_MSTATS
+
+=begin original
+
+Relevant only if perl is compiled with the malloc included with the perl
+distribution (that is, if C<perl -V:d_mymalloc> is 'define').
+If set, this causes memory statistics to be dumped after execution. If set
+to an integer greater than one, also causes memory statistics to be dumped
+after compilation.
+
+=end original
+
+Perl ‚ª Perl ”z•zƒpƒbƒP[ƒW‚ÉŠÜ‚Ü‚ê‚é malloc ƒ‹[ƒ`ƒ“‚ðŽg‚Á‚Ä
+ƒRƒ“ƒpƒCƒ‹‚³‚ê‚Ä‚¢‚éê‡(C<perl -V:d_mymalloc> ‚ª 'define' ‚Ìê‡)‚É‚Ì‚Ý
+—LŒø‚Å‚·B
+ݒ肳‚ê‚é‚ÆAŽÀsŒã‚Ƀƒ‚ƒŠó‹µ‚ª•\Ž¦‚³‚ê‚Ü‚·B
+1 ‚ð’´‚¦‚é”’l‚ªÝ’肳‚ê‚é‚ÆAƒRƒ“ƒpƒCƒ‹Œã‚É‚à
+ƒƒ‚ƒŠó‹µ‚ð•\Ž¦‚µ‚Ü‚·B
+
+=item PERL_DESTRUCT_LEVEL
+
+=begin original
+
+Relevant only if your perl executable was built with B<-DDEBUGGING>,
+this controls the behavior of global destruction of objects and other
+references. See L<perlhack/PERL_DESTRUCT_LEVEL> for more information.
+
+=end original
+
+Perl ‚ÌŽÀsƒtƒ@ƒCƒ‹‚ª B<-DDEBUGGING> •t‚«‚Å\’z‚³‚ꂽꇂɂ̂ݗLŒø‚Å‚·B
+‚±‚̃IƒvƒVƒ‡ƒ“‚̓IƒuƒWƒFƒNƒg‚â‚»‚Ì‘¼‚̃Šƒtƒ@ƒŒƒ“ƒX‚̃Oƒ[ƒoƒ‹‚È
+ƒfƒXƒgƒ‰ƒNƒ^‚ÌU‚é•‘‚¢‚ð§Œä‚µ‚Ü‚·B‚³‚ç‚È‚éî•ñ‚ɂ‚¢‚Ä‚Í
+L<perlhack/PERL_DESTRUCT_LEVEL> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item PERL_DL_NONLAZY
+
+=begin original
+
+Set to one to have perl resolve B<all> undefined symbols when it loads
+a dynamic library. The default behaviour is to resolve symbols when
+they are used. Setting this variable is useful during testing of
+extensions as it ensures that you get an error on misspelled function
+names even if the test suite doesn't call it.
+
+=end original
+
+1 ‚ɃZƒbƒg‚·‚é‚ÆA Perl ‚Í B<‘S‚Ä‚Ì> –¢’è‹`ƒVƒ“ƒ{ƒ‹‚ðƒ_ƒCƒiƒ~ƒbƒNƒ‰ƒCƒuƒ‰ƒŠ‚ð
+ƒ[ƒh‚µ‚½‚Æ‚«‚É‰ðŒˆ‚µ‚Ü‚·B
+ƒfƒtƒHƒ‹ƒg‚ÌU‚é•‘‚¢‚ÍŽg‚í‚ê‚é‚Æ‚«‚ɃVƒ“ƒ{ƒ‹‚ð‰ðŒˆ‚µ‚Ü‚·B
+‚±‚Ì•Ï”‚ðÝ’è‚·‚邱‚Æ‚ÅAŠg’£‹@”\‚̃eƒXƒgŽž‚ÉŠÖ”–¼‚̃Xƒyƒ‹ƒ~ƒX‚ð
+ƒeƒXƒgƒXƒC[ƒg‚ªŒÄ‚Ño‚³‚È‚‚Ä‚àƒGƒ‰[‚ðŠmŽÀ‚Ɏ󂯎æ‚邱‚Æ‚ª‚Å‚«‚é‚Ì‚Å
+•Ö—˜‚Å‚·B
+
+=item PERL_ENCODING
+
+=begin original
+
+If using the C<encoding> pragma without an explicit encoding name, the
+PERL_ENCODING environment variable is consulted for an encoding name.
+
+=end original
+
+C<encoding> ƒvƒ‰ƒOƒ}‚𖾎¦“I‚ȃGƒ“ƒR[ƒfƒBƒ“ƒO–¼‚ðŽw’肹‚¸‚É
+Žg—p‚µ‚½ê‡APERL_ENCODING ŠÂ‹«•Ï”‚ªƒGƒ“ƒR[ƒfƒBƒ“ƒO–¼‚Æ‚µ‚ÄŽg‚í‚ê‚Ü‚·B
+
+=item PERL_HASH_SEED
+
+=begin original
+
+(Since Perl 5.8.1.) Used to randomise Perl's internal hash function.
+To emulate the pre-5.8.1 behaviour, set to an integer (zero means
+exactly the same order as 5.8.0). "Pre-5.8.1" means, among other
+things, that hash keys will be ordered the same between different runs
+of Perl.
+
+=end original
+
+(Perl 5.8.1 ‚©‚ç) Perl ‚Ì“à•”ƒnƒbƒVƒ…ŠÖ”‚̃‰ƒ“ƒ_ƒ€‰»‚ÉŽg‚í‚ê‚Ü‚·B
+5.8.1 ˆÈ‘O‚ÌU‚é•‘‚¢‚ðƒGƒ~ƒ…ƒŒ[ƒg‚·‚邽‚ß‚É‚ÍA®”‚ðŽw’肵‚Ü‚·
+(ƒ[ƒ‚Í 5.8.0 ‚ÆŠ®‘S‚É“¯‚¶‡˜‚ðˆÓ–¡‚µ‚Ü‚·)B
+"5.8.1 ˆÈ‘O" ‚Æ‚¢‚¤‚Ì‚ÍA‚»‚Ì‘¼‚Ì‚±‚Æ‚àŠÜ‚ß‚ÄA
+Perl ‚ð‰½“xŽÀs‚µ‚Ä‚àƒnƒbƒVƒ…ƒL[‚Ì•À‚ч‚ª“¯‚¶‚Å‚ ‚邱‚Æ‚ðˆÓ–¡‚µ‚Ü‚·B
+
+=begin original
+
+The default behaviour is to randomise unless the PERL_HASH_SEED is set.
+If Perl has been compiled with C<-DUSE_HASH_SEED_EXPLICIT>, the default
+behaviour is B<not> to randomise unless the PERL_HASH_SEED is set.
+
+=end original
+
+ƒfƒtƒHƒ‹ƒg‚ÌU‚é•‘‚¢‚ÍA PERL_HASH_SEED ‚ªƒZƒbƒg‚³‚ê‚È‚¢ŒÀ‚è
+ƒ‰ƒ“ƒ_ƒ€‰»‚³‚ê‚Ü‚·BPerl ‚ª C<-DUSE_HASH_SEED_EXPLICIT> •t‚«‚Å
+ƒRƒ“ƒpƒCƒ‹‚³‚ꂽê‡AƒfƒtƒHƒ‹ƒg‚ÌU‚é•‘‚¢‚Í
+PERL_HASH_SEED ‚ªƒZƒbƒg‚³‚ê‚È‚¢ŒÀ‚胉ƒ“ƒ_ƒ€‰» B<‚³‚ê‚Ü‚¹‚ñ>B
+
+=begin original
+
+If PERL_HASH_SEED is unset or set to a non-numeric string, Perl uses
+the pseudorandom seed supplied by the operating system and libraries.
+This means that each different run of Perl will have a different
+ordering of the results of keys(), values(), and each().
+
+=end original
+
+PERL_HASH_SEED ‚ªƒZƒbƒg‚³‚ê‚È‚¢‚©A”’l‚Å‚È‚¢•¶Žš—ñ‚ªƒZƒbƒg‚³‚ꂽê‡A
+Perl ‚̓IƒyƒŒ[ƒeƒBƒ“ƒOƒVƒXƒeƒ€‚ƃ‰ƒCƒuƒ‰ƒŠ‚ª’ñ‹Ÿ‚·‚é‹[Ž——”‚Ì
+Ží‚ðŽg—p‚µ‚Ü‚·B
+‚±‚ê‚É‚æ‚èAPerl ‚ðŽÀs‚·‚é“x‚É keys(), values(), each() ‚ÌŒ‹‰Ê‚Ì
+‡˜‚ª•Ï‚í‚è‚Ü‚·B
+
+=begin original
+
+B<Please note that the hash seed is sensitive information>. Hashes are
+randomized to protect against local and remote attacks against Perl
+code. By manually setting a seed this protection may be partially or
+completely lost.
+
+=end original
+
+B<ƒnƒbƒVƒ…‚ÌŽí‚Í”÷–‚È–â‘è‚Å‚ ‚邱‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢>B
+ƒnƒbƒVƒ…‚Í Perl ƒR[ƒh‚ɑ΂·‚éƒ[ƒJƒ‹EƒŠƒ‚[ƒgUŒ‚‚©‚çŽç‚邽‚ß‚É
+ƒ‰ƒ“ƒ_ƒ€‰»‚³‚ê‚Ü‚·BŽè“®‚ÅŽí‚ðÝ’è‚·‚邱‚Æ‚É‚æ‚肱‚ÌŽç‚è‚Í•”•ª“I‚ÉA
+‚ ‚é‚¢‚ÍŠ®‘S‚ÉŽ¸‚í‚ê‚Ü‚·B
+
+=begin original
+
+See L<perlsec/"Algorithmic Complexity Attacks"> and
+L</PERL_HASH_SEED_DEBUG> for more information.
+
+=end original
+
+‚³‚ç‚È‚éî•ñ‚ɂ‚¢‚Ä‚Í L<perlsec/"Algorithmic Complexity Attacks"> ‚Æ
+L</PERL_HASH_SEED_DEBUG> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item PERL_HASH_SEED_DEBUG
+
+=begin original
+
+(Since Perl 5.8.1.) Set to one to display (to STDERR) the value of
+the hash seed at the beginning of execution. This, combined with
+L</PERL_HASH_SEED> is intended to aid in debugging nondeterministic
+behavior caused by hash randomization.
+
+=end original
+
+(Perl 5.8.1 ‚©‚ç) ‚±‚ê‚ð 1 ‚ÉÝ’è‚·‚é‚ÆAŽÀsŠJŽnŽž‚ɃnƒbƒVƒ…‚ÌŽí‚Ì
+’l‚ð‰æ–Ê(STDERR)‚Éo—Í‚µ‚Ü‚·B
+‚±‚ê‚Í L</PERL_HASH_SEED> ‚Æ‘g‚݇‚킹‚邱‚ƂŃnƒbƒVƒ…‚̃‰ƒ“ƒ_ƒ€‰»‚É
+‚æ‚é”ñŒˆ’è“I‚ÈU‚é•‘‚¢‚̃fƒoƒbƒO‚𕂯‚邱‚Æ‚ð–Ú“I‚Æ‚µ‚Ä‚¢‚Ü‚·B
+
+=begin original
+
+B<Note that the hash seed is sensitive information>: by knowing it one
+can craft a denial-of-service attack against Perl code, even remotely,
+see L<perlsec/"Algorithmic Complexity Attacks"> for more information.
+B<Do not disclose the hash seed> to people who don't need to know it.
+See also hash_seed() of L<Hash::Util>.
+
+=end original
+
+B<ƒnƒbƒVƒ…‚ÌŽí‚Í”÷–‚È–â‘è‚Å‚ ‚邱‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢>:
+‚±‚ê‚ð’m‚邱‚Æ‚ÅAƒŠƒ‚[ƒg‚©‚ç‚Å‚à Perl ‚̃R[ƒh‚ɑ΂µ‚ăT[ƒrƒX‹‘”ÛUŒ‚‚ð
+ŽdŠ|‚¯‚邱‚Æ‚ªo—ˆ‚Ü‚·B‚³‚ç‚È‚éî•ñ‚ɂ‚¢‚Ä‚Í
+L<perlsec/"Algorithmic Complexity Attacks"> ‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+’m‚é•K—v‚Ì‚È‚¢lX‚ɑ΂µ‚Ä B<ƒnƒbƒVƒ…‚ÌŽí‚ðŒöŠJ‚µ‚È‚¢‚Å‚‚¾‚³‚¢>B
+L<Hash::Util> ‚Ì hash_seed() ‚àŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item PERL_ROOT (specific to the VMS port)
+
+=begin original
+
+A translation concealed rooted logical name that contains perl and the
+logical device for the @INC path on VMS only. Other logical names that
+affect perl on VMS include PERLSHR, PERL_ENV_TABLES, and
+SYS$TIMEZONE_DIFFERENTIAL but are optional and discussed further in
+L<perlvms> and in F<README.vms> in the Perl source distribution.
+
+=end original
+
+Perl ‚Æ VMS ê—p‚Ì @INC ‚Ì‚½‚߂̘_—ƒfƒoƒCƒX‚ðŠÜ‚ÞA
+•ÏŠ·‚ª‰B‚³‚ꂽƒ‹[ƒg‚Æ‚È‚é˜_—–¼‚Å‚·B
+VMS ‚Ì Perl ‚ɉe‹¿‚ð—^‚¦‚é‚»‚Ì‘¼‚̘_—–¼‚Æ‚µ‚Ä‚Í
+PERLSHR, PERL_ENV_TABLES, SYS$TIMEZONE_DIFFERENTIAL ‚ª‚ ‚è‚Ü‚·‚ªA
+‚±‚ê‚ç‚̓IƒvƒVƒ‡ƒ“‚Å‚·BÚׂɂ‚¢‚Ä‚Í
+Perl ƒ\[ƒX”z•zƒpƒbƒP[ƒW‚Ì L<perlvms> ‚Æ F<README.vms> ‚Å
+‹c˜_‚³‚ê‚Ä‚¢‚Ü‚·B
+
+=item PERL_SIGNALS
+
+=begin original
+
+In Perls 5.8.1 and later. If set to C<unsafe> the pre-Perl-5.8.0
+signals behaviour (immediate but unsafe) is restored. If set to
+C<safe> the safe (or deferred) signals are used.
+See L<perlipc/"Deferred Signals (Safe signals)">.
+
+=end original
+
+Perl 5.8.1 ˆÈ~‚Å—LŒø‚Å‚·B‚±‚ê‚É C<unsafe> ‚ðƒZƒbƒg‚·‚é‚Æ
+Perl 5.8.0 ˆÈ‘O‚̃VƒOƒiƒ‹‚ÌU‚é•‘‚¢(’¼Ú“I‚Å‚·‚ªˆÀ‘S‚Å‚Í‚ ‚è‚Ü‚¹‚ñ)‚ª
+•œŒ³‚³‚ê‚Ü‚·BC<safe>‚ðƒZƒbƒg‚·‚é‚ƈÀ‘S‚È(’x‰„‚·‚é)ƒVƒOƒiƒ‹‚ª
+Žg‚í‚ê‚Ü‚·B
+L<perlipc/"Deferred Signals (Safe signals)">‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item PERL_UNICODE
+
+=begin original
+
+Equivalent to the B<-C> command-line switch. Note that this is not
+a boolean variable-- setting this to C<"1"> is not the right way to
+"enable Unicode" (whatever that would mean). You can use C<"0"> to
+"disable Unicode", though (or alternatively unset PERL_UNICODE in
+your shell before starting Perl). See the description of the C<-C>
+switch for more information.
+
+=end original
+
+B<-C> ƒRƒ}ƒ“ƒhƒ‰ƒCƒ“ƒXƒCƒbƒ`‚Æ“™‰¿‚Å‚·B
+‚±‚ê‚Í^‹U’l•Ï”‚Å‚Í‚È‚¢‚±‚Æ‚É’ˆÓ‚µ‚Ä‚‚¾‚³‚¢ -- ‚±‚ê‚ð C<"1"> ‚É
+ƒZƒbƒg‚·‚邱‚Æ‚Í(‚Ç‚ñ‚ȈӖ¡‚É‚¨‚¢‚Ä‚à)"Unicode ‚ð—LŒø‚É‚·‚é"‚½‚ß‚Ì
+³‚µ‚¢•û–@‚Å‚Í‚ ‚è‚Ü‚¹‚ñB
+‚µ‚©‚µA"Unicode ‚𖳌ø‚É‚·‚é"‚½‚ß‚É C<"0">‚ðƒZƒbƒg‚·‚邱‚Æ‚Ío—ˆ‚Ü‚·
+(‚ ‚é‚¢‚Í Perl ‚Ì‹N“®‘O‚É‚ ‚È‚½‚Ì‚¨Žg‚¢‚̃VƒFƒ‹‚Å PERL_UNICODE ‚ð
+–¢Ý’è‚É‚·‚邱‚Æ‚Å‚ào—ˆ‚Ü‚·)B
+‚³‚ç‚È‚éî•ñ‚ɂ‚¢‚Ä‚Í C<-C> ƒXƒCƒbƒ`‚Ìà–¾‚ðŽQÆ‚µ‚Ä‚‚¾‚³‚¢B
+
+=item SYS$LOGIN (specific to the VMS port)
+
+=begin original
+
+Used if chdir has no argument and HOME and LOGDIR are not set.
+
+=end original
+
+chdir ‚̈ø”‚ª‚È‚AHOME ‚Æ LOGDIR ‚ªƒZƒbƒg‚³‚ê‚Ä‚¢‚È‚¢‚Æ‚«‚ÉŽg‚í‚ê‚Ü‚·B
+
+=back
+
+=begin original
+
+Perl also has environment variables that control how Perl handles data
+specific to particular natural languages. See L<perllocale>.
+
+=end original
+
+“Á’è‚ÌŽ©‘RŒ¾Œê‚É“Á—L‚̃f[ƒ^‚ð Perl ‚ª‚ǂ̂悤‚Ɉµ‚¤‚©‚ð
+§Œä‚·‚éŠÂ‹«•Ï”‚à‚ ‚è‚Ü‚·BL<perllocale> ‚ðŽQÆ‚µ‚ĉº‚³‚¢B
+
+=begin original
+
+Apart from these, Perl uses no other environment variables, except
+to make them available to the program being executed, and to child
+processes. However, programs running setuid would do well to execute
+the following lines before doing anything else, just to keep people
+honest:
+
+=end original
+
+‚±‚ê‚ç‚Ì‘¼‚É‚ÍA
+ŽÀs‚³‚ê‚Ä‚¢‚éƒvƒƒOƒ‰ƒ€‚ ‚é‚¢‚̓`ƒƒƒCƒ‹ƒhƒvƒƒZƒX‚ª‚ª—LŒø‚É‚µ‚È‚¢ŒÀ‚èA
+Perl ‚͊‹«•Ï”‚ðŽg‚¢‚Ü‚¹‚ñB
+‚µ‚©‚µAsetuid ‚Å“®ì‚·‚éƒvƒƒOƒ‰ƒ€‚͉½‚©‚ð‚·‚é‘O‚ÉA
+’P‚ÉlX‚É•Ï‚È‹C‚ð‹N‚±‚³‚¹‚È‚¢‚½‚ß‚É
+ˆÈ‰º‚̃R[ƒh‚ð“ü‚ê‚Ä‚¨‚‚Ì‚ª‚æ‚¢‚Å‚·B
+
+ $ENV{PATH} = '/bin:/usr/bin'; # or whatever you need
+ $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL};
+ delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};
+
+=begin meta
+
+Translate: ‹g‘º Žõl <JAE00****@nifty*****>
+Update: Kentaro Shirakata <argra****@ub32*****>
+License: GPL or Artistic
+
+=end meta