open FILEHANDLE,EXPR
open FILEHANDLE
Opens the file whose filename is given by EXPR, and associates it with
FILEHANDLE. If FILEHANDLE is an expression, its value is used as the
name of the real filehandle wanted. If EXPR is omitted, the scalar
variable of the same name as the FILEHANDLE contains the filename. If
the filename begins with "<" or nothing, the file is opened for input.
If the filename begins with ">", the file is opened for output. If the
filename begins with ">>", the file is opened for appending. (You can
put a '+' in front of the '>' or '<' to indicate that you want both
read and write access to the file.) If the filename begins with "|",
the filename is interpreted as a command to which output is to be
piped, and if the filename ends with a "|", the filename is interpreted
as command which pipes input to us. (You may not have a command that
pipes both in and out.) Opening '™' opens STDIN and opening '>™'
opens STDOUT. Open returns non™zero upon success, the undefined
value otherwise. If the open involved a pipe, the return value happens
to be the pid of the subprocess. Examples:
$ARTICLE = 100;
open ARTICLE or die "Can't find article $ARTICLE: $!\n";
while (<ARTICLE>) {...
open(LOG, '>>/usr/spool/news/twitlog'); # (log is reserved)
open(article, "caesar <$article |"); # decrypt article
open(extract, "|sort >/tmp/Tmp$$"); # $$ is our process id
foreach $file (@ARGV) {
process($file, 'fh00');
}
sub process {
local($filename, $input) = @_;
$input++; # this is a string increment
unless (open($input, $filename)) {
print STDERR "Can't open $filename: $!\n";
return;
}
while (<$input>) { # note use of indirection
if (/^#include "(.*)"/) {
process($1, $input);
next;
}
... # whatever
}
}
You may also, in the Bourne shell tradition, specify an EXPR beginning
with ">&", in which case the rest of the string is interpreted as the
name of a filehandle (or file descriptor, if numeric) which is to be
duped and opened. You may use & after >, >>, <, +>, +>> and +<. The
mode you specify should match the mode of the original filehandle.
Here is a script that saves, redirects, and restores STDOUT and
STDERR:
open(SAVEOUT, ">&STDOUT");
open(SAVEERR, ">&STDERR");
open(STDOUT, ">foo.out") || die "Can't redirect stdout";
open(STDERR, ">&STDOUT") || die "Can't dup stdout";
select(STDERR); $| = 1; # make unbuffered
select(STDOUT); $| = 1; # make unbuffered
print STDOUT "stdout 1\n"; # this works for
print STDERR "stderr 1\n"; # subprocesses too
close(STDOUT);
close(STDERR);
open(STDOUT, ">&SAVEOUT");
open(STDERR, ">&SAVEERR");
print STDOUT "stdout 2\n";
print STDERR "stderr 2\n";
If you specify "<&=N", where N is a number, then Perl will do an
equivalent of C's fdopen() of that file descriptor. For example:
open(FILEHANDLE, "<&=$fd")
If you open a pipe on the command "™", i.e. either "|™" or "™|", then
there is an implicit fork done, and the return value of open is the pid
of the child within the parent process, and 0 within the child
process. (Use defined($pid) to determine whether the open was successful.)
The filehandle behaves normally for the parent, but i/o to that
filehandle is piped from/to the STDOUT/STDIN of the child process.
In the child process the filehandle isn't opened™™i/o happens from/to
the new STDOUT or STDIN. Typically this is used like the normal
piped open when you want to exercise more control over just how the
pipe command gets executed, such as when you are running setuid, and
don't want to have to scan shell commands for metacharacters. The
following pairs are more or less equivalent:
open(FOO, "|tr '[a™z]' '[A™Z]'");
open(FOO, "|™") || exec 'tr', '[a™z]', '[A™Z]';
open(FOO, "cat ™n '$file'|");
open(FOO, "™|") || exec 'cat', '™n', $file;
Explicitly closing any piped filehandle causes the parent process to
wait for the child to finish, and returns the status value in $?.
Note: on any operation which may do a fork, unflushed buffers remain
unflushed in both processes, which means you may need to set $| to
avoid duplicate output.
The filename that is passed to open will have leading and trailing
whitespace deleted. In order to open a file with arbitrary weird
characters in it, it's necessary to protect any leading and trailing
whitespace thusly:
$file =~ s#^(\s)#./$1#;
open(FOO, "< $file\0");
[sh-index] Back to list of manuals
|
| |
