*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> perlfaq5 (1)              
Title
Content
Arch
Section
 

Contents


PERLFAQ5(1)							   PERLFAQ5(1)


NAME    [Toc]    [Back]

     perlfaq5 -	Files and Formats ($Revision: 1.22 $, $Date: 1997/04/24
     22:44:02 $)

DESCRIPTION    [Toc]    [Back]

     This section deals	with I/O and the "f" issues: filehandles, flushing,
     formats, and footers.

     How do I flush/unbuffer a filehandle?  Why	must I do this?

     The C standard I/O	library	(stdio)	normally buffers characters sent to
     devices.  This is done for	efficiency reasons, so that there isn't	a
     system call for each byte.	 Any time you use print() or write() in	Perl,
     you go though this	buffering.  syswrite() circumvents stdio and
     buffering.

     In	most stdio implementations, the	type of	buffering and the size of the
     buffer varies according to	the type of device.  Disk files	are block
     buffered, often with a buffer size	of more	than 2k.  Pipes	and sockets
     are often buffered	with a buffer size between 1/2 and 2k.	Serial devices
     (e.g. modems, terminals) are normally line-buffered, and stdio sends the
     entire line when it gets the newline.

     Perl does not support truly unbuffered output (except insofar as you can
     syswrite(OUT, $char, 1)).	What it	does instead support is	"command
     buffering", in which a physical write is performed	after every output
     command.  This isn't as hard on your system as unbuffering, but does get
     the output	where you want it when you want	it.

     If	you expect characters to get to	your device when you print them	there,
     you'll want to autoflush its handle, as in	the older:

	 use FileHandle;
	 open(DEV, "<+/dev/tty");      # ceci n'est pas	une pipe
	 DEV->autoflush(1);

     or	the newer IO::*	modules:

	 use IO::Handle;
	 open(DEV, ">/dev/printer");   # but is	this?
	 DEV->autoflush(1);

     or	even this:

	 use IO::Socket;	       # this one is kinda a pipe?
	 $sock = IO::Socket::INET->new(PeerAddr	=> 'www.perl.com',
				       PeerPort	=> 'http(80)',
				       Proto	=> 'tcp');
	 die "$!" unless $sock;






									Page 1






PERLFAQ5(1)							   PERLFAQ5(1)



	 $sock->autoflush();
	 $sock->print("GET /\015\012");
	 $document = join('', $sock->getlines());
	 print "DOC IS:	$document\n";

     Note the hardcoded	carriage return	and newline in their octal
     equivalents.  This	is the ONLY way	(currently) to assure a	proper flush
     on	all platforms, including Macintosh.

     You can use select() and the $| variable to control autoflushing (see the
     section on	$| in the perlvar manpage and the select entry in the perlfunc
     manpage):

	 $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]);


     How do I change one line in a file/delete a line in a file/insert a line
     in	the middle of a	file/append to the beginning of	a file?

     Although humans have an easy time thinking	of a text file as being	a
     sequence of lines that operates much like a stack of playing cards	-- or
     punch cards -- computers usually see the text file	as a sequence of
     bytes.  In	general, there's no direct way for Perl	to seek	to a
     particular	line of	a file,	insert text into a file, or remove text	from a
     file.

     (There are	exceptions in special circumstances.  Replacing	a sequence of
     bytes with	another	sequence of the	same length is one.  Another is	using
     the $DB_RECNO array bindings as documented	in the DB_File manpage.	 Yet
     another is	manipulating files with	all lines the same length.)

     The general solution is to	create a temporary copy	of the text file with
     the changes you want, then	copy that over the original.

	 $old =	$file;
	 $new =	"$file.tmp.$$";
	 $bak =	"$file.bak";

	 open(OLD, "< $old")	     or	die "can't open	$old: $!";
	 open(NEW, "> $new")	     or	die "can't open	$new: $!";

	 # Correct typos, preserving case
	 while (<OLD>) {
	     s/\b(p)earl\b/${1}erl/i;
	     (print NEW	$_)	     or	die "can't write to $new: $!";
	 }



									Page 2






