名前¶

perlfaq8 - システムとの相互作用 ($Revision$)

説明¶

FAQ のこのセクションでは、オペレーティングシステムとの対話に関する質問を 扱っています。 これにはプロセス間(IPC)、ユーザーインターフェース (キーボード、スクリーン、ポインティングデバイス)の制御、 その他データ操作に関連しないほとんどの事柄を含みます。

あなたの使っているオペレーティングシステム向けの移植について特有のことは、 それに関する FAQ とドキュメント(perlvms, perlplan9 など)を 読んでください。 そこには、あなたの使う perl についてのより詳しい情報があります。

実行しているオペレーティングシステムを見分けるには?¶

$^O という変数(use Engish をしていれば $OSNAME)は、あなたの使っている perl の実行ファイルがビルドされたオペレーティングシステムの名前 (リリース番号ではありません)の情報を持っています。

なぜ exec() は戻ってこないのでしょう?¶

そういうものだからです: これはその時点で実行されているプログラムを 別のもので置き換えるのです。 もし元のものを残しておきたい(あなたがこの質問をしたときの状況のように)なら、 exec() の代わりに system() を使ってください。

キーボード/画面/マウスの凝った機能を使うには?¶

キーボード、画面、ポインティングデバイス(“マウス”)にアクセスしたり それを制御することはシステム依存です。 以下のモジュールを試してみてください:

Keyboard

        Term::Cap               Standard perl distribution
        Term::ReadKey           CPAN
        Term::ReadLine::Gnu     CPAN
        Term::ReadLine::Perl    CPAN
        Term::Screen            CPAN

Screen

        Term::Cap               Standard perl distribution
        Curses                  CPAN
        Term::ANSIColor         CPAN

Mouse

        Tk                      CPAN

これらの一部の特殊なケースは、このセクションの他の回答の例として 示されています。

色付きで何かを出力するには?¶

一般的にはできません。 なぜなら、あなたはディスプレイデバイスに関するレシピについて 何も知らないからです。 もしあなたがカラーの扱える ANSI ターミナルについて知っているのなら、 CPAN にある Term::ANSIColor モジュールを使うことができます。

        use Term::ANSIColor;
        print color("red"), "Stop!\n", color("reset");
        print color("green"), "Go!\n", color("reset");

あるいは次のようにも書けます:

        use Term::ANSIColor qw(:constants);
        print RED, "Stop!\n", RESET;
        print GREEN, "Go!\n", RESET;

リターンキーを待たずにキーのデータを一つ読み取るには?¶

入力バッファを制御するのは非常にシステムに依存したやりかたです。 多くのシステムでは、"getc" in perlfunc にあるように stty コマンドを使うことができますが、今書いた通り 移植性の問題があるのです。

        open(TTY, "+</dev/tty") or die "no tty: $!";
        system "stty  cbreak </dev/tty >/dev/tty 2>&1";
        $key = getc(TTY);               # perhaps this works
        # OR ELSE
        sysread(TTY, $key, 1);  # probably this does
        system "stty -cbreak </dev/tty >/dev/tty 2>&1";

CPAN にある Term::ReadKey モジュールは、stty をキー毎にシェルに 送るよりもより効果的に行ってくれて使うのが簡単なインターフェースを 提供します。 このモジュールは限定的ながら Windows にも対応しています。

        use Term::ReadKey;
        ReadMode('cbreak');
        $key = ReadKey(0);
        ReadMode('normal');

しかし、このコードを使うには C コンパイラを使えることが条件であり、かつ CPAN モジュールのビルドとインストールができなければなりません。 以下の例は、標準の POSIX モジュールを使った解決策で、 あなたの使っているシステムが POSIX をサポートしていれば 即使えるものです。

        use HotKey;
        $key = readkey();

そして以下の例は、HotKey モジュールを使ったものです。 この HotKey モジュールは POSIX の termio 構造体の操作を包み隠します。

        # HotKey.pm
        package HotKey;

        @ISA = qw(Exporter);
        @EXPORT = qw(cbreak cooked readkey);

        use strict;
        use POSIX qw(:termios_h);
        my ($term, $oterm, $echo, $noecho, $fd_stdin);

        $fd_stdin = fileno(STDIN);
        $term     = POSIX::Termios->new();
        $term->getattr($fd_stdin);
        $oterm     = $term->getlflag();

        $echo     = ECHO | ECHOK | ICANON;
        $noecho   = $oterm & ~$echo;

        sub cbreak {
                $term->setlflag($noecho);  # ok, so i don't want echo either
                $term->setcc(VTIME, 1);
                $term->setattr($fd_stdin, TCSANOW);
        }

        sub cooked {
                $term->setlflag($oterm);
                $term->setcc(VTIME, 0);
                $term->setattr($fd_stdin, TCSANOW);
        }

        sub readkey {
                my $key = '';
                cbreak();
                sysread(STDIN, $key, 1);
                cooked();
                return $key;
        }

        END { cooked() }

        1;

キーの入力待ちがあるかどうかチェックするには?¶

最も簡単な方法は、CPAN にある Term::ReadKey に対して (ブロックを行わないという意味である)-1 を引数に渡して 使用することによって非ブロックモードでキーを読み取るという方法です。

        use Term::ReadKey;

        ReadMode('cbreak');

        if (defined ($char = ReadKey(-1)) ) {
                # input was waiting and it was $char
        } else {
                # no input was waiting
        }

        ReadMode('normal');                  # restore normal tty settings

画面をクリアするには?¶

それほど頻繁でないのなら、system を使います:

        system("clear");

頻繁に行う必要があるのなら、クリアの文字列を保存することによって プログラムを呼び出す回数を減らすことができます:

        $clear_string = `clear`;
        print $clear_string;

カーソル位置など、そのほかのスクリーン操作をしようと考えているのなら、 Term::Cap モジュールを使うと良いかもしれません:

        use Term::Cap;
        $terminal = Term::Cap->Tgetent( {OSPEED => 9600} );
        $clear_string = $terminal->Tputs('cl');

画面サイズを得るには?¶

CPAN にある Term::ReadKey モジュールをインストールしているのなら、 文字やピクセルでの幅と高さを得ることができます:

        use Term::ReadKey;
        ($wchar, $hchar, $wpixels, $hpixels) = GetTerminalSize();

以下の例は生の ioctl よりも移植性がありますが、 あまりわかりやすい例ではありません:

        require 'sys/ioctl.ph';
        die "no TIOCGWINSZ " unless defined &TIOCGWINSZ;
        open(TTY, "+</dev/tty")                     or die "No tty: $!";
        unless (ioctl(TTY, &TIOCGWINSZ, $winsize='')) {
                die sprintf "$0: ioctl TIOCGWINSZ (%08x: $!)\n", &TIOCGWINSZ;
        }
        ($row, $col, $xpixel, $ypixel) = unpack('S4', $winsize);
        print "(row,col) = ($row,$col)";
        print "  (xpixel,ypixel) = ($xpixel,$ypixel)" if $xpixel || $ypixel;
        print "\n";

ユーザーにパスワードを尋ねるには?¶

(この質問は web とは関係ありません。 それに関しては 別の FAQ を参照してください。)

