----------------------------------------------------------------------------
[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread
Index][Top&Search][Original]
----------------------------------------------------------------------------

Re: your mail

----------------------------------------------------------------------------

   * From: Tom Christiansen <tchrist@jhereg.perl.com>
   * To: Chip Salzenberg <chip@perl.org>
   * Cc: Byron Brummer <byron@thrush.omix.com>, 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 `<FH>' 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 <FH>;
                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 <chip@perl.org>
     Steffen Beyer <sb@sdm.de>sb@engelschall.com (Steffen Beyer)

References to:
     Chip Salzenberg <chip@perl.org>

----------------------------------------------------------------------------
[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread
Index][Top&Search][Original]
----------------------------------------------------------------------------