PERLFAQ5(1)							   PERLFAQ5(1)



	 close(OLD)		     or	die "can't close $old: $!";
	 close(NEW)		     or	die "can't close $new: $!";

	 rename($old, $bak)	     or	die "can't rename $old to $bak:	$!";
	 rename($new, $old)	     or	die "can't rename $new to $old:	$!";

     Perl can do this sort of thing for	you automatically with the -i
     command-line switch or the	closely-related	$^I variable (see the perlrun
     manpage for more details).	 Note that -i may require a suffix on some
     non-Unix systems; see the platform-specific documentation that came with
     your port.

	 # Renumber a series of	tests from the command line
	 perl -pi -e 's/(^\s+test\s+)\d+/ $1 . ++$count	/e' t/op/taint.t

	 # form	a script
	 local($^I, @ARGV) = ('.bak', glob("*.c"));
	 while (<>) {
	     if	($. == 1) {
		 print "This line should appear	at the top of each file\n";
	     }
	     s/\b(p)earl\b/${1}erl/i;	     # Correct typos, preserving case
	     print;
	     close ARGV	if eof;		     # Reset $.
	 }

     If	you need to seek to an arbitrary line of a file	that changes
     infrequently, you could build up an index of byte positions of where the
     line ends are in the file.	 If the	file is	large, an index	of every tenth
     or	hundredth line end would allow you to seek and read fairly
     efficiently.  If the file is sorted, try the look.pl library (part	of the
     standard perl distribution).

     In	the unique case	of deleting lines at the end of	a file,	you can	use
     tell() and	truncate().  The following code	snippet	deletes	the last line
     of	a file without making a	copy or	reading	the whole file into memory:

	     open (FH, "+< $file");
	     while ( <FH> ) { $addr = tell(FH) unless eof(FH) }
	     truncate(FH, $addr);

     Error checking is left as an exercise for the reader.

     How do I count the	number of lines	in a file?

     One fairly	efficient way is to count newlines in the file.	The following
     program uses a feature of tr///, as documented in the perlop manpage.  If
     your text file doesn't end	with a newline,	then it's not really a proper
     text file,	so this	may report one fewer line than you expect.






									Page 3