この例が "crypt" in perlfunc にあります。 第一に、端末を“no echo”モードにし、それから通常通りにパスワードを 読み込みます。 これを、古いスタイルの ioctl() 関数を使ってできますし、あるいは POSIX の端末制御(POSIX と、らくだ本を参照してください)を使うことも、 stty プログラムを呼び出すことも可能です(ただしこれは移植性は劣ります)。

あるいはほとんどのシステムで、CPAN にある Term::ReadKey を使って 行うこともできます。 これは使うのが簡単で、理論的にはより移植性があります。

        use Term::ReadKey;

        ReadMode('noecho');
        $password = ReadLine(0);

シリアルポートの読み書きを行うには?¶

これはプログラムを実行するオペレーティングシステムに依存します。 UNIX の場合、シリアルポートは /dev にあるファイルを通じてアクセスが 可能です。 他のシステムでは、デバイス名は異なったものであることでしょう。 全てのデバイス操作に共通の問題点として以下のものが挙げられます:

lockfiles

(ロックファイル)

Your system may use lockfiles to control multiple access. Make sure you follow the correct protocol. Unpredictable behavior can result from multiple processes reading from one device.

あなたの使っているシステムは、多重アクセスを制御するためにロック ファイルを使用しているかもしれません。 正しい手順に従うようにしてください。 予測のつかない振る舞いは一つのデバイスに対する複数のプロセスの読み出しが 原因かもしれません。

open mode

(オープンモード)

If you expect to use both read and write operations on the device, you'll have to open it for update (see "open" in perlfunc for details). You may wish to open it without running the risk of blocking by using sysopen() and O_RDWR|O_NDELAY|O_NOCTTY from the Fcntl module (part of the standard perl distribution). See "sysopen" in perlfunc for more on this approach.

一つのデバイスに対して、読み込みと書き出しの両方の操作ができることを 期待しているのなら、それを更新モード(詳しくは "open" in perlfunc を 参照)でオープンする必要があるでしょう。 sysopen() と Fcntl モジュールにある O_RDWR|O_NDELAY|O_NOCTTY とを使って ブロッキングする危険性なしにオープンを実行したいと考えるかもしれません。 このアプローチに関する詳細は "sysopen" in perlfunc を参照してください。

end of line

(行の末尾)

Some devices will be expecting a "\r" at the end of each line rather than a "\n". In some ports of perl, "\r" and "\n" are different from their usual (Unix) ASCII values of "\012" and "\015". You may have to give the numeric values you want directly, using octal ("\015"), hex ("0x0D"), or as a control-character specification ("\cM").

幾つかのデバイスでは、行の終端に "\n" ではなく "\r" を期待しています。 perl の移植の一部では、"\r" と "\n" は通常の(UNIX の) ASCII 値である "\012" と "\015" とは異なったものになっています。 八進表記 ("\015") や十六進表記("0x0D")、 あるいは制御文字指定 ("\cM") を使って 直接数値を与える必要があるかもしれません。

        print DEV "atv1\012";   # wrong, for some devices
        print DEV "atv1\015";   # right, for some devices

    print DEV "atv1\012";       # 一部のデバイスにとっては間違い
    print DEV "atv1\015";       # 一部のデバイスにとっては正しい

Even though with normal text files a "\n" will do the trick, there is still no unified scheme for terminating a line that is portable between Unix, DOS/Win, and Macintosh, except to terminate ALL line ends with "\015\012", and strip what you don't need from the output. This applies especially to socket I/O and autoflushing, discussed next.

通常のテキストファイルでさえも、"\n" はいたずらを行う可能性があります。 全ての行 を "\015\012" で終わらせ、出力から必要のないものを 取り除くということを除いては、UNIX、DOS/Win、Macintosh との間で 互換性のある行の終端方法は未だに統一されていません。 これは特にソケットの入出力や自動フラッシュで適用されます。 これについては次に述べます。

flushing output

If you expect characters to get to your device when you print() them, you'll want to autoflush that filehandle. You can use select() and the $| variable to control autoflushing (see "$|" in perlvar and "select" in perlfunc, or perlfaq5, "How do I flush/unbuffer an output filehandle? Why must I do this?"):

デバイスに print() した時にそのキャラクタが反映されるようにしたいのなら、 そのハンドルを自動フラッシュするようにしたいでしょう。 自動フラッシュを制御するのに、$| という変数と、select() を 使うことができます("$|" in perlvarと"select" in perlfunc または perlfaq5 の "How do I flush/unbuffer an output filehandle? Why must I do this?" を参照してください)。

        $oldh = select(DEV);
        $| = 1;
        select($oldh);

You'll also see code that does this without a temporary variable, as in

以下のように、これを一時変数を使わないで行うコードを見るかもしれません:

        select((select(DEV), $| = 1)[0]);

Or if you don't mind pulling in a few thousand lines of code just because you're afraid of a little $| variable:

$| というような変数に戸惑いを感じていて、数千行のプログラムを 引っ張りこむことを気にしないのなら以下のようにできます:

        use IO::Handle;
        DEV->autoflush(1);

As mentioned in the previous item, this still doesn't work when using socket I/O between Unix and Macintosh. You'll need to hard code your line terminators, in that case.

先のアイテムで述べたように、これでもまだ UNIX と Macintosh の間で ソケット I/O を使った場合にはうまく動作しません。 その場合には、行の終端をハードコーディングする必要があるでしょう。

non-blocking input

