---------------------------------------------------------------------------- [Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original] ---------------------------------------------------------------------------- Re: your mail ---------------------------------------------------------------------------- * From: Tom Christiansen * To: Chip Salzenberg * Cc: Byron Brummer , perlbug@perl.com, tchrist@jhereg.perl.com * Date: Tue, 19 May 1998 10:50:27 -0600 * Message-Id: <199805191650.KAA09658@jhereg.perl.com> ---------------------------------------------------------------------------- >You can call the readline() or glob() operators directly, if you like, >or else assign your handle to a scalar and say <$scalar>. Um, not quite. Here's a FMTEYEWTK on Indirect FileHandles that didn't make the cut on the Perl Cookbook. Check out talk about readln, er, readline. --tom You want to use a filehandle like a normal variable so you can pass it to or return it from a function, store it in a data structure, and so on. The solution is to use indirect filehandles by storing strings, typeglobs, typeglob references, or IO objects into scalar variables: $fh = SOME_FH; # bareword is strict-subs hostile $fh = "SOME_FH"; # strict-refs hostile; same package only $fh = *SOME_FH; # typeglob $fh = \*SOME_FH; # ref to typeglob (bless-able) $fh = *SOME_FH{IO}; # blessed IO::Handle from *SOME_FH typeglob Or to use the `new' method from the FileHandle or IO modules to create an anonymous filehandle, store that in a scalar variable, and use it as though it were a normal filehandle. use FileHandle; $fh = FileHandle->new(); use IO::Handle; # 5.004 or higher $fh = IO::Handle->new(); Then use any of these as you would a normal filehandle. Here's how this works: Anywhere that Perl is expecting a filehandle, an indirect filehandle may be used instead. An indirect filehandle is just a scalar variable that contains a filehandle. Functions like `print', `open', `seek', or the functions or the `' diamond operator will accept either a read filehandle or a scalar variable containing one: ($ifh, $ofh, $efh) = (*STDIN, *STDOUT, *STDERR); print $ofh "Type it: "; $got = <$ifh> print $efh "What was that: $got"; In the spirit of there being more than one way to do it, here are seven ways to produce an indirect filehandle. Don't be intimidated: numbers 3, 6 and 7 are the most common (and 6 and 7 are really the same thing): 1. Barewords The first, SOME_FH is rather dubious, because it's not merely a string, but a bareword string. It won't be allowed if `use strict 'subs'' is in effect. Other than that, everything in the next entry also applies. 2. Strings `"SOME_FH"' is still a string, but at least it's quoted. The big problem with this is that it doesn't have package information, so if you used it to call a function compiled in a different package, that function could get confused unless it were one of the ubiquitous handles, like ARGV, STDIN, STDOUT, and STDERR. You could add the package manually, saying perhaps `"main::SOME_FH"'. It won't be allowed if `use strict 'refs'' is in effect. The function in question can fix it up using the `Symbol::qualify' function, which adds in the package. Its cousin, `Symbol::qualify_to_ref', does this and produces a reference, silencing the complaints from `strict refs'. use Symbol; sub function_taking_filehandle_argument { my $fh = shift; # produce typeglob $fh = qualify($fh, scalar caller); # or else this one: # produce typeglob ref $fh = qualify_to_ref($fh, scalar caller); ... } The `Symbol::qualify' function produces something useful for passing to the `readline' function as described below. 3. Typeglobs The `*SOME_FH' notation is a typeglob, an entry in a package symbol table. Typeglobs are often nominated as Perl's deepest and blackest magic. If you see a star in front of an identifier, there are typeglobs involved, and you know you have entered a wizardly realm where even gurus fear to tread. Unlike the string versions of filehandles shown previously, you can do nearly anything with a typeglob you'd like--if not a good bit more. They're extremely convenient and useful, once you get the hang of them. You don't have to fight with packages or any stricture. And although it's not `bless'able because it's not a reference, it can be effectively returned from functions. A reference to a typeglob can't. Here's how typeglobs are typically used for I/O: #!/usr/bin/perl # demoglob - show how to return local filehandles sub ropen { my $path = shift; local *FH; open(FH, $path) || die $!; return *FH; } $f = ropen("/etc/motd"); $g = ropen("/etc/termcap"); print scalar(<$f>), scalar(<$g>); >>> Welcome to www.perl.com, the Perl Homepage >>> ######## TERMINAL TYPE DESCRIPTIONS SOURCE FILE If a typeglob is passed in, it can be assigned to a local filehandle using a typeglob. After that, normal operations like `<>' or any I/O function can be applied to it. sub read_N_lines using local *FH = shift; my $count = shift; my @lines = (); while (--$count > 0) { push @lines, scalar ; last if eof(FH); } return @lines; } open(TCAP, "/etc/termcap") || die $!; @some = read_N_lines(*TCAP, 3); print @some; >>> ######## TERMINAL TYPE DESCRIPTIONS SOURCE FILE >>> # >>> # Version 9.12.0 It turns out that it also works if the caller forgets to star the filehandle or passes it as a string, effectively using techniques 1 and 2 from this list. It works only so long as they're in the same package as the function in question and `strict refs' isn't enabled, though. @some = read_N_lines('TCAP', 5); That's because assigning a string to a typeglob promotes the string to a typeglob of that name, like this: *newname = *oldname; *newname = 'oldname'; # magically same; promote string to typeglob! A careful function would have done either this to qualify its filehandle argument: use Symbol; local *FH = qualify(shift, caller); Or prototyped the function to take a typeglob, which implicitly does the same thing: sub read_N_lines(*$) { # same definition } Once such a prototype is visible, a call like this: @some = read_N_lines(TCAP, 5); is really treated as though it were @some = &read_N_lines(*TCAP, 5); 4. Typeglob references The ` \*SOME_FH' notation produces a reference to a typeglob. It can be used to create an object by blessing the reference; this is what the FileHandle and IO modules use. Don't try passing one of these back from a function, though, because it doesn't work. Instead, if you would like an anonymous one of these, use the Symbol module. use Symbol; sub ropen { my $path = shift; my $fh = gensym(); open($fh, $path) || die $!; return $fh; } 5. IO handles The curious `*SOME_FH{IO}' construct is explained in greater detail in perlref(1). It accesses the internal IO object associated with the handle called SOME_FH. This is a real object; it's already blessed even though it's built-in to Perl. printf "I have %s\n", *STDIN{IO}; >>> I have IO::Handle=IO(0x80784b8) The only issue here is that it can't be used to generate a new filehandle the way `Symbol::gensym' can. But if you've already accessed the symbol as a filehandle, that's ok. This works fine: sub ropen { my $path = shift; local *FH; open(FH, $path) || die $!; return *FH{IO}; } 6. FileHandle The standard FileHandle module can be used to create a new filehandle to use indirectly. It's just a bit expensive to load; as of the 5.004 release, merely saying `use FileHandle' loads fifteen text files plus several shared libraries, plodding through nearly four thousand lines of source code. use FileHandle; sub ropen { my $path = shift; my $fh = FileHandle->new(); open($fh, $path) || die $!; return $fh; } 7. IO::Handle This is works the same as the FileHandle module, except that its name is different. The FileHandle module is really just a front-end to this one. It's still just as crazily expensive. There's a catch with these indirect filehandles. Only a simple scalar variable, not part of an array or hash or larger expression, can be used for things like `print', `printf', or the diamond operator. This is illegal and won't even compile: @fd = (*STDIN, *STDOUT, *STDERR); print $fd[1] "Type it: "; # WRONG $got = <$fd[0]> # WRONG print $fd[2] "What was that: $got"; # WRONG With `print', you can get around this problem by using a block and an expression: print { $fd[1] } "funny stuff\n"; printf { $fd[1] } "Pity the poor %x.\n", 3_735_928_559; >>> Pity the poor deadbeef. or even this, which sends the message out to one of two places: $ok = -x "/bin/cat"; print { $ok ? $fd[1] : $fd[2] } "cat stat $ok\n"; print { $fd[ 1+ ($ok || 0) ] } "cat stat $ok\n"; This kind of thing doesn't work for the diamond operator. In some cases, though, you may be in luck. The angle bracket notation is mostly just an interface to the built-in function named `readline'. You may call it directly--providing that you pass it a typeglob. Not a string. Not a reference to a typeglob. Just a typeglob. Given the initialization of @fd above, this would work: $got = readline($fd[0]); But if those had been typeglob references or strings instead of globs, `readline' wouldn't have worked. All this monkeying around will probably get to you eventually. If so, it may well be time to load the FileHandle module (or its newer alias, IO::Handle), which simplifies much of this. It has a `new' method to provide an anonymous filehandle, as we saw above. And it has `print' and `getline' methods (Yes, that's `getline' as a method, but `readline' when a function. I don't know what I was thinking when I wrote it.): use FileHandle; @fd = ( *STDIN{IO}, *STDOUT{IO}, *STDERR{IO} ); $fd[1]->print("Type it: "); print { $fd[1] } ("Type it: "); # same, but *much* faster $got = $fd[0]->getline(); $fd[2]->print("What was that: $got"); See also the `open' entry in perlfunc(1) (or Camel:3), FileHandle(3) (or Camel:7), the perlref(1) manpage's treatment of the so-called `*foo{THING}' syntax, and the IO modules. ---------------------------------------------------------------------------- Follow-Ups from: Chip Salzenberg Steffen Beyer sb@engelschall.com (Steffen Beyer) References to: Chip Salzenberg ---------------------------------------------------------------------------- [Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original] ----------------------------------------------------------------------------