PERLFAQ5(1)							   PERLFAQ5(1)



	 $lines	= 0;
	 open(FILE, $filename) or die "Can't open `$filename': $!";
	 while (sysread	FILE, $buffer, 4096) {
	     $lines += ($buffer	=~ tr/\n//);
	 }
	 close FILE;


     How do I make a temporary file name?

     Use the process ID	and/or the current time-value.	If you need to have
     many temporary files in one process, use a	counter:

	 BEGIN {
	     use IO::File;
	     use Fcntl;
	     my	$temp_dir = -d '/tmp' ?	'/tmp' : $ENV{TMP} || $ENV{TEMP};
	     my	$base_name = sprintf("%s/%d-%d-0000", $temp_dir, $$, time());
	     sub temp_file {
		 my $fh	= undef;
		 my $count = 0;
		 until (defined($fh) ||	$count > 100) {
		     $base_name	=~ s/-(\d+)$/"-" . (1 +	$1)/e;
		     $fh = IO::File->new($base_name, O_WRONLY|O_EXCL|O_CREAT, 0644)
		 }
		 if (defined($fh)) {
		     return ($fh, $base_name);
		 } else	{
		     return ();
		 }
	     }
	 }

     Or	you could simply use IO::Handle::new_tmpfile.

     How can I manipulate fixed-record-length files?

     The most efficient	way is using pack() and	unpack().  This	is faster than
     using substr().  Here is a	sample chunk of	code to	break up and put back
     together again some fixed-format input lines, in this case	from the
     output of a normal, Berkeley-style	ps:














									Page 4






PERLFAQ5(1)							   PERLFAQ5(1)



	 # sample input	line:
	 #   15158 p5  T      0:00 perl	/home/tchrist/scripts/now-what
	 $PS_T = 'A6 A4	A7 A5 A*';
	 open(PS, "ps|");
	 $_ = <PS>; print;
	 while (<PS>) {
	     ($pid, $tt, $stat,	$time, $command) = unpack($PS_T, $_);
	     for $var (qw!pid tt stat time command!) {
		 print "$var: <$$var>\n";
	     }
	     print 'line=', pack($PS_T,	$pid, $tt, $stat, $time, $command),
		     "\n";
	 }


     How can I make a filehandle local to a subroutine?	 How do	I pass
     filehandles between subroutines?  How do I	make an	array of filehandles?

     You may have some success with typeglobs, as we always had	to use in days
     of	old:

	 local(*FH);

     But while still supported,	that isn't the best to go about	getting	local
     filehandles.  Typeglobs have their	drawbacks.  You	may well want to use
     the FileHandle module, which creates new filehandles for you (see the
     FileHandle	manpage):

	 use FileHandle;
	 sub findme {
	     my	$fh = FileHandle->new();
	     open($fh, "</etc/hosts") or die "no /etc/hosts: $!";
	     while (<$fh>) {
		 print if /\b127\.(0\.0\.)?1\b/;
	     }
	     # $fh automatically closes/disappears here
	 }

     Internally, Perl believes filehandles to be of class IO::Handle.  You may
     use that module directly if you'd like (see the IO::Handle	manpage), or
     one of its	more specific derived classes.

     Once you have IO::File or FileHandle objects, you can pass	them between
     subroutines or store them in hashes as you	would any other	scalar values:

	 use FileHandle;









									Page 5






PERLFAQ5(1)							   PERLFAQ5(1)



	 # Storing filehandles in a hash and array
	 foreach $filename (@names) {
	     my	$fh = new FileHandle($filename)		     or	die;
	     $file{$filename} =	$fh;
	     push(@files, $fh);
	 }

	 # Using the filehandles in the	array
	 foreach $file (@files)	{
	     print $file "Testing\n";
	 }

	 # You have to do the {	} ugliness when	you're specifying the
	 # filehandle by anything other	than a simple scalar variable.
	 print { $files[2] } "Testing\n";

	 # Passing filehandles to subroutines
	 sub debug {
	     my	$filehandle = shift;
	     printf $filehandle	"DEBUG:	", @_;
	 }

	 debug($fh, "Testing\n");


     How can I set up a	footer format to be used with write()?

     There's no	builtin	way to do this,	but the	perlform manpage has a couple
     of	techniques to make it possible for the intrepid	hacker.

     How can I write() into a string?

     See the perlform manpage for an swrite() function.

     How can I output my numbers with commas added?

     This one will do it for you:

	 sub commify {
	     local $_  = shift;
	     1 while s/^(-?\d+)(\d{3})/$1,$2/;
	     return $_;
	 }

	 $n = 23659019423.2331;
	 print "GOT: ",	commify($n), "\n";

	 GOT: 23,659,019,423.2331

     You can't just:





									Page 6






PERLFAQ5(1)							   PERLFAQ5(1)



	 s/^(-?\d+)(\d{3})/$1,$2/g;

     because you have to put the comma in and then recalculate your position.

     Alternatively, this commifies all numbers in a line regardless of whether
     they have decimal portions, are preceded by + or -, or whatever:

	 # from	Andrew Johnson <ajohnson@gpu.srv.ualberta.ca>
	 sub commify {
	    my $input =	shift;
	     $input = reverse $input;
	     $input =~ s<(\d\d\d)(?=\d)(?!\d*\.)><$1,>g;
	     return reverse $input;
	 }


     How can I translate tildes	(~) in a filename?

     Use the <>	(glob()) operator, documented in the perlfunc manpage.	This
     requires that you have a shell installed that groks tildes, meaning csh
     or	tcsh or	(some versions of) ksh,	and thus may have portability
     problems.	The Glob::KGlob	module (available from CPAN) gives more
     portable glob functionality.

     Within Perl, you may use this directly:

	     $filename =~ s{
	       ^ ~	       # find a	leading	tilde
	       (	       # save this in $1
		   [^/]	       # a non-slash character
			 *     # repeated 0 or more times (0 means me)
	       )
	     }{
	       $1
		   ? (getpwnam($1))[7]
		   : ( $ENV{HOME} || $ENV{LOGDIR} )
	     }ex;


     How come when I open the file read-write it wipes it out?

     Because you're using something like this, which truncates the file	and
     then gives	you read-write access:

	 open(FH, "+> /path/name");  # WRONG

     Whoops.  You should instead use this, which will fail if the file doesn't
     exist.

	 open(FH, "+< /path/name");  # open for	update

     If	this is	an issue, try:



									Page 7






PERLFAQ5(1)							   PERLFAQ5(1)



	 sysopen(FH, "/path/name", O_RDWR|O_CREAT, 0644);

     Error checking is left as an exercise for the reader.

     Why do I sometimes	get an "Argument list too long"	when I use <*>?

     The <> operator performs a	globbing operation (see	above).	 By default
     glob() forks csh(1) to do the actual glob expansion, but csh can't	handle
     more than 127 items and so	gives the error	message	Argument list too
     long.  People who installed tcsh as csh won't have	this problem, but
     their users may be	surprised by it.

     To	get around this, either	do the glob yourself with Dirhandles and
     patterns, or use a	module like Glob::KGlob, one that doesn't use the
     shell to do globbing.

     Is	there a	leak/bug in glob()?

     Due to the	current	implementation on some operating systems, when you use
     the glob()	function or its	angle-bracket alias in a scalar	context, you
     may cause a leak and/or unpredictable behavior.  It's best	therefore to
     use glob()	only in	list context.

     How can I open a file with	a leading ">" or trailing blanks?

     Normally perl ignores trailing blanks in filenames, and interprets
     certain leading characters	(or a trailing "|") to mean something special.
     To	avoid this, you	might want to use a routine like this.	It makes
     incomplete	pathnames into explicit	relative ones, and tacks a trailing
     null byte on the name to make perl	leave it alone:

	 sub safe_filename {
	     local $_  = shift;
	     return m#^/#
		     ? "$_\0"
		     : "./$_\0";
	 }

	 $fn = safe_filename("<<<something really wicked   ");
	 open(FH, "> $fn") or "couldn't	open $fn: $!";

     You could also use	the sysopen() function (see the	sysopen	entry in the
     perlfunc manpage).

     How can I reliably	rename a file?

     Well, usually you just use	Perl's rename()	function.  But that may	not
     work everywhere, in particular, renaming files across file	systems.  If
     your operating system supports a mv(1) program or its moral equivalent,
     this works:





									Page 8






PERLFAQ5(1)							   PERLFAQ5(1)



	 rename($old, $new) or system("mv", $old, $new);

     It	may be more compelling to use the File::Copy module instead.  You just
     copy to the new file to the new name (checking return values), then
     delete the	old one.  This isn't really the	same semantics as a real
     rename(), though, which preserves metainformation like permissions,
     timestamps, inode info, etc.

     How can I lock a file?

     Perl's builtin flock() function (see the perlfunc manpage for details)
     will call flock(2)	if that	exists,	fcntl(2) if it doesn't (on perl
     version 5.004 and later), and lockf(3) if neither of the two previous
     system calls exists.  On some systems, it may even	use a different	form
     of	native locking.	 Here are some gotchas with Perl's flock():

     1	 Produces a fatal error	if none	of the three system calls (or their
	 close equivalent) exists.

     2	 lockf(3) does not provide shared locking, and requires	that the
	 filehandle be open for	writing	(or appending, or read/writing).

     3	 Some versions of flock() can't	lock files over	a network (e.g.	on NFS
	 file systems),	so you'd need to force the use of fcntl(2) when	you
	 build Perl.  See the flock entry of the perlfunc manpage, and the
	 INSTALL file in the source distribution for information on building
	 Perl to do this.

     The CPAN module File::Lock	offers similar functionality and (if you have
     dynamic loading) won't require you	to rebuild perl	if your	flock()	can't
     lock network files.

     What can't	I just open(FH,	">file.lock")?

     A common bit of code NOT TO USE is	this:

	 sleep(3) while	-e "file.lock";	     # PLEASE DO NOT USE
	 open(LCK, "> file.lock");	     # THIS BROKEN CODE

     This is a classic race condition: you take	two steps to do	something
     which must	be done	in one.	 That's	why computer hardware provides an
     atomic test-and-set instruction.	In theory, this	"ought"	to work:

	 sysopen(FH, "file.lock", O_WRONLY|O_EXCL|O_CREAT, 0644)
		     or	die "can't open	 file.lock: $!":

     except that lamentably, file creation (and	deletion) is not atomic	over
     NFS, so this won't	work (at least,	not every time)	over the net.  Various
     schemes involving involving link()	have been suggested, but these tend to
     involve busy-wait,	which is also subdesirable.





									Page 9