If you are doing a blocking read() or sysread(), you'll have to arrange for an alarm handler to provide a timeout (see "alarm" in perlfunc). If you have a non-blocking open, you'll likely have a non-blocking read, which means you may have to use a 4-arg select() to determine whether I/O is ready on that device (see "select" in perlfunc.

ブロッキング read() やブロッキング sysread() を行うのであれば、 タイムアウトを実現するためにalarmハンドラーをアレンジする必要があるでしょう ("alarm" in perlfunc を参照)。 もしノンブロッキング open を持っているのであれば、デバイスが入出力完了の 状態であるかどうかを決定するために四つの引数を取る select() を使う必要が あるであろうノンブロッキング read も同様に持っていることでしょう ("select" in perlfuncを参照)。

caller-id ボックスから読み出すことに挑戦したことで有名な Jamie Zawinski <[email protected]> は、 sysread や sysopen、POSIX の tcgetattr その他さまざまな関数を扱い 悪戦苦闘しながら、最終的には以下のようものを作りました:

        sub open_modem {
                use IPC::Open2;
                my $stty = `/bin/stty -g`;
                open2( \*MODEM_IN, \*MODEM_OUT, "cu -l$modem_device -s2400 2>&1");
                # starting cu hoses /dev/tty's stty settings, even when it has
                # been opened on a pipe...
                system("/bin/stty $stty");
                $_ = <MODEM_IN>;
                chomp;
                if ( !m/^Connected/ ) {
                        print STDERR "$0: cu printed `$_' instead of `Connected'\n";
                }
        }

暗号化されたパスワードファイルを復号化するには?¶

特別なハードウェアに非常に多額のお金を掛けてください; しかしこれはあなたが何について話しているかによります。

まじめな話をすると、UNIX のパスワードに対してのものならできません -- UNIX のパスワードシステムは一方向の暗号化を採用しています。 それは暗号化というよりはむしろハッシュ化といえるものです。 あなたがチェックできる最善の方法は、同じ文字列に対する ハッシュかどうかを調べることです。 Crack のようなプログラムは考えられるパスワードを力づくで(そして知的に) 試しますが、即座に成功するものを生成することはしません(できません)。

もしあなたが、ユーザーが悪いパスワードを選択してしまうことを 心配しているのであれば、ユーザーが(たとえば passwd(1) を使って)自分の パスワードを変更しようとしたときに積極的にチェックをすべきでしょう。

バックグラウンドでプロセスを起動するには?¶

いくつかのモジュールは、Perl プログラムをブロックせずに他のプロセスを 開始します。 IPC::Open3, Parallel::Jobs, IPC::Run, および POE モジュールのいくつかが 使えます。 更なる詳細については CPAN を参照してください。

以下のようにも出来ますし:

        system("cmd &")

"fork" in perlfunc で説明されている fork を使ってできます (perlipc には例もあります)。 あなたが UNIX 的なシステムを使っているなら、注意すべき事柄があります。

STDIN, STDOUT, and STDERR are shared

(STDIN, STDOUT, STDERR は共有されます)

Both the main process and the backgrounded one (the "child" process) share the same STDIN, STDOUT and STDERR filehandles. If both try to access them at once, strange things can happen. You may want to close or reopen these for the child. You can get around this with opening a pipe (see "open" in perlfunc) but on some systems this means that the child process cannot outlive the parent.

主プロセスとバックグラウンドプロセス(子プロセス)で同じ STDIN, STDOUT, STDERR のファイルハンドルが共有されます。 両方のプロセスが同時にアクセスしようとすると、 おかしな事が発生するかもしれません。 子プロセス用のこれらのハンドルを、クローズしたり再オープンしたり したくなるかもしれません。 これは、パイプを open することで行えますが、 一部のシステムにおいてはこれは子プロセスが親プロセスよりも 長生きすることはできないということになります。

Signals

(シグナル)

You'll have to catch the SIGCHLD signal, and possibly SIGPIPE too. SIGCHLD is sent when the backgrounded process finishes. SIGPIPE is sent when you write to a filehandle whose child process has closed (an untrapped SIGPIPE can cause your program to silently die). This is not an issue with system("cmd&").

SIGCHLD シグナルを捕捉する必要があり、可能なら SIGPIPE も 捕捉する必要があるでしょう。 SIGCHLD はバックグラウンドプロセスが終了したときに送られます。 SIGPIPE は既にクローズされている子プロセスを所有するファイルハンドルに 書き込みを行ったときに送られます(トラップされていない SIGPIPE は、 あなたのプログラムを黙って終わらせてしまうかもしれません)。 これは system("cmd&") を使ったときには起こりません。

Zombies

(ゾンビ)

You have to be prepared to "reap" the child process when it finishes.

子プロセスが終了したときにそれを“刈り取る”(reap) 準備をする必要があります。

        $SIG{CHLD} = sub { wait };

        $SIG{CHLD} = 'IGNORE';

You can also use a double fork. You immediately wait() for your first child, and the init daemon will wait() for your grandchild once it exits.

2 重 fork も使えます。 あなたは直ちに最初の子に対して wait() し、init デーモンは孫が終了するのを wait() します。

        unless ($pid = fork) {
            unless (fork) {
                exec "what you really wanna do";
                die "exec failed!";
            }
            exit 0;
        }
        waitpid($pid, 0);

See "Signals" in perlipc for other examples of code to do this. Zombies are not an issue with system("prog &").

これを行うサンプルは "Signals" in perlipc を参照してください。 ゾンビは system("prog &") を使ったときには発生しません。

制御文字やシグナルをトラップするには?¶

実際には制御文字を“トラップ”できません。 その代わりに、その文字が生成して 端末のフォアグラウンドプロセスに送られることになる シグナルがトラップできます。 シグナルは "Signals" in perlipc とらくだ本の "Signal" の章に 説明があります。

%SIG ハッシュにシグナルを扱いたい関数をセットできます。 perl がシグナルを捕捉した後、perl はシグナルと同じ名前をキーとして %SIG を 見て、そのキーの値であるサブルーチンを呼び出します。

        # as an anonymous subroutine

        $SIG{INT} = sub { syswrite(STDERR, "ouch\n", 5 ) };

        # or a reference to a function

        $SIG{INT} = \&ouch;

        # or the name of the function as a string

        $SIG{INT} = "ouch";

バージョン 5.8 より前の Perl には、シグナルを受け取って、可能なら %SIG にセットされている Perl の関数を実行する C ソースコードのシグナルハンドラが ありました。 これはこのレベルでのシグナルハンドリングのルールに違反していて、perl の コアダンプを引き起こしていました。 バージョン 5.8.0 から、perl はシグナルを捕捉している間ではなく、シグナルを 捕捉した「後に」%SIG を見ます。 この答えの以前のバージョンは間違っていました。

UNIX システムのシャドウパスワードファイルを変更するには?¶

perl が正しくインストールされていて、かつ、シャドウライブラリが きちんとインストールされていれば、perlfunc で説明されている getpw*() 関数がシャドウパスワードファイルに対する(リードオンリーの) アクセスを提供しています。 ファイルを変更するには、新たなシャドウパスワードファイルを作成して (フォーマットはシステム毎に異なります--詳しくは passwd を参照してください)、pwd_mkdb(8) を使ってそれをインストールします (詳細は pwd_mkdb を参照のこと)。

日付や時刻を設定するには?¶

あなたが十分な権限を持っているとすれば、date(1) プログラムを実行すれば システム全体の日付や時刻を設定できるはずです (プロセス毎に日付や時刻を設定する方法はありません)。 この機構は、UNIX、MS-DOS、Windows、NT でうまくいくでしょう。 VMS には等価な set time があります。

あなたのやりたいことがタイムゾーンの変更であるのなら、 環境変数を変更することでそれができるでしょう。

        $ENV{TZ} = "MST7MDT";              # unixish
        $ENV{'SYS$TIMEZONE_DIFFERENTIAL'}="-5" # vms
        system "trn comp.lang.perl.misc";

一秒未満の時間に対する sleep() や alarm() をするには?¶

sleep() 関数が一秒未満の単位での動作をサポートすることを求めているのなら、 "select" in perlfunc にあるように、select() を使うのが最も単純な方法です。 Time::Hires と BSD::Itimer モジュール(CPAN から利用可能ですし、 Perl 5.8 からは Time::HiRes は標準配布の一部です)も 試してみてください。

1 秒未満の時間を計るには?¶

(brian d foy によって寄贈されました)

(Perl 5.8 から標準配布の一部である) Time::HiRes モジュールは、 紀元からのマイクロ秒を返す gettimeofday() システムコールを使って時間を 計測します。 もし古い Perl を使っていて Time::HiRes をインストールできず、 Unixish を使っているなら、gettimeofday(2) を直接使えます。 "syscall" in perlfunc を参照してください。

atexit() や setjmp()/longjmp() をするには? (例外処理)¶

Perl のリリース 5 では、END ブロックが追加されました。 これは atexit() をシミュレートするのに使うことができます。 各パッケージの END ブロックはプログラム、もしくはスレッド (perlmod を参照してください) が終了したときに呼び出されます (詳しくは perlmod を参照)。

例を挙げると、あなたのフィルタープログラムが出力を確実に ディスクに送るようにするためには以下のようにできます:

        END {
                close(STDOUT) || die "stdout close failed: $!";
        }

END ブロックは、トラップされないシグナルが プログラムを強制終了させた場合には呼び出されません。 したがって、END ブロックを使う場合には同時に以下のようにするべきです:

        use sigtrap qw(die normal-signals);

Perl の例外処理機構は eval() 演算子です。 setjmp() として eval() を、longjmp() として die() を使うことができます。 これに関する詳細は、シグナルに関するセクション、 特に "Signals" in perlipc にあるブロッキング flock() のための タイムアウトハンドラーと、らくだ本の "Signal" の章を参照してください。

例外処理そのものに興味があるのなら、exception.pl ライブラリ (これは標準 perl 配布キットの一部です)を試してみてください。

atexit() 構文(と、rmexit()) が欲しいのなら、CPAN にある AtExit モジュールを試してみてください。

なぜ私のソケットプログラムはSystem V (Solaris) ではうまく動かないの? "Protocol not supported"というエラーメッセージの意味するところは?¶

一部の System 5 ベースのシステム、特に Solaris 2.x では標準のソケット定数の 幾つかが再定義されています。 これらの定数は全てのアーキテクチャに渡るものであったので、 しばしば perl コードにハードコーディングされています。 これに対処する適切な方法は正しい値を得るために "use Socket" とすることです。

SunOS と Solaris とではバイナリ互換性があるにも関らず、 これらの値が異なるということに注意してください。 不思議なことです。

Perl から私のシステムに固有の C 関数を呼び出すには?¶

ほとんどの場合、その方法は外部モジュールを作るというものです -- "Where can I learn about linking C with Perl? [h2xs, xsubpp]" の回答を参照してください。 ただし、その関数がシステムコールでありあなたの使っているシステムが syscall() をサポートしているのであれば、 syscall 関数(perlfunc に説明があります)を使うことができます。

一緒に配布されたモジュールや CPAN にあるモジュールをチェックすることを 忘れないでください--誰かが求めるモジュールを既に作っているかもしれません。 Windows では、Win32::API を試してください。 Mac では、Mac::Carbon を試してください。 C 関数へのインターフェースを持つモジュールがなければ、 Inline::C を使って Perl のソースコードにちょっとした C のコードを インライン化できます。

ioctl() や syscall() で使うための include ファイルはどこで入手できますか?¶

伝統的に、これらのファイルは標準配布に含まれる h2ph というツールによって 生成されるものです。 このプログラムはCのヘッダーファイルにある cpp(1) 指示子を &SYS_getitimer のような、関数に対する引数として使うことのできる サブルーチン定義を含むファイルに変換するものです。 これは完璧なものではありませんが、ほとんどの場合には十分な仕事を行います。 errno.h, syscall.h, socket.h のような単純なファイルはよいのですが、 ioctl.h のように難しいものはほとんど常に手で編集する必要があります。 以下の手順は、*.ph ファイルをインストールするためのものです。

        1.  become super-user
        2.  cd /usr/include
        3.  h2ph *.h */*.h

あなたの使っているシステムが動的ローディングをサポートしているのであれば、 移植性と健全性(sanity)のために、h2xs を使うべきでしょう (これも標準の perl 配布キットに含まれています)。 このツールは、C のヘッダーファイルを Perl のエクステンションに変換します。 h2xs の使い方は perlxstut を参照してください。

あなたの使っているシステムが動的ローディングをサポートしていない 場合であっても、やはり h2xs を使うべきでしょう。 より詳しい情報は perlxstut と ExtUtils::MakeMaker を参照してください (簡単に言うと、新しい静的エクステションを伴った perl を再ビルドするのに 通常の make を使うのではなく、make perl を使うだけです)。

なぜ setuid された perl スクリプトはカーネルの問題について文句を言うのでしょうか?¶

幾つかのオペレーティングシステムは、setuid スクリプトを本質的に 安全でなくするようなカーネルのバグを抱えています。 Perl は、そういったシステムに対処して動作させるための幾つかのオプションを 持っています(perlsec に説明があります)。

あるコマンドに対する双方向のパイプをオープンするには?¶

IPC::Open2 モジュール(標準の perl の配布に含まれています)は内部的に pipe()、fork()、exec() を使った使いやすい手法です。 ただし、ドキュメントにあるデッドロックの警告をよく読んでください (IPC::Open2を参照)。 "Bidirectional Communication with Another Process" in perlipc と "Bidirectional Communication with Yourself" in perlipc も参照してください。

IPC::Open3 モジュール(標準配布パッケージに含まれています)も使えますが、 これは IPC::Open2 とは引数の順序が違うということに注意してください (IPC::Open3 を参照してください)。

なぜ system() を使ったコマンドの出力を得ることができないのでしょうか?¶

system() の目的と逆クォートの目的を混同しているのでしょう。 system() はコマンドを実行して、終了ステータス情報(16bit 値として: 下位 7bit は(もしあれば)終了したプロセスからのシグナルで、上位 8bit は 実際の終了ステータス)を返します。 逆クォートはコマンドを実行し、そのコマンドが STDOUT に送ったものを返します。

        $exit_status   = system("mail-users");
        $output_string = `ls`;

外部コマンドの STDERR を捕捉するには?¶

外部コマンドを実行する基本的なやり方が三つあります:

        system $cmd;            # using system()
        $output = `$cmd`;               # using backticks (``)
        open (PIPE, "cmd |");   # using open()

system() を使った場合の STDOUT と STDERR は、system() コマンドが リダイレクトを行っていない限りはそれぞれスクリプトが使っていた STDOUT と STDERR へ出力されます。 backticks と open() はコマンドの STDOUT だけを 読み込みます。

IPC::Open3 の open3() 関数も使えます。 Benjamin Goldberg がいくつかのサンプルコードを提供しています:

あるプログラムの STDOUT は捕捉したいが、STDERR は捨てたい場合:

        use IPC::Open3;
        use File::Spec;
        use Symbol qw(gensym);
        open(NULL, ">", File::Spec->devnull);
        my $pid = open3(gensym, \*PH, ">&NULL", "cmd");
        while( <PH> ) { }
        waitpid($pid, 0);

あるプログラムの STDERR は捕捉したいが、STDOUT は捨てたい場合:

        use IPC::Open3;
        use File::Spec;
        use Symbol qw(gensym);
        open(NULL, ">", File::Spec->devnull);
        my $pid = open3(gensym, ">&NULL", \*PH, "cmd");
        while( <PH> ) { }
        waitpid($pid, 0);

プログラムの STDERR を捕捉してその STDOUT を自身の STDERR に送るには:

        use IPC::Open3;
        use Symbol qw(gensym);
        my $pid = open3(gensym, ">&STDERR", \*PH, "cmd");
        while( <PH> ) { }
        waitpid($pid, 0);

あるコマンドの STDOUT と STDERR を別々に読み込みたい場合、それをテンポラリ ファイルにリダイレクトして、コマンドを実行して、テンポラリファイルから 読み込みます:

        use IPC::Open3;
        use Symbol qw(gensym);
        use IO::File;
        local *CATCHOUT = IO::File->new_tmpfile;
        local *CATCHERR = IO::File->new_tmpfile;
        my $pid = open3(gensym, ">&CATCHOUT", ">&CATCHERR", "cmd");
        waitpid($pid, 0);
        seek $_, 0, 0 for \*CATCHOUT, \*CATCHERR;
        while( <CATCHOUT> ) {}
        while( <CATCHERR> ) {}

しかし、実際には「両方を」テンポラリファイルにするする必要はありません…。 以下のものもデッドロックなしにうまく動きます:

        use IPC::Open3;
        use Symbol qw(gensym);
        use IO::File;
        local *CATCHERR = IO::File->new_tmpfile;
        my $pid = open3(gensym, \*CATCHOUT, ">&CATCHERR", "cmd");
        while( <CATCHOUT> ) {}
        waitpid($pid, 0);
        seek CATCHERR, 0, 0;
        while( <CATCHERR> ) {}

そして、これはプログラムの終了を待つのではなく、プログラムの標準出力を直ちに 処理するので、より速いはずです。

これらのどれでも、呼び出しの前にファイル記述子を変更できます:

        open(STDOUT, ">logfile");
        system("ls");

Bourne シェルのファイル記述子リダイレクションを使うこともできます:

        $output = `$cmd 2>some_file`;
        open (PIPE, "cmd 2>some_file |");

同様に、STDERR を STDOUT の複製にするためにファイル記述子 リダイレクションを使うこともできます。

        $output = `$cmd 2>&1`;
        open (PIPE, "cmd 2>&1 |");

STDOUT の複製のために、Perl プログラムの中で単純に STDERR を オープンすることは できない ということと、リダイレクトのための シェルの呼び出しを避けることはできないということに注意してください。 以下の例はうまくいきません:

        open(STDERR, ">&STDOUT");
        $alloutput = `cmd args`;  # stderr still escapes

これは open() が、STDERR を(open() が呼び出された時点で)STDOUT が 使っていた場所に対応するようにするので失敗します。 その後で逆クォートは STDOUT(に出力された内容)を文字列にしますが、 STDERR を変更することはしません(これは以前の STDOUT が指していたところです)。

backticlsの中では、csh(1) のリダイレクト構文ではなく、Bourne shell (sh(1)) のリダイレクト構文を 使わなければならない ということに 注意してください! なぜ Perl の system()、backticks、パイプオープンの全てで Bourne シェルの ものを使うかは http://www.cpan.org/misc/olddoc/FMTEYEWTK.tgz にある "Far More Than You Ever Wanted To Know" の versus/csh.whynot という記事で 説明されています。 あるコマンドの標準出力と標準エラー出力を両方とも捉えるには:

        $output = `cmd 2>&1`;                       # either with backticks
        $pid = open(PH, "cmd 2>&1 |");              # or with an open pipe
        while (<PH>) { }                            #    plus a read

あるコマンドの標準出力を捉え、標準エラー出力を捨てるには:

        $output = `cmd 2>/dev/null`;                # either with backticks
        $pid = open(PH, "cmd 2>/dev/null |");       # or with an open pipe
        while (<PH>) { }                            #    plus a read

あるコマンドの標準エラー出力を捉え、標準出力を捨てるには:

        $output = `cmd 2>&1 1>/dev/null`;           # either with backticks
        $pid = open(PH, "cmd 2>&1 1>/dev/null |");  # or with an open pipe
        while (<PH>) { }                            #    plus a read

あるコマンドの標準エラー出力を捉えるために 標準出力と標準エラー出力を入れ替えるが、標準出力に 古い標準エラー出力に出るようにするには:

        $output = `cmd 3>&1 1>&2 2>&3 3>&-`;        # either with backticks
        $pid = open(PH, "cmd 3>&1 1>&2 2>&3 3>&-|");# or with an open pipe
        while (<PH>) { }                            #    plus a read

標準出力と標準エラー出力の両方を分けて読み出すには、 別々のファイルにリダイレクトしてしまって、 その後でそのファイルをプログラムから読むというのが最も簡単な方法です:

        system("program args 1>program.stdout 2>program.stderr");

これらの例では順序が重要です。 なぜなら、シェルがリダイレクトのためのファイル記述子を処理する順序は 正確に左から右へという順になっているからです。

        system("prog args 1>tmpfile 2>&1");
        system("prog args 2>&1 1>tmpfile");

最初のコマンドは標準出力と標準エラー出力の両方を一時ファイルに送ります。 二番目のコマンドは古い標準出力だけをファイルへと送り、古い標準エラー出力は 古い標準出力へと送り出します。

なぜ open() は パイプのオープンに失敗したときにエラーを返さないのでしょうか?¶

パイプされた open() の第二引数にシェルのメタ文字が含まれている場合、 perl は fork() し、メタ文字をデコードするためにシェルを exec() し、 最終的に必要なプログラムを実行します。 このプログラムが実行できない場合、メッセージを得るのはシェルであって、 Perl ではありません。 あなたの Perl プログラムがわかることはシェル自身が正しく開始されたかどうか だけです。 エラーメッセージのためにシェルの STDERR を捕捉してチェックするという方法は あります。 この文書の別の場所にある "How can I capture STDERR from an external command?" を参照するか、IPC::Open3 モジュールを使ってください。

open() の引数にシェルのメタ文字がないなら、Perl はコマンドをシェルを使わずに 直接実行し、コマンドが開始したかどうかを正しく報告できます。

無効コンテキストで逆クォートを使うことのなにが悪いのでしょうか?¶

厳密に言えばありません。 形式的に言えば、保守しやすいコードを書くための良い方法ではありません。 Perl は外部コマンドを実行するためのいくつかの演算子があります。 逆クォートはその一つです; これはコマンドからの出力を、自身のプログラムで 使うために収集します。 system 関数はもう一つのものです; これはコマンドからの出力を収集しません。

プログラム中に逆クォートを書くことで、そのコマンドの出力を使いたいという はっきりしたメッセージをあなたのコードの読者に送ります。 なぜ正しくないはっきりしたメッセージを送るのですか?

以下のような行を考えてみましょう:

        `cat /etc/termcap`;

プログラムが正しく実行されたかどうかを確認するために $? を見るのを忘れています。

        print `cat /etc/termcap`;

このコードは、以下のように書くべきでしょう

        system("cat /etc/termcap") == 0
        or die "cat program failed!";

これは、プログラムが出力を終えるのを待つのではなく、cat コマンドの出力が 生成される毎にエコーします。 これはまたその戻り値のチェックも行います。

system() はまた、シェルのワイルドカード処理を行えるかどうかを直接 制御しますが、逆クォートはそういった制御は行いません。

シェルの処理をせずに逆クォートを呼び出すには?¶

ちょっとトリッキーになります。 単純に以下のようにはコマンドを書けません:

        @ok = `grep @opts '$search_string' @filenames`;

Perl 5.8.0 から、複数の引数の open() を使えます。 リスト形式の system() や exec() と同様に、シェルエスケープは 起きません。

        open( GREP, "-|", 'grep', @opts, $search_string, @filenames );
        chomp(@ok = <GREP>);
        close GREP;

以下のようにもできます:

        my @ok = ();
        if (open(GREP, "-|")) {
                while (<GREP>) {
                        chomp;
                        push(@ok, $_);
                }
                close GREP;
        } else {
                exec 'grep', @opts, $search_string, @filenames;
        }

system() を使ったときと同じく、シェルエスケープは exec() のリストに 対して行われません。 さらなる例が "Safe Pipe Opens" in perlipc にあります。

もしあなたが Windows を使っているのなら、この悩ましい問題を 解決する方法は全くありません。 たとえ Perl が fork() をエミュレートしたとしても、まだうまくいきません。 なぜならマイクロソフトは argc/argv 形式の API を提供していないからです。

なぜ EOF(UNIX での^D、MS-DOS での^Z)を受け取った後で STDIN から読み込むことができないの?¶

一部の stdio ではエラーフラグと eof フラグがセットされ、 それをクリアする必要があるからです。 POSIX モジュールはこのために使える clearerr() を定義しています。 これは、フラグをクリアするための技術的に正しい方法です。 以下の方法はこれよりは信頼性にかけるやり方です:

1. Try keeping around the seekpointer and go there, like this:

   以下の例のように、シークポインタを保存しておいてそこへ移動します:

           $where = tell(LOG);
           seek(LOG, $where, 0);

2. If that doesn't work, try seeking to a different part of the file and then back.

   上のやりかたがだめなら、一度ファイルの別の部分にシークして、それから 元の場所にシークするようにします。

3. If that doesn't work, try seeking to a different part of the file, reading something, and then seeking back.

   これでもだめなら、ファイルの別の部分にシークして何かを読み出し、それから 元の場所にシークするようにします。

4. If that doesn't work, give up on your stdio package and use sysread.

   これでだめなら stdio パッケージで行うことはあきらめて、sysread を使います。

私のシェルスクリプトを perl に変換するには?¶

Perl を学び、自分で書き直しましょう。 まじめな話、単純なコンバータというものはありません。 シェルで行うには不格好になるようなことも Perl では簡単に行うことができ、 そして、このとても不格好なことがシェル→ perl コンバーターを作製することを ほとんど不可能なことにしているのです。 自分で書き換えをすることで、あなたは自分が本当に試すべきことについて 考えるようになり、シェルの(便利なときもあるものの多くの非効率を持ち込む) パイプラインデータストリームパラダイムから逃れることができるでしょう。

telnet や ftp のセッションを実行するために perl を使うことができますか?¶

Net::FTP, TCP::Client, Net::Telnet といったモジュール(CPAN で入手可能です)を 試してみてください。 http://www.cpan.org/scripts/netstuff/telnet.emul.shar も telnet プロトコルを エミュレートする助けになるでしょうが、Net::Telnet は使うのがとても簡単です。

あなたのやりたいことが telnet のふりをすることであっても初期化時の telnet のハンドシェイクを必要としないのであれば、 標準的な dual-process アプローチで十分でしょう。

        use IO::Socket;             # new in 5.004
        $handle = IO::Socket::INET->new('www.perl.com:80')
            or die "can't connect to port 80 on www.perl.com: $!";
        $handle->autoflush(1);
        if (fork()) {               # XXX: undef means failure
            select($handle);
            print while <STDIN>;    # everything from stdin to socket
        } else {
            print while <$handle>;  # everything from socket to stdout
        }
        close $handle;
        exit;

Perl で expect を書くには?¶

昔々、chat2.pl と呼ばれたライブラリがありました(これは標準の perl 配布キットに含まれます)。 もしこれをどこかで見つけても使ってはいけません。 今日では、CPAN にある IO::Pty や IO::Stty といった ライブラリを探すのが最善でしょう。

“ps”のようなプログラムから、perl のコマンドラインを隠す方法はありますか?¶

まず初めに、あなたが(たとえば他人がパスワードを除くのを避けるためなどの) セキュリティ上の理由でそれを行おうとしてるのであれば、 重要な情報が引数として与えられることがないようにプログラムを 書き直すべきだということに注意してください。 引数を隠すことは、あなたのプログラムを完全に安全なものにすることは ありません。

外部から見えるコマンドラインを実際に書き換えるために、perlvar で 説明されているように $0 という変数に代入することができます。 ただし、これはすべてのオペレーティングシステムで実行できるというものでは ありません。 sendmail のようなデーモンプログラムは以下の例のように状態を設定します:

        $0 = "orcus [accepting connections]";

perl スクリプトの中で、ディレクトリを変更したり環境変数を変更しました。なぜ、スクリプトを終了したときこれらの変更は無効になってしまうの? 変更が反映されるようにするには?¶

Unix

In the strictest sense, it can't be done--the script executes as a different process from the shell it was started from. Changes to a process are not reflected in its parent--only in any children created after the change. There is shell magic that may allow you to fake it by eval()ing the script's output in your shell; check out the comp.unix.questions FAQ for details.

もっとも厳密な意味で言うと、それはできません--スクリプトはそれを 起動したシェルとは異なるプロセスで実行されるのです。 あるプロセスに対する変更はその親に反映されることはありません --変更した後で生成された子プロセスに対してのみ反映されます。 あなたの使っているシェルにおいてスクリプトの出力をeval()することによって、 お望みのことをしたように見せかけるシェルマジック (shell magic)があります。 詳しくは comp.unix.questions FAQを調べてください。

プロセスの完了を待つことなしにそのファイルハンドルをクローズするには?¶

あなたの使っているシステムがそういった機能をサポートしていると仮定すると、 そのプロセスに対して適切なシグナルを送るだけです ("kill" in perlfunc を参照してください)。 最初にTERMシグナルを送り、ちょっとだけ待って、 終了させるために KILL シグナルを送るというのが一般的なものです。

デーモンプロセスを fork() するには?¶

あなたのいうデーモンプロセスが detach されている(tty と 結び付けられていない)ものであれば、以下の手順がほとんどの UNIX 的な システムで動作するということが報告されています。 非 UNIX ユーザーは Your_OS::Process モジュールで他の解決策を あたるべきでしょう。

• Open /dev/tty and use the TIOCNOTTY ioctl on it. See tty for details. Or better yet, you can just use the POSIX::setsid() function, so you don't have to worry about process groups.

  /dev/tty をオープンし、それに TIOCNOTTY ioctl を使います。 詳しくは tty を参照してください。 そのほかもっと良いのは、POSIX::setsid() 関数を使うことです。 これによってプロセスグループに関して思い煩う必要がなくなります。

• Change directory to /

  / へディレクトリを変更します。

• Reopen STDIN, STDOUT, and STDERR so they're not connected to the old tty.

  STDIN、STDOUT、STDERR を再オープンします。 これでこれらのハンドルは以前の tty とは結び付けらていない状態になります。

• Background yourself like this:

  以下のようにしてバックグラウンドにします:

          fork && exit;

CPAN で入手できる Proc::Daemon モジュールはこれらの操作を 行ってくれる関数を提供しています。

自分が対話的に実行されているかどうかを知るには?¶

良い質問です。 -t STDIN と -t STDOUT が手掛かりを与えてくれるときもあるし、 そうでないときもあります。

        if (-t STDIN && -t STDOUT) {
                print "Now what? ";
                }

POSIX システムでは以下のようにして、あなたが端末を制御しているカレントの プロセスグループにマッチするようなプロセスグループを 所有しているかどうかを検査できます:

        use POSIX qw/getpgrp tcgetpgrp/;

        # Some POSIX systems, such as Linux, can be
        # without a /dev/tty at boot time.
        if (!open(TTY, "/dev/tty")) {
                print "no tty\n";
        } else {
                $tpgrp = tcgetpgrp(fileno(*TTY));
                $pgrp = getpgrp();
                if ($tpgrp == $pgrp) {
                        print "foreground\n";
                } else {
                        print "background\n";
                }
        }

遅いイベントをタイムアウトするには?¶

"Signals" in perlipc やらくだ本の "Signal" の章で説明されているように、 alarm() 関数と、おそらくはシグナルハンドラーを組み合わせて使います。 この代わりに、CPAN にあるより柔軟性のある Sys::AlarmCall モジュールを使うこともできます。

alarm() 関数は Windows の全てのバージョンで実装されているわけではありません。 あなたの特定のバージョンの Perl のドキュメントをチェックしてください。

CPU のリミットを設定するには?¶

(Xho によって寄贈されました)

CPAN にある BSD::Resource モジュールを使います。 例として:

        use BSD::Resource;
        setrlimit(RLIMIT_CPU,10,20) or die $!;

これはソフト制限とハード制限をそれぞれ 10 秒と 20 秒にセットします。 CPU が 10 秒の時間を消費後("wall" 時間ではありません)、プロセスはシグナル (システムによっては XCPU)を送り、トラップされなければ、これによりプロセスは 終了します。 シグナルがトラップされると、さらに 10 秒(合計 20 秒)経過後、プロセスは ブロック不可シグナルで kill されます。

詳細については BSD::Resource とあなたのシステムのドキュメントを 参照してください。

UNIX システムでゾンビを回避するには?¶

SIGCHLD を受け取ったときに wait() を呼び出すように "Signals" in perlipc に ある刈り取り機プログラム (reaper code) を使うか、 "How do I start a process in the background?" in perlfaq8 で 説明されている double-fork テクニックを使います。

SQL データベースを使うには?¶

DBI モジュールはほとんどのデータベースサーバと型に対する抽象 インターフェースを提供します; これには Oracle, DB2, Sybase, mysql, Postgresql, ODBC, フラットファイルを含みます。 DBI モジュールは、DBD と呼ばれるデータベースドライバを通して各データベース 型にアクセスします。 利用可能なドライバの完全な一覧は CPAN (http://www.cpan.org/modules/by-module/DBD/) にあります。 DBI に関するさらなる情報は http://dbi.perl.org にあります。

その他のモジュールはより具体的なアクセスを提供します: Win32::ODBC, Alzabo, iodbc などは CPAN Search (http://search.cpan.org) で見つけられます。

コントロール-C で system() が exit するようにするには?¶

できません。 system() 呼び出しを模倣する必要があり(perlipc のサンプルコードを 参照してください)、サブプロセスでのシグナルを送る INT シグナルのためのシグナルハンドラーを持つ必要があります。 あるいは、以下のようにしてチェックすることもできます:

        $rc = system($cmd);
        if ($rc & 127) { die "signal death" }

ブロックせずにファイルをオープンするには?¶

幸運にもあなたの使っているシステムがノンブロッキング読み出し (ほとんどの UNIX 的システムはサポートしています)をサポートしているのであれば、 Fcntl モジュールの O_NDELAY や O_NONBLOCK というフラグを sysopne() と一緒に使うだけです。

        use Fcntl;
        sysopen(FH, "/foo/somefile", O_WRONLY|O_NDELAY|O_CREAT, 0644)
                or die "can't open /foo/somefile: $!":

シェルからと perl からのエラーを見分けるには?¶

(答えは brian d foy によって寄贈されました)

あなたが Perl スクリプトを実行すると、他の誰かがあなたのためにスクリプトを 動かします; そしてその他の誰かがエラーメッセージを出すことがあります。 スクリプトも自身の警告やエラーメッセージを出すかもしれません。 ほとんどの場合、それを言っているのが誰かは教えてもらえません。

あなたが perl を実行しているものを修正することはおそらくできませんが、 独自の警告と die の関数を定義することで、perl がどのように警告を 出力するかを変えることはできます。

すぐには気付かないかもしれない誤りを含むこのスクリプトを考えてみてください。

        #!/usr/locl/bin/perl

        print "Hello World\n";

これを私のシェル(たまたま bash でした)で実行するとエラーが表示されます。 これは perl が print() 関数を忘れてしまったかのように見えますが、 #! 行の perl へのパスが間違っているので、シェルがこのスクリプトを実行し、 エラーが表示されます。

        $ ./test
        ./test: line 3: print: command not found

素早く汚い修正には少しコードが必要ですが、おそらく問題を見つけ出すのに 必要なものが全てあるでしょう。

        #!/usr/bin/perl -w

        BEGIN {
        $SIG{__WARN__} = sub{ print STDERR "Perl: ", @_; };
        $SIG{__DIE__}  = sub{ print STDERR "Perl: ", @_; exit 1};
        }

        $a = 1 + undef;
        $x / 0;
        __END__

perl のメッセージは先頭に "Perl" を付けて出力されます。 BEGIN ブロックはコンパイル時に動作するので、全てのコンパイル時のエラーと 警告にも "Perl:" の接頭辞がつきます。

        Perl: Useless use of division (/) in void context at ./test line 9.
        Perl: Name "main::a" used only once: possible typo at ./test line 8.
        Perl: Name "main::x" used only once: possible typo at ./test line 9.
        Perl: Use of uninitialized value in addition (+) at ./test line 8.
        Perl: Use of uninitialized value in division (/) at ./test line 9.
        Perl: Illegal division by zero at ./test line 9.
        Perl: Illegal division by zero at -e line 3.

"Perl:" という文字がなければ、perl が出しているものではありません。

単に全ての perl のエラーを知るという方法もありますが、(全てのエラーを 知っている人もいるかもしれませんが)おそらくあなたは知らないでしょう。 しかし、これら全ては perldiag マニュアルページにあるはずです。 もしエラーがここになければ、それはおそらく perl のエラーではありません。

全てのメッセージを探すというのは最も簡単な方法ではないので、その作業は perl にさせます。 perl の通常のメッセージを、より長い説明に変更する diagnostics プラグマを 使います。

        use diagnostics;

段落一つか二つの追加の議論が表示されなければ、それは perl のメッセージでは ないでしょう。

モジュールを CPAN からインストールするには?¶

最も単純な方法は、その仕事をしてくれる CPAN モジュールを入手することです。 このモジュールは、5.004 以降の perl に付属しています。

        $ perl -MCPAN -e shell

        cpan shell -- CPAN exploration and modules installation (v1.59_54)
        ReadLine support enabled

        cpan> install Some::Module

CPAN モジュールや問題に対して行儀よく振る舞う CPAN モジュールを手作業で インストールするには、以下のステップに従います:

1. Unpack the source into a temporary area.

   ソースファイルを一時的な領域に展開します。

2.         perl Makefile.PL

3.         make

4.         make test

5.         make install

あなたの使っている perl が、動的ローディングを使わずに コンパイルされたものであれば、 ステップ 3 の (make) を make perl で置き換える必要があり、 エクステンションをリンクした新しい perl の実行ファイルを 入手することになります。

エクステンションのビルドについての詳細は ExtUtils::MakeMaker を参照して下さい。 次の質問 "What's the difference between require and use?" も参照してください。

require と use の間の違いとは?¶

Perl では、あるファイルを別のファイルから取り込むのに何種類かの 方法を提供しています。 以下はそれぞれの方法の違いを明確にしたものです:

        1)  do $file is like eval `cat $file`, except the former
        1.1: searches @INC and updates %INC.
        1.2: bequeaths an *unrelated* lexical scope on the eval'ed code.

        1) do $file は `cat $file` と似ていますが、以下の点が違います:
        1.1: @INC を検索し、%INC を更新します。
        1.2: eval されたコードに*関係ない*レキシカルスコープを残します。

        2)  require $file is like do $file, except the former
        2.1: checks for redundant loading, skipping already loaded files.
        2.2: raises an exception on failure to find, compile, or execute $file.

        2)  require $file は do $File に似ていますが、以下の点が違います:
        2.1: 余分なローディングをチェックし、既にロードしたファイルであれば
             スキップします。
        2.2: ファイルが見つからなかったり、コンパイルできなかったり
             実行できなかったときには例外を発生します。

        3)  require Module is like require "Module.pm", except the former
        3.1: translates each "::" into your system's directory separator.
        3.2: primes the parser to disambiguate class Module as an indirect object.

        3)  require Module は require "Module.pm" と似ていますが、以下の点が
            違います:
        3.1: "::" をあなたの使っているシステムのディレクトリセパレータに
             変換します。
        3.2: 間接オブジェクトとしてのクラスモジュールを明確にするための
             解析準備をします。

        4)  use Module is like require Module, except the former
        4.1: loads the module at compile time, not run-time.
        4.2: imports symbols and semantics from that package to the current one.

        4)  use Module は require Module に似ていますが、以下の点が違います:
        4.1: 実行時にではなくコンパイル時にモジュールをロードします。
        4.2: カレントのパッケージにその取り込んだパッケージでのシンボルと
             semanticsをインポートします。

一般的には、use と適切な Perl モジュールを使いたいと考えるでしょう。

自分自身のモジュール/ライブラリディレクトリを持つには?¶

モジュールを作成するときに、Perl にモジュールをインストールする場所を 指定します。

Makefile.PL-ベースの配布では、Makefile の生成時に PREFIX と LIB の オプションを使ってください:

        perl Makefile.PL PREFIX=/mydir/perl LIB=/mydir/perl/lib

CPAN.pm シェルを使ったときに、自動的にモジュールを自分のプライベートな ディレクトリにインストールさせるように、CPAN.pm の設定を変更できます:

        % cpan
        cpan> o conf makepl_arg PREFIX=/mydir/perl,LIB=/mydir/perl/lib
        cpan> o conf commit

Build.PL-ベースの配布では、--install_base オプションを使ってください:

        perl Build.PL --install_base /mydir/perl 

自動的にこのオプションを使うために、CPAN.pm を設定することも出来ます:

        % cpan
        cpan> o conf mbuild_arg --install_base /mydir/perl
        cpan> o conf commit

私のプログラムの置いてある場所をモジュール/ライブラリの検索パスに追加するには?¶

(brian d foy によって寄贈されました)

すでにディレクトリが分かっている場合は、それを @INC に追加できます。 コンパイル時に分かっている場合は、<use lib> が使えます:

        use lib $directory;

このタスクの秘訣は、ディレクトリを探すことです。 あなたのスクリプトが(chdir などで)他の場所へ行く前に、Perl に 同梱されている Cwd モジュールを使って、カレントワーキングディレクトリを 取得できます:

        BEGIN {
                use Cwd;
                our $directory = cwd;
                }
        
        use lib $directory;

似たようなことは、スクリプト名を記録している $0 でもできます。 これは相対パスかもしれませんが、rel2abs はこれを絶対パスに変更できます。 以下のようにすると

        BEGIN { 
                use File::Spec::Functions qw(rel2abs);
                use File::Basename qw(dirname);
                
                my $path   = rel2abs( $0 );
                our $directory = dirname( $path );
                }
                
        use lib $directory;

Perl に同梱されている FindBin モジュールが働くでしょう。 これは $ENV{PATH} を検索します(従ってあなたのスクリプトはこれらの ディレクトリの一つにある必要があります)。 それからこの ($FindBin::Bin にある)ディレクトリを、追加したい ディレクトリを指定するのに使います:

        use FindBin;
        use lib "$FindBin::Bin/../lib";

実行時にインクルードパス (@INC) にディレクトリを追加するには?¶

環境変数、実行時スイッチ、コード内の文などを使って、インクルードパスを 変更するためのお薦めの方法を挙げておきます:

the PERLLIB environment variable

(PERLLIB 環境変数)

        $ export PERLLIB=/path/to/my/dir
        $ perl program.pl

the PERL5LIB environment variable

(PERL5LIB 環境変数)

        $ export PERL5LIB=/path/to/my/dir
        $ perl program.pl

the perl -Idir command line flag

(perl の -Idir コマンドラインフラグ)

        $ perl -I/path/to/my/dir program.pl

the use lib pragma:

(use lib プラグマ)

        use lib "$ENV{HOME}/myown_perllib";

最後のものが特に便利です。 なぜなら、これはマシン依存のアーキテクチャを知っているからです。 プラグマ的モジュール(pragmatic module) lib.pm は Perl 5.002 で 最初に導入されました。

socket.ph とは一体何で、それはどこで入手できますか?¶

それは Perl 4 スタイルのファイルで、ネットワーク使用のための 値を定義しているものです。 これは Perl がインストールされたときに h2ph を使って作成されることも ありますが、そうでないときもあります。 最近のやり方では use Socket を代わりに使用します。

REVISION¶

Revision: $Revision$

Date: $Date$

See perlfaq for source control details and availability.

AUTHOR AND COPYRIGHT¶

Copyright (c) 1997-2007 Tom Christiansen, Nathan Torkington, and other authors as noted. All rights reserved.

This documentation is free; you can redistribute it and/or modify it under the same terms as Perl itself.

Irrespective of its distribution, all code examples in this file are hereby placed into the public domain. You are permitted and encouraged to use this code in your own programs for fun or for profit as you see fit. A simple comment in the code giving credit would be courteous but is not required.