1package FileHandle;
2
3use 5.006;
4use strict;
5our($VERSION, @ISA, @EXPORT, @EXPORT_OK);
6
7$VERSION = "2.03";
8
9require IO::File;
10@ISA = qw(IO::File);
11
12@EXPORT = qw(_IOFBF _IOLBF _IONBF);
13
14@EXPORT_OK = qw(
15    pipe
16
17    autoflush
18    output_field_separator
19    output_record_separator
20    input_record_separator
21    input_line_number
22    format_page_number
23    format_lines_per_page
24    format_lines_left
25    format_name
26    format_top_name
27    format_line_break_characters
28    format_formfeed
29
30    print
31    printf
32    getline
33    getlines
34);
35
36#
37# Everything we're willing to export, we must first import.
38#
39IO::Handle->import( grep { !defined(&$_) } @EXPORT, @EXPORT_OK );
40
41#
42# Some people call "FileHandle::function", so all the functions
43# that were in the old FileHandle class must be imported, too.
44#
45{
46    no strict 'refs';
47
48    my %import = (
49	'IO::Handle' =>
50	    [qw(DESTROY new_from_fd fdopen close fileno getc ungetc gets
51		eof flush error clearerr setbuf setvbuf _open_mode_string)],
52	'IO::Seekable' =>
53	    [qw(seek tell getpos setpos)],
54	'IO::File' =>
55	    [qw(new new_tmpfile open)]
56    );
57    for my $pkg (keys %import) {
58	for my $func (@{$import{$pkg}}) {
59	    my $c = *{"${pkg}::$func"}{CODE}
60		or die "${pkg}::$func missing";
61	    *$func = $c;
62	}
63    }
64}
65
66#
67# Specialized importer for Fcntl magic.
68#
69sub import {
70    my $pkg = shift;
71    my $callpkg = caller;
72    require Exporter;
73    Exporter::export($pkg, $callpkg, @_);
74
75    #
76    # If the Fcntl extension is available,
77    #  export its constants.
78    #
79    eval {
80	require Fcntl;
81	Exporter::export('Fcntl', $callpkg);
82    };
83}
84
85################################################
86# This is the only exported function we define;
87# the rest come from other classes.
88#
89
90sub pipe {
91    my $r = IO::Handle->new;
92    my $w = IO::Handle->new;
93    CORE::pipe($r, $w) or return undef;
94    ($r, $w);
95}
96
97# Rebless standard file handles
98bless *STDIN{IO},  "FileHandle" if ref *STDIN{IO}  eq "IO::Handle";
99bless *STDOUT{IO}, "FileHandle" if ref *STDOUT{IO} eq "IO::Handle";
100bless *STDERR{IO}, "FileHandle" if ref *STDERR{IO} eq "IO::Handle";
101
1021;
103
104__END__
105
106=head1 NAME
107
108FileHandle - supply object methods for filehandles
109
110=head1 SYNOPSIS
111
112    use FileHandle;
113
114    $fh = FileHandle->new;
115    if ($fh->open("< file")) {
116        print <$fh>;
117        $fh->close;
118    }
119
120    $fh = FileHandle->new("> FOO");
121    if (defined $fh) {
122        print $fh "bar\n";
123        $fh->close;
124    }
125
126    $fh = FileHandle->new("file", "r");
127    if (defined $fh) {
128        print <$fh>;
129        undef $fh;       # automatically closes the file
130    }
131
132    $fh = FileHandle->new("file", O_WRONLY|O_APPEND);
133    if (defined $fh) {
134        print $fh "corge\n";
135        undef $fh;       # automatically closes the file
136    }
137
138    $pos = $fh->getpos;
139    $fh->setpos($pos);
140
141    $fh->setvbuf($buffer_var, _IOLBF, 1024);
142
143    ($readfh, $writefh) = FileHandle::pipe;
144
145    autoflush STDOUT 1;
146
147=head1 DESCRIPTION
148
149NOTE: This class is now a front-end to the IO::* classes.
150
151C<FileHandle::new> creates a C<FileHandle>, which is a reference to a
152newly created symbol (see the C<Symbol> package).  If it receives any
153parameters, they are passed to C<FileHandle::open>; if the open fails,
154the C<FileHandle> object is destroyed.  Otherwise, it is returned to
155the caller.
156
157C<FileHandle::new_from_fd> creates a C<FileHandle> like C<new> does.
158It requires two parameters, which are passed to C<FileHandle::fdopen>;
159if the fdopen fails, the C<FileHandle> object is destroyed.
160Otherwise, it is returned to the caller.
161
162C<FileHandle::open> accepts one parameter or two.  With one parameter,
163it is just a front end for the built-in C<open> function.  With two
164parameters, the first parameter is a filename that may include
165whitespace or other special characters, and the second parameter is
166the open mode, optionally followed by a file permission value.
167
168If C<FileHandle::open> receives a Perl mode string (">", "+<", etc.)
169or a POSIX fopen() mode string ("w", "r+", etc.), it uses the basic
170Perl C<open> operator.
171
172If C<FileHandle::open> is given a numeric mode, it passes that mode
173and the optional permissions value to the Perl C<sysopen> operator.
174For convenience, C<FileHandle::import> tries to import the O_XXX
175constants from the Fcntl module.  If dynamic loading is not available,
176this may fail, but the rest of FileHandle will still work.
177
178C<FileHandle::fdopen> is like C<open> except that its first parameter
179is not a filename but rather a file handle name, a FileHandle object,
180or a file descriptor number.
181
182If the C functions fgetpos() and fsetpos() are available, then
183C<FileHandle::getpos> returns an opaque value that represents the
184current position of the FileHandle, and C<FileHandle::setpos> uses
185that value to return to a previously visited position.
186
187If the C function setvbuf() is available, then C<FileHandle::setvbuf>
188sets the buffering policy for the FileHandle.  The calling sequence
189for the Perl function is the same as its C counterpart, including the
190macros C<_IOFBF>, C<_IOLBF>, and C<_IONBF>, except that the buffer
191parameter specifies a scalar variable to use as a buffer.  WARNING: A
192variable used as a buffer by C<FileHandle::setvbuf> must not be
193modified in any way until the FileHandle is closed or until
194C<FileHandle::setvbuf> is called again, or memory corruption may
195result!
196
197See L<perlfunc> for complete descriptions of each of the following
198supported C<FileHandle> methods, which are just front ends for the
199corresponding built-in functions:
200
201    close
202    fileno
203    getc
204    gets
205    eof
206    clearerr
207    seek
208    tell
209
210See L<perlvar> for complete descriptions of each of the following
211supported C<FileHandle> methods:
212
213    autoflush
214    output_field_separator
215    output_record_separator
216    input_record_separator
217    input_line_number
218    format_page_number
219    format_lines_per_page
220    format_lines_left
221    format_name
222    format_top_name
223    format_line_break_characters
224    format_formfeed
225
226Furthermore, for doing normal I/O you might need these:
227
228=over 4
229
230=item $fh->print
231
232See L<perlfunc/print>.
233
234=item $fh->printf
235
236See L<perlfunc/printf>.
237
238=item $fh->getline
239
240This works like <$fh> described in L<perlop/"I/O Operators">
241except that it's more readable and can be safely called in a
242list context but still returns just one line.
243
244=item $fh->getlines
245
246This works like <$fh> when called in a list context to
247read all the remaining lines in a file, except that it's more readable.
248It will also croak() if accidentally called in a scalar context.
249
250=back
251
252There are many other functions available since FileHandle is descended
253from IO::File, IO::Seekable, and IO::Handle.  Please see those
254respective pages for documentation on more functions.
255
256=head1 SEE ALSO
257
258The B<IO> extension,
259L<perlfunc>,
260L<perlop/"I/O Operators">.
261
262=cut
263