PERLFAQ5(1)							   PERLFAQ5(1)



     I still don't get locking.	 I just	want to	increment the number in	the
     file.  How	can I do this?

     Didn't anyone ever	tell you web-page hit counters were useless?

     Anyway, this is what to do:

	 use Fcntl;
	 sysopen(FH, "numfile",	O_RDWR|O_CREAT,	0644) or die "can't open numfile: $!";
	 flock(FH, 2)				      or die "can't flock numfile: $!";
	 $num =	<FH> ||	0;
	 seek(FH, 0, 0)				      or die "can't rewind numfile: $!";
	 truncate(FH, 0)			      or die "can't truncate numfile: $!";
	 (print	FH $num+1, "\n")		      or die "can't write numfile: $!";
	 # DO NOT UNLOCK THIS UNTIL YOU	CLOSE
	 close FH				      or die "can't close numfile: $!";

     Here's a much better web-page hit counter:

	 $hits = int( (time() -	850_000_000) / rand(1_000) );

     If	the count doesn't impress your friends,	then the code might.  :-)

     How do I randomly update a	binary file?

     If	you're just trying to patch a binary, in many cases something as
     simple as this works:

	 perl -i -pe 's{window manager}{window mangler}g' /usr/bin/emacs

     However, if you have fixed	sized records, then you	might do something
     more like this:

	 $RECSIZE = 220; # size	of record, in bytes
	 $recno	  = 37;	 # which record	to update
	 open(FH, "+<somewhere") || die	"can't update somewhere: $!";
	 seek(FH, $recno * $RECSIZE, 0);
	 read(FH, $record, $RECSIZE) ==	$RECSIZE || die	"can't read record $recno: $!";
	 # munge the record
	 seek(FH, $recno * $RECSIZE, 0);
	 print FH $record;
	 close FH;

     Locking and error checking	are left as an exercise	for the	reader.	 Don't
     forget them, or you'll be quite sorry.

     Don't forget to set binmode() under DOS-like platforms when operating on
     files that	have anything other than straight text in them.	 See the docs
     on	open() and on binmode()	for more details.






								       Page 10






