← Index
Performance Profile   « block view • line view • sub view »
For /wise/base/deliv/dev/bin/getfix
  Run on Thu May 20 15:30:03 2010
Reported on Thu May 20 16:25:31 2010

File/wise/base/static/lib/perl5/site_perl/5.10.0/File/Slurp.pm
Statements Executed37
Total Time0.00215 seconds

Subroutines — ordered by exclusive time
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
00000File::Slurp::BEGIN
00000File::Slurp::__ANON__[:20]
00000File::Slurp::__ANON__[:21]
00000File::Slurp::__ANON__[:22]
00000File::Slurp::__ANON__[:26]
00000File::Slurp::__ANON__[:27]
00000File::Slurp::__ANON__[:28]
00000File::Slurp::__ANON__[:34]
00000File::Slurp::__ANON__[:35]
00000File::Slurp::__ANON__[:36]
00000File::Slurp::__ANON__[:39]
00000File::Slurp::__ANON__[:40]
00000File::Slurp::__ANON__[:41]
00000File::Slurp::__ANON__[:44]
00000File::Slurp::__ANON__[:45]
00000File::Slurp::__ANON__[:46]
00000File::Slurp::_error
00000File::Slurp::append_file
00000File::Slurp::read_dir
00000File::Slurp::read_file
00000File::Slurp::write_file

