5 use vars qw($VERSION @ISA @EXPORT @EXPORT_OK);
12 @EXPORT = qw(_IOFBF _IOLBF _IONBF);
18 output_field_separator
19 output_record_separator
20 input_record_separator
27 format_line_break_characters
37 # Everything we're willing to export, we must first import.
39 import IO::Handle grep { !defined(&$_) } @EXPORT, @EXPORT_OK;
42 # Some people call "FileHandle::function", so all the functions
43 # that were in the old FileHandle class must be imported, too.
50 [qw(DESTROY new_from_fd fdopen close fileno getc ungetc gets
51 eof flush error clearerr setbuf setvbuf _open_mode_string)],
53 [qw(seek tell getpos setpos)],
55 [qw(new new_tmpfile open)]
57 for my $pkg (keys %import) {
58 for my $func (@{$import{$pkg}}) {
59 my $c = *{"${pkg}::$func"}{CODE}
60 or die "${pkg}::$func missing";
67 # Specialized importer for Fcntl magic.
72 Exporter::export $pkg, $callpkg, @_;
75 # If the Fcntl extension is available,
76 # export its constants.
80 Exporter::export 'Fcntl', $callpkg;
84 ################################################
85 # This is the only exported function we define;
86 # the rest come from other classes.
90 my $r = new IO::Handle;
91 my $w = new IO::Handle;
92 CORE::pipe($r, $w) or return undef;
96 # Rebless standard file handles
97 bless *STDIN{IO}, "FileHandle" if ref *STDIN{IO} eq "IO::Handle";
98 bless *STDOUT{IO}, "FileHandle" if ref *STDOUT{IO} eq "IO::Handle";
99 bless *STDERR{IO}, "FileHandle" if ref *STDERR{IO} eq "IO::Handle";
107 FileHandle - supply object methods for filehandles
113 $fh = new FileHandle;
114 if ($fh->open "< file") {
119 $fh = new FileHandle "> FOO";
125 $fh = new FileHandle "file", "r";
128 undef $fh; # automatically closes the file
131 $fh = new FileHandle "file", O_WRONLY|O_APPEND;
134 undef $fh; # automatically closes the file
140 $fh->setvbuf($buffer_var, _IOLBF, 1024);
142 ($readfh, $writefh) = FileHandle::pipe;
148 NOTE: This class is now a front-end to the IO::* classes.
150 C<FileHandle::new> creates a C<FileHandle>, which is a reference to a
151 newly created symbol (see the C<Symbol> package). If it receives any
152 parameters, they are passed to C<FileHandle::open>; if the open fails,
153 the C<FileHandle> object is destroyed. Otherwise, it is returned to
156 C<FileHandle::new_from_fd> creates a C<FileHandle> like C<new> does.
157 It requires two parameters, which are passed to C<FileHandle::fdopen>;
158 if the fdopen fails, the C<FileHandle> object is destroyed.
159 Otherwise, it is returned to the caller.
161 C<FileHandle::open> accepts one parameter or two. With one parameter,
162 it is just a front end for the built-in C<open> function. With two
163 parameters, the first parameter is a filename that may include
164 whitespace or other special characters, and the second parameter is
165 the open mode, optionally followed by a file permission value.
167 If C<FileHandle::open> receives a Perl mode string (">", "+<", etc.)
168 or a POSIX fopen() mode string ("w", "r+", etc.), it uses the basic
169 Perl C<open> operator.
171 If C<FileHandle::open> is given a numeric mode, it passes that mode
172 and the optional permissions value to the Perl C<sysopen> operator.
173 For convenience, C<FileHandle::import> tries to import the O_XXX
174 constants from the Fcntl module. If dynamic loading is not available,
175 this may fail, but the rest of FileHandle will still work.
177 C<FileHandle::fdopen> is like C<open> except that its first parameter
178 is not a filename but rather a file handle name, a FileHandle object,
179 or a file descriptor number.
181 If the C functions fgetpos() and fsetpos() are available, then
182 C<FileHandle::getpos> returns an opaque value that represents the
183 current position of the FileHandle, and C<FileHandle::setpos> uses
184 that value to return to a previously visited position.
186 If the C function setvbuf() is available, then C<FileHandle::setvbuf>
187 sets the buffering policy for the FileHandle. The calling sequence
188 for the Perl function is the same as its C counterpart, including the
189 macros C<_IOFBF>, C<_IOLBF>, and C<_IONBF>, except that the buffer
190 parameter specifies a scalar variable to use as a buffer. WARNING: A
191 variable used as a buffer by C<FileHandle::setvbuf> must not be
192 modified in any way until the FileHandle is closed or until
193 C<FileHandle::setvbuf> is called again, or memory corruption may
196 See L<perlfunc> for complete descriptions of each of the following
197 supported C<FileHandle> methods, which are just front ends for the
198 corresponding built-in functions:
209 See L<perlvar> for complete descriptions of each of the following
210 supported C<FileHandle> methods:
213 output_field_separator
214 output_record_separator
215 input_record_separator
218 format_lines_per_page
222 format_line_break_characters
225 Furthermore, for doing normal I/O you might need these:
231 See L<perlfunc/print>.
235 See L<perlfunc/printf>.
239 This works like <$fh> described in L<perlop/"I/O Operators">
240 except that it's more readable and can be safely called in an
241 array context but still returns just one line.
245 This works like <$fh> when called in an array context to
246 read all the remaining lines in a file, except that it's more readable.
247 It will also croak() if accidentally called in a scalar context.
255 L<perlop/"I/O Operators">.