PERLFAQ5(1)							   PERLFAQ5(1)



     How do I get a file's timestamp in	perl?

     If	you want to retrieve the time at which the file	was last read,
     written, or had its meta-data (owner, etc)	changed, you use the -M, -A,
     or	-C filetest operations as documented in	the perlfunc manpage.  These
     retrieve the age of the file (measured against the	start-time of your
     program) in days as a floating point number.  To retrieve the "raw" time
     in	seconds	since the epoch, you would call	the stat function, then	use
     localtime(), gmtime(), or POSIX::strftime() to convert this into humanreadable
 form.

     Here's an example:

	 $write_secs = (stat($file))[9];
	 print "file $file updated at ", scalar(localtime($file)), "\n";

     If	you prefer something more legible, use the File::stat module (part of
     the standard distribution in version 5.004	and later):

	 use File::stat;
	 use Time::localtime;
	 $date_string =	ctime(stat($file)->mtime);
	 print "file $file updated at $date_string\n";

     Error checking is left as an exercise for the reader.

     How do I set a file's timestamp in	perl?

     You use the utime() function documented in	the utime entry	in the
     perlfunc manpage.	By way of example, here's a little program that	copies
     the read and write	times from its first argument to all the rest of them.

	 if (@ARGV < 2)	{
	     die "usage: cptimes timestamp_file	other_files ...\n";
	 }
	 $timestamp = shift;
	 ($atime, $mtime) = (stat($timestamp))[8,9];
	 utime $atime, $mtime, @ARGV;

     Error checking is left as an exercise for the reader.

     Note that utime() currently doesn't work correctly	with Win95/NT ports.
     A bug has been reported.  Check it	carefully before using it on those
     platforms.

     How do I print to more than one file at once?

     If	you only have to do this once, you can do this:

	 for $fh (FH1, FH2, FH3) { print $fh "whatever\n" }

     To	connect	up to one filehandle to	several	output filehandles, it's



								       Page 11