LineStmts.Exclusive
Time		Avg.Code
1package File::Slurp;
2
332.9e-59.7e-6use strict;
# spent 10µs making 1 call to strict::import
4
533.2e-51.1e-5use Carp ;
# spent 51µs making 1 call to Exporter::import
633.8e-51.3e-5use POSIX qw( :fcntl_h ) ;
# spent 453µs making 1 call to POSIX::import
733.1e-51.0e-5use Fcntl qw( :DEFAULT ) ;
# spent 677µs making 1 call to Exporter::import
830.000460.00015use Symbol ;
# spent 80µs making 1 call to Exporter::import
9
1014.0e-64.0e-6my $is_win32 = $^O =~ /win32/i ;
11
12# Install subs for various constants that aren't set in older perls
13# (< 5.005). Fcntl on old perls uses Exporter to define subs without a
14# () prototype These can't be overridden with the constant pragma or
15# we get a prototype mismatch. Hence this less than aesthetically
16# appealing BEGIN block:
17
18BEGIN {
1946.0e-61.5e-6 unless( eval { defined SEEK_SET() } ) {
20 *SEEK_SET = sub { 0 };
21 *SEEK_CUR = sub { 1 };
22 *SEEK_END = sub { 2 };
23 }
24
2511.0e-61.0e-6 unless( eval { defined O_BINARY() } ) {
26 *O_BINARY = sub { 0 };
27 *O_RDONLY = sub { 0 };
28 *O_WRONLY = sub { 1 };
29 }
30
31100 unless ( eval { defined O_APPEND() } ) {
32
33 if ( $^O =~ /olaris/ ) {
34 *O_APPEND = sub { 8 };
35 *O_CREAT = sub { 256 };
36 *O_EXCL = sub { 1024 };
37 }
38 elsif ( $^O =~ /inux/ ) {
39 *O_APPEND = sub { 1024 };
40 *O_CREAT = sub { 64 };
41 *O_EXCL = sub { 128 };
42 }
43 elsif ( $^O =~ /BSD/i ) {
44 *O_APPEND = sub { 8 };
45 *O_CREAT = sub { 512 };
46 *O_EXCL = sub { 2048 };
47 }
48 }
4915.1e-55.1e-5}
50
51# print "OS [$^O]\n" ;
52
53# print "O_BINARY = ", O_BINARY(), "\n" ;
54# print "O_RDONLY = ", O_RDONLY(), "\n" ;
55# print "O_WRONLY = ", O_WRONLY(), "\n" ;
56# print "O_APPEND = ", O_APPEND(), "\n" ;
57# print "O_CREAT ", O_CREAT(), "\n" ;
58# print "O_EXCL ", O_EXCL(), "\n" ;
59
6030.000268.7e-5use base 'Exporter' ;
# spent 87µs making 1 call to base::import
6130.001210.00040use vars qw( %EXPORT_TAGS @EXPORT_OK $VERSION @EXPORT ) ;
# spent 60µs making 1 call to vars::import
62
6314.0e-64.0e-6%EXPORT_TAGS = ( 'all' => [
64 qw( read_file write_file overwrite_file append_file read_dir ) ] ) ;
65
6613.0e-63.0e-6@EXPORT = ( @{ $EXPORT_TAGS{'all'} } );
6711.0e-61.0e-6@EXPORT_OK = qw( slurp ) ;
68
6911.0e-61.0e-6$VERSION = '9999.13';
70
7112.0e-62.0e-6*slurp = \&read_file ;
72
73sub read_file {
74
75 my( $file_name, %args ) = @_ ;
76
77# set the buffer to either the passed in one or ours and init it to the null
78# string
79
80 my $buf ;
81 my $buf_ref = $args{'buf_ref'} || \$buf ;
82 ${$buf_ref} = '' ;
83
84 my( $read_fh, $size_left, $blk_size ) ;
85
86# check if we are reading from a handle (glob ref or IO:: object)
87
88 if ( ref $file_name ) {
89
90# slurping a handle so use it and don't open anything.
91# set the block size so we know it is a handle and read that amount
92
93 $read_fh = $file_name ;
94 $blk_size = $args{'blk_size'} || 1024 * 1024 ;
95 $size_left = $blk_size ;
96
97# DEEP DARK MAGIC. this checks the UNTAINT IO flag of a
98# glob/handle. only the DATA handle is untainted (since it is from
99# trusted data in the source file). this allows us to test if this is
100# the DATA handle and then to do a sysseek to make sure it gets
101# slurped correctly. on some systems, the buffered i/o pointer is not
102# left at the same place as the fd pointer. this sysseek makes them
103# the same so slurping with sysread will work.
104
105 eval{ require B } ;
106
107 if ( $@ ) {
108
109 @_ = ( \%args, <<ERR ) ;
110Can't find B.pm with this Perl: $!.
111That module is needed to slurp the DATA handle.
112ERR
113 goto &_error ;
114 }
115
116 if ( B::svref_2object( $read_fh )->IO->IoFLAGS & 16 ) {
117
118# set the seek position to the current tell.
119
120 sysseek( $read_fh, tell( $read_fh ), SEEK_SET ) ||
121 croak "sysseek $!" ;
122 }
123 }
124 else {
125
126# a regular file. set the sysopen mode
127
128 my $mode = O_RDONLY ;
129 $mode |= O_BINARY if $args{'binmode'} ;
130
131#printf "RD: BINARY %x MODE %x\n", O_BINARY, $mode ;
132
133# open the file and handle any error
134
135 $read_fh = gensym ;
136 unless ( sysopen( $read_fh, $file_name, $mode ) ) {
137 @_ = ( \%args, "read_file '$file_name' - sysopen: $!");
138 goto &_error ;
139 }
140
141# get the size of the file for use in the read loop
142
143 $size_left = -s $read_fh ;
144
145 unless( $size_left ) {
146
147 $blk_size = $args{'blk_size'} || 1024 * 1024 ;
148 $size_left = $blk_size ;
149 }
150 }
151
152# infinite read loop. we exit when we are done slurping
153
154 while( 1 ) {
155
156# do the read and see how much we got
157
158 my $read_cnt = sysread( $read_fh, ${$buf_ref},
159 $size_left, length ${$buf_ref} ) ;
160
161 if ( defined $read_cnt ) {
162
163# good read. see if we hit EOF (nothing left to read)
164
165 last if $read_cnt == 0 ;
166
167# loop if we are slurping a handle. we don't track $size_left then.
168
169 next if $blk_size ;
170
171# count down how much we read and loop if we have more to read.
172 $size_left -= $read_cnt ;
173 last if $size_left <= 0 ;
174 next ;
175 }
176
177# handle the read error
178
179 @_ = ( \%args, "read_file '$file_name' - sysread: $!");
180 goto &_error ;
181 }
182
183# fix up cr/lf to be a newline if this is a windows text file
184
185 ${$buf_ref} =~ s/\015\012/\n/g if $is_win32 && !$args{'binmode'} ;
186
187# this is the 5 returns in a row. each handles one possible
188# combination of caller context and requested return type
189
190 my $sep = $/ ;
191 $sep = '\n\n+' if defined $sep && $sep eq '' ;
192
193# caller wants to get an array ref of lines
194
195# this split doesn't work since it tries to use variable length lookbehind
196# the m// line works.
197# return [ split( m|(?<=$sep)|, ${$buf_ref} ) ] if $args{'array_ref'} ;
198 return [ length(${$buf_ref}) ? ${$buf_ref} =~ /(.*?$sep|.+)/sg : () ]
199 if $args{'array_ref'} ;
200
201# caller wants a list of lines (normal list context)
202
203# same problem with this split as before.
204# return split( m|(?<=$sep)|, ${$buf_ref} ) if wantarray ;
205 return length(${$buf_ref}) ? ${$buf_ref} =~ /(.*?$sep|.+)/sg : ()
206 if wantarray ;
207
208# caller wants a scalar ref to the slurped text
209
210 return $buf_ref if $args{'scalar_ref'} ;
211
212# caller wants a scalar with the slurped text (normal scalar context)
213
214 return ${$buf_ref} if defined wantarray ;
215
216# caller passed in an i/o buffer by reference (normal void context)
217
218 return ;
219}
220
221sub write_file {
222
223 my $file_name = shift ;
224
225# get the optional argument hash ref from @_ or an empty hash ref.
226
227 my $args = ( ref $_[0] eq 'HASH' ) ? shift : {} ;
228
229 my( $buf_ref, $write_fh, $no_truncate, $orig_file_name, $data_is_ref ) ;
230
231# get the buffer ref - it depends on how the data is passed into write_file
232# after this if/else $buf_ref will have a scalar ref to the data.
233
234 if ( ref $args->{'buf_ref'} eq 'SCALAR' ) {
235
236# a scalar ref passed in %args has the data
237# note that the data was passed by ref
238
239 $buf_ref = $args->{'buf_ref'} ;
240 $data_is_ref = 1 ;
241 }
242 elsif ( ref $_[0] eq 'SCALAR' ) {
243
244# the first value in @_ is the scalar ref to the data
245# note that the data was passed by ref
246
247 $buf_ref = shift ;
248 $data_is_ref = 1 ;
249 }
250 elsif ( ref $_[0] eq 'ARRAY' ) {
251
252# the first value in @_ is the array ref to the data so join it.
253
254 ${$buf_ref} = join '', @{$_[0]} ;
255 }
256 else {
257
258# good old @_ has all the data so join it.
259
260 ${$buf_ref} = join '', @_ ;
261 }
262
263# see if we were passed a open handle to spew to.
264
265 if ( ref $file_name ) {
266
267# we have a handle. make sure we don't call truncate on it.
268
269 $write_fh = $file_name ;
270 $no_truncate = 1 ;
271 }
272 else {
273
274# spew to regular file.
275
276 if ( $args->{'atomic'} ) {
277
278# in atomic mode, we spew to a temp file so make one and save the original
279# file name.
280 $orig_file_name = $file_name ;
281 $file_name .= ".$$" ;
282 }
283
284# set the mode for the sysopen
285
286 my $mode = O_WRONLY | O_CREAT ;
287 $mode |= O_BINARY if $args->{'binmode'} ;
288 $mode |= O_APPEND if $args->{'append'} ;
289 $mode |= O_EXCL if $args->{'no_clobber'} ;
290
291#printf "WR: BINARY %x MODE %x\n", O_BINARY, $mode ;
292
293# open the file and handle any error.
294
295 $write_fh = gensym ;
296 unless ( sysopen( $write_fh, $file_name, $mode ) ) {
297 @_ = ( $args, "write_file '$file_name' - sysopen: $!");
298 goto &_error ;
299 }
300 }
301
302 sysseek( $write_fh, 0, SEEK_END ) if $args->{'append'} ;
303
304
305#print 'WR before data ', unpack( 'H*', ${$buf_ref}), "\n" ;
306
307# fix up newline to write cr/lf if this is a windows text file
308
309 if ( $is_win32 && !$args->{'binmode'} ) {
310
311# copy the write data if it was passed by ref so we don't clobber the
312# caller's data
313 $buf_ref = \do{ my $copy = ${$buf_ref}; } if $data_is_ref ;
314 ${$buf_ref} =~ s/\n/\015\012/g ;
315 }
316
317#print 'after data ', unpack( 'H*', ${$buf_ref}), "\n" ;
318
319# get the size of how much we are writing and init the offset into that buffer
320
321 my $size_left = length( ${$buf_ref} ) ;
322 my $offset = 0 ;
323
324# loop until we have no more data left to write
325
326 do {
327
328# do the write and track how much we just wrote
329
330 my $write_cnt = syswrite( $write_fh, ${$buf_ref},
331 $size_left, $offset ) ;
332
333 unless ( defined $write_cnt ) {
334
335# the write failed
336 @_ = ( $args, "write_file '$file_name' - syswrite: $!");
337 goto &_error ;
338 }
339
340# track much left to write and where to write from in the buffer
341
342 $size_left -= $write_cnt ;
343 $offset += $write_cnt ;
344
345 } while( $size_left > 0 ) ;
346
347# we truncate regular files in case we overwrite a long file with a shorter file
348# so seek to the current position to get it (same as tell()).
349
350 truncate( $write_fh,
351 sysseek( $write_fh, 0, SEEK_CUR ) ) unless $no_truncate ;
352
353 close( $write_fh ) ;
354
355# handle the atomic mode - move the temp file to the original filename.
356
357 rename( $file_name, $orig_file_name ) if $args->{'atomic'} ;
358
359 return 1 ;
360}
361
362# this is for backwards compatibility with the previous File::Slurp module.
363# write_file always overwrites an existing file
364
36511.0e-61.0e-6*overwrite_file = \&write_file ;
366
367# the current write_file has an append mode so we use that. this
368# supports the same API with an optional second argument which is a
369# hash ref of options.
370
371sub append_file {
372
373# get the optional args hash ref
374 my $args = $_[1] ;
375 if ( ref $args eq 'HASH' ) {
376
377# we were passed an args ref so just mark the append mode
378
379 $args->{append} = 1 ;
380 }
381 else {
382
383# no args hash so insert one with the append mode
384
385 splice( @_, 1, 0, { append => 1 } ) ;
386 }
387
388# magic goto the main write_file sub. this overlays the sub without touching
389# the stack or @_
390
391 goto &write_file
392}
393
394# basic wrapper around opendir/readdir
395
396sub read_dir {
397
398 my ($dir, %args ) = @_;
399
400# this handle will be destroyed upon return
401
402 local(*DIRH);
403
404# open the dir and handle any errors
405
406 unless ( opendir( DIRH, $dir ) ) {
407
408 @_ = ( \%args, "read_dir '$dir' - opendir: $!" ) ;
409 goto &_error ;
410 }
411
412 my @dir_entries = readdir(DIRH) ;
413
414 @dir_entries = grep( $_ ne "." && $_ ne "..", @dir_entries )
415 unless $args{'keep_dot_dot'} ;
416
417 return @dir_entries if wantarray ;
418 return \@dir_entries ;
419}
420
421# error handling section
422#
423# all the error handling uses magic goto so the caller will get the
424# error message as if from their code and not this module. if we just
425# did a call on the error code, the carp/croak would report it from
426# this module since the error sub is one level down on the call stack
427# from read_file/write_file/read_dir.
428
429
43012.0e-62.0e-6my %err_func = (
431 'carp' => \&carp,
432 'croak' => \&croak,
433) ;
434
435sub _error {
436
437 my( $args, $err_msg ) = @_ ;
438
439# get the error function to use
440
441 my $func = $err_func{ $args->{'err_mode'} || 'croak' } ;
442
443# if we didn't find it in our error function hash, they must have set
444# it to quiet and we don't do anything.
445
446 return unless $func ;
447
448# call the carp/croak function
449
450 $func->($err_msg) ;
451
452# return a hard undef (in list context this will be a single value of
453# undef which is not a legal in-band value)
454
455 return undef ;
456}
457
45811.2e-51.2e-51;
459__END__
460
461=head1 NAME
462
463File::Slurp - Efficient Reading/Writing of Complete Files
464
465=head1 SYNOPSIS
466
467 use File::Slurp;
468
469 my $text = read_file( 'filename' ) ;
470 my @lines = read_file( 'filename' ) ;
471
472 write_file( 'filename', @lines ) ;
473
474 use File::Slurp qw( slurp ) ;
475
476 my $text = slurp( 'filename' ) ;
477
478
479=head1 DESCRIPTION
480
481This module provides subs that allow you to read or write entire files
482with one simple call. They are designed to be simple to use, have
483flexible ways to pass in or get the file contents and to be very
484efficient. There is also a sub to read in all the files in a
485directory other than C<.> and C<..>
486
487These slurp/spew subs work for files, pipes and
488sockets, and stdio, pseudo-files, and DATA.
489
490=head2 B<read_file>
491
492This sub reads in an entire file and returns its contents to the
493caller. In list context it will return a list of lines (using the
494current value of $/ as the separator including support for paragraph
495mode when it is set to ''). In scalar context it returns the entire
496file as a single scalar.
497
498 my $text = read_file( 'filename' ) ;
499 my @lines = read_file( 'filename' ) ;
500
501The first argument to C<read_file> is the filename and the rest of the
502arguments are key/value pairs which are optional and which modify the
503behavior of the call. Other than binmode the options all control how
504the slurped file is returned to the caller.
505
506If the first argument is a file handle reference or I/O object (if ref
507is true), then that handle is slurped in. This mode is supported so
508you slurp handles such as C<DATA>, C<STDIN>. See the test handle.t
509for an example that does C<open( '-|' )> and child process spews data
510to the parant which slurps it in. All of the options that control how
511the data is returned to the caller still work in this case.
512
513NOTE: as of version 9999.06, read_file works correctly on the C<DATA>
514handle. It used to need a sysseek workaround but that is now handled
515when needed by the module itself.
516
517You can optionally request that C<slurp()> is exported to your code. This
518is an alias for read_file and is meant to be forward compatible with
519Perl 6 (which will have slurp() built-in).
520
521The options are:
522
523=head3 binmode
524
525If you set the binmode option, then the file will be slurped in binary
526mode.
527
528 my $bin_data = read_file( $bin_file, binmode => ':raw' ) ;
529
530NOTE: this actually sets the O_BINARY mode flag for sysopen. It
531probably should call binmode and pass its argument to support other
532file modes.
533
534=head3 array_ref
535
536If this boolean option is set, the return value (only in scalar
537context) will be an array reference which contains the lines of the
538slurped file. The following two calls are equivalent:
539
540 my $lines_ref = read_file( $bin_file, array_ref => 1 ) ;
541 my $lines_ref = [ read_file( $bin_file ) ] ;
542
543=head3 scalar_ref
544
545If this boolean option is set, the return value (only in scalar
546context) will be an scalar reference to a string which is the contents
547of the slurped file. This will usually be faster than returning the
548plain scalar.
549
550 my $text_ref = read_file( $bin_file, scalar_ref => 1 ) ;
551
552=head3 buf_ref
553
554You can use this option to pass in a scalar reference and the slurped
555file contents will be stored in the scalar. This can be used in
556conjunction with any of the other options.
557
558 my $text_ref = read_file( $bin_file, buf_ref => \$buffer,
559 array_ref => 1 ) ;
560 my @lines = read_file( $bin_file, buf_ref => \$buffer ) ;
561
562=head3 blk_size
563
564You can use this option to set the block size used when slurping from an already open handle (like \*STDIN). It defaults to 1MB.
565
566 my $text_ref = read_file( $bin_file, blk_size => 10_000_000,
567 array_ref => 1 ) ;
568
569=head3 err_mode
570
571You can use this option to control how read_file behaves when an error
572occurs. This option defaults to 'croak'. You can set it to 'carp' or
573to 'quiet to have no error handling. This code wants to carp and then
574read abother file if it fails.
575
576 my $text_ref = read_file( $file, err_mode => 'carp' ) ;
577 unless ( $text_ref ) {
578
579 # read a different file but croak if not found
580 $text_ref = read_file( $another_file ) ;
581 }
582
583 # process ${$text_ref}
584
585=head2 B<write_file>
586
587This sub writes out an entire file in one call.
588
589 write_file( 'filename', @data ) ;
590
591The first argument to C<write_file> is the filename. The next argument
592is an optional hash reference and it contains key/values that can
593modify the behavior of C<write_file>. The rest of the argument list is
594the data to be written to the file.
595
596 write_file( 'filename', {append => 1 }, @data ) ;
597 write_file( 'filename', {binmode => ':raw' }, $buffer ) ;
598
599As a shortcut if the first data argument is a scalar or array
600reference, it is used as the only data to be written to the file. Any
601following arguments in @_ are ignored. This is a faster way to pass in
602the output to be written to the file and is equivilent to the
603C<buf_ref> option. These following pairs are equivilent but the pass
604by reference call will be faster in most cases (especially with larger
605files).
606
607 write_file( 'filename', \$buffer ) ;
608 write_file( 'filename', $buffer ) ;
609
610 write_file( 'filename', \@lines ) ;
611 write_file( 'filename', @lines ) ;
612
613If the first argument is a file handle reference or I/O object (if ref
614is true), then that handle is slurped in. This mode is supported so
615you spew to handles such as \*STDOUT. See the test handle.t for an
616example that does C<open( '-|' )> and child process spews data to the
617parant which slurps it in. All of the options that control how the
618data is passes into C<write_file> still work in this case.
619
620C<write_file> returns 1 upon successfully writing the file or undef if
621it encountered an error.
622
623The options are:
624
625=head3 binmode
626
627If you set the binmode option, then the file will be written in binary
628mode.
629
630 write_file( $bin_file, {binmode => ':raw'}, @data ) ;
631
632NOTE: this actually sets the O_BINARY mode flag for sysopen. It
633probably should call binmode and pass its argument to support other
634file modes.
635
636=head3 buf_ref
637
638You can use this option to pass in a scalar reference which has the
639data to be written. If this is set then any data arguments (including
640the scalar reference shortcut) in @_ will be ignored. These are
641equivilent:
642
643 write_file( $bin_file, { buf_ref => \$buffer } ) ;
644 write_file( $bin_file, \$buffer ) ;
645 write_file( $bin_file, $buffer ) ;
646
647=head3 atomic
648
649If you set this boolean option, the file will be written to in an
650atomic fashion. A temporary file name is created by appending the pid
651($$) to the file name argument and that file is spewed to. After the
652file is closed it is renamed to the original file name (and rename is
653an atomic operation on most OS's). If the program using this were to
654crash in the middle of this, then the file with the pid suffix could
655be left behind.
656
657=head3 append
658
659If you set this boolean option, the data will be written at the end of
660the current file.
661
662 write_file( $file, {append => 1}, @data ) ;
663
664C<write_file> croaks if it cannot open the file. It returns true if it
665succeeded in writing out the file and undef if there was an
666error. (Yes, I know if it croaks it can't return anything but that is
667for when I add the options to select the error handling mode).
668
669=head3 no_clobber
670
671If you set this boolean option, an existing file will not be overwritten.
672
673 write_file( $file, {no_clobber => 1}, @data ) ;
674
675=head3 err_mode
676
677You can use this option to control how C<write_file> behaves when an
678error occurs. This option defaults to 'croak'. You can set it to
679'carp' or to 'quiet' to have no error handling other than the return
680value. If the first call to C<write_file> fails it will carp and then
681write to another file. If the second call to C<write_file> fails, it
682will croak.
683
684 unless ( write_file( $file, { err_mode => 'carp', \$data ) ;
685
686 # write a different file but croak if not found
687 write_file( $other_file, \$data ) ;
688 }
689
690=head2 overwrite_file
691
692This sub is just a typeglob alias to write_file since write_file
693always overwrites an existing file. This sub is supported for
694backwards compatibility with the original version of this module. See
695write_file for its API and behavior.
696
697=head2 append_file
698
699This sub will write its data to the end of the file. It is a wrapper
700around write_file and it has the same API so see that for the full
701documentation. These calls are equivilent:
702
703 append_file( $file, @data ) ;
704 write_file( $file, {append => 1}, @data ) ;
705
706=head2 read_dir
707
708This sub reads all the file names from directory and returns them to
709the caller but C<.> and C<..> are removed by default.
710
711 my @files = read_dir( '/path/to/dir' ) ;
712
713It croaks if it cannot open the directory.
714
715In a list context C<read_dir> returns a list of the entries in the
716directory. In a scalar context it returns an array reference which has
717the entries.
718
719=head3 keep_dot_dot
720
721If this boolean option is set, C<.> and C<..> are not removed from the
722list of files.
723
724 my @all_files = read_dir( '/path/to/dir', keep_dot_dot => 1 ) ;
725
726=head2 EXPORT
727
728 read_file write_file overwrite_file append_file read_dir
729
730=head2 SEE ALSO
731
732An article on file slurping in extras/slurp_article.pod. There is
733also a benchmarking script in extras/slurp_bench.pl.
734
735=head2 BUGS
736
737If run under Perl 5.004, slurping from the DATA handle will fail as
738that requires B.pm which didn't get into core until 5.005.
739
740=head1 AUTHOR
741
742Uri Guttman, E<lt>uri@stemsystems.comE<gt>
743
744=cut

Report produced by the NYTProf 2.07 Perl profiler, developed by Tim Bunce and Adam Kaplan.