PERLFAQ5(1)							   PERLFAQ5(1)



     easiest to	use the	tee(1) program if you have it, and let it take care of
     the multiplexing:

	 open (FH, "| tee file1	file2 file3");

     Otherwise you'll have to write your own multiplexing print	function -- or
     your own tee program -- or	use Tom	Christiansen's,	at
     http://www.perl.com/CPAN/authors/id/TOMC/scripts/tct.gz, which is written
     in	Perl.

     In	theory a IO::Tee class could be	written, but to	date we	haven't	seen
     such.

     How can I read in a file by paragraphs?

     Use the $\	variable (see the perlvar manpage for details).	 You can
     either set	it to "" to eliminate empty paragraphs ("abc\n\n\n\ndef", for
     instance, gets treated as two paragraphs and not three), or "\n\n"	to
     accept empty paragraphs.

     How can I read a single character from a file?  From the keyboard?

     You can use the builtin getc() function for most filehandles, but it
     won't (easily) work on a terminal device.	For STDIN, either use the
     Term::ReadKey module from CPAN, or	use the	sample code in the getc	entry
     in	the perlfunc manpage.

     If	your system supports POSIX, you	can use	the following code, which
     you'll note turns off echo	processing as well.

	 #!/usr/bin/perl -w
	 use strict;
	 $| = 1;
	 for (1..4) {
	     my	$got;
	     print "gimme: ";
	     $got = getone();
	     print "-->	$got\n";
	 }
	 exit;

	 BEGIN {
	     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();




								       Page 12






PERLFAQ5(1)							   PERLFAQ5(1)



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

	     sub cbreak	{
		 $term->setlflag($noecho);
		 $term->setcc(VTIME, 1);
		 $term->setattr($fd_stdin, TCSANOW);
	     }

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

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

	 }

	 END { cooked()	}

     The Term::ReadKey module from CPAN	may be easier to use:

	 use Term::ReadKey;
	 open(TTY, "</dev/tty");
	 print "Gimme a	char: ";
	 ReadMode "raw";
	 $key =	ReadKey	0, *TTY;
	 ReadMode "normal";
	 printf	"\nYou said %s,	char number %03d\n",
	     $key, ord $key;

     For DOS systems, Dan Carson <dbc@tc.fluke.COM> reports the	following:

     To	put the	PC in "raw" mode, use ioctl with some magic numbers gleaned
     from msdos.c (Perl	source file) and Ralf Brown's interrupt	list (comes
     across the	net every so often):

	 $old_ioctl = ioctl(STDIN,0,0);	    # Gets device info
	 $old_ioctl &= 0xff;
	 ioctl(STDIN,1,$old_ioctl | 32);    # Writes it	back, setting bit 5

     Then to read a single character:






								       Page 13






PERLFAQ5(1)							   PERLFAQ5(1)



	 sysread(STDIN,$c,1);		    # Read a single character

     And to put	the PC back to "cooked"	mode:

	 ioctl(STDIN,1,$old_ioctl);	    # Sets it back to cooked mode.

     So	now you	have $c.  If ord($c) ==	0, you have a two byte code, which
     means you hit a special key.  Read	another	byte with sysread(STDIN,$c,1),
     and that value tells you what combination it was according	to this	table:

	 # PC 2-byte keycodes =	^@ + the following:

	 # HEX	   KEYS
	 # ---	   ----
	 # 0F	   SHF TAB
	 # 10-19   ALT QWERTYUIOP
	 # 1E-26   ALT ASDFGHJKL
	 # 2C-32   ALT ZXCVBNM
	 # 3B-44   F1-F10
	 # 47-49   HOME,UP,PgUp
	 # 4B	   LEFT
	 # 4D	   RIGHT
	 # 4F-53   END,DOWN,PgDn,Ins,Del
	 # 54-5D   SHF F1-F10
	 # 5E-67   CTR F1-F10
	 # 68-71   ALT F1-F10
	 # 73-77   CTR LEFT,RIGHT,END,PgDn,HOME
	 # 78-83   ALT 1234567890-=
	 # 84	   CTR PgUp

     This is all trial and error I did a long time ago,	I hope I'm reading the
     file that worked.

     How can I tell if there's a character waiting on a	filehandle?

     You should	check out the Frequently Asked Questions list in comp.unix.*
     for things	like this: the answer is essentially the same.	It's very
     system dependent.	Here's one solution that works on BSD systems:

	 sub key_ready {
	     my($rin, $nfd);
	     vec($rin, fileno(STDIN), 1) = 1;
	     return $nfd = select($rin,undef,undef,0);
	 }

     You should	look into getting the Term::ReadKey extension from CPAN.

     How do I open a file without blocking?

     You need to use the O_NDELAY or O_NONBLOCK	flag from the Fcntl module in
     conjunction with sysopen():




								       Page 14






PERLFAQ5(1)							   PERLFAQ5(1)



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


     How do I create a file only if it doesn't exist?

     You need to use the O_CREAT and O_EXCL flags from the Fcntl module	in
     conjunction with sysopen():

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

     Be	warned that neither creation nor deletion of files is guaranteed to be
     an	atomic operation over NFS.  That is, two processes might both
     successful	create or unlink the same file!

     How do I do a tail	-f in perl?

     First try

	 seek(GWFILE, 0, 1);

     The statement seek(GWFILE,	0, 1) doesn't change the current position, but
     it	does clear the end-of-file condition on	the handle, so that the	next
     <GWFILE> makes Perl try again to read something.

     If	that doesn't work (it relies on	features of your stdio
     implementation), then you need something more like	this:

	     for (;;) {
	       for ($curpos = tell(GWFILE); <GWFILE>; $curpos =	tell(GWFILE)) {
		 # search for some stuff and put it into files
	       }
	       # sleep for a while
	       seek(GWFILE, $curpos, 0);  # seek to where we had been
	     }

     If	this still doesn't work, look into the POSIX module.  POSIX defines
     the clearerr() method, which can remove the end of	file condition on a
     filehandle.  The method: read until end of	file, clearerr(), read some
     more.  Lather, rinse, repeat.

     How do I dup() a filehandle in Perl?

     If	you check the open entry in the	perlfunc manpage, you'll see that
     several of	the ways to call open()	should do the trick.  For example:

	 open(LOG, ">>/tmp/logfile");
	 open(STDERR, ">&LOG");




								       Page 15






PERLFAQ5(1)							   PERLFAQ5(1)



     Or	even with a literal numeric descriptor:

	$fd = $ENV{MHCONTEXTFD};
	open(MHCONTEXT,	"<&=$fd");   # like fdopen(3S)

     Error checking has	been left as an	exercise for the reader.

     How do I close a file descriptor by number?

     This should rarely	be necessary, as the Perl close() function is to be
     used for things that Perl opened itself, even if it was a dup of a
     numeric descriptor, as with MHCONTEXT above.  But if you really have to,
     you may be	able to	do this:

	 require 'sys/syscall.ph';
	 $rc = syscall(&SYS_close, $fd + 0);  #	must force numeric
	 die "can't sysclose $fd: $!" unless $rc == -1;


     Why can't I use "C:\temp\foo" in DOS paths?  What doesn't
     `C:\temp\foo.exe` work?

     Whoops!  You just put a tab and a formfeed	into that filename!  Remember
     that within double	quoted strings ("like\this"), the backslash is an
     escape character.	The full list of these is in the section on Quote and
     Quote-like	Operators in the perlop	manpage.  Unsurprisingly, you don't
     have a file called	"c:(tab)emp(formfeed)oo" or
     "c:(tab)emp(formfeed)oo.exe" on your DOS filesystem.

     Either single-quote your strings, or (preferably) use forward slashes.
     Since all DOS and Windows versions	since something	like MS-DOS 2.0	or so
     have treated / and	\ the same in a	path, you might	as well	use the	one
     that doesn't clash	with Perl -- or	the POSIX shell, ANSI C	and C++, awk,
     Tcl, Java,	or Python, just	to mention a few.

     Why doesn't glob("*.*") get all the files?

     Because even on non-Unix ports, Perl's glob function follows standard
     Unix globbing semantics.  You'll need glob("*") to	get all	(non-hidden)
     files.

     Why does Perl let me delete read-only files?  Why does -i clobber
     protected files?  Isn't this a bug	in Perl?

     This is elaborately and painstakingly described in	the "Far More Than You
     Every Wanted To Know" in http://www.perl.com/CPAN/doc/FMTEYEWTK/file-
     dir-perms .

     The executive summary: learn how your filesystem works.  The permissions
     on	a file say what	can happen to the data in that file.  The permissions
     on	a directory say	what can happen	to the list of files in	that
     directory.	 If you	delete a file, you're removing its name	from the



								       Page 16






PERLFAQ5(1)							   PERLFAQ5(1)



     directory (so the operation depends on the	permissions of the directory,
     not of the	file).	If you try to write to the file, the permissions of
     the file govern whether you're allowed to.

     How do I select a random line from	a file?

     Here's an algorithm from the Camel	Book:

	 srand;
	 rand($.) < 1 && ($line	= $_) while <>;

     This has a	significant advantage in space over reading the	whole file in.

AUTHOR AND COPYRIGHT    [Toc]    [Back]

     Copyright (c) 1997	Tom Christiansen and Nathan Torkington.	 All rights
     reserved.	See the	perlfaq	manpage	for distribution information.







































								       Page 17






PERLFAQ5(1)							   PERLFAQ5(1)


								       PPPPaaaaggggeeee 11118888
[ Back ]
 Similar pages
Name OS Title
perlfaq5 OpenBSD Files and Formats ($Revision: 1.8 $, $Date: 2004/08/09 18:10:15 $)
perlfaq9 IRIX Networking ($Revision: 1.17 $, $Date: 1997/04/24 22:44:29 $)
perlfaq6 IRIX Regexps ($Revision: 1.17 $, $Date: 1997/04/24 22:44:10 $)
perlfaq8 IRIX System Interaction ($Revision: 1.21 $, $Date: 1997/04/24 22:44:19 $)
perlfaq4 IRIX Data Manipulation ($Revision: 1.19 $, $Date: 1997/04/24 22:43:57 $)
perlfaq3 IRIX Programming Tools ($Revision: 1.22 $, $Date: 1997/04/24 22:43:42 $)
perlfaq7 IRIX Perl Language Issues ($Revision: 1.18 $, $Date: 1997/04/24 22:44:14 $)
perlfaq2 IRIX Obtaining and Learning about Perl ($Revision: 1.16 $, $Date: 1997/04/23 18:04:09 $)
perlfaq1 IRIX General Questions About Perl ($Revision: 1.12 $, $Date: 1997/04/24 22:43:34 $)
perlfaq IRIX frequently asked questions about Perl ($Date: 1997/04/24 22:46:06 $)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service