<h2>Editing File: /usr/share/perl5/open.pm</h2><form method='post'><textarea name='content' class='file-edit'>package open;
use warnings;

our $VERSION = '1.11';

require 5.008001; # for PerlIO::get_layers()

my $locale_encoding;

sub _get_encname {
    return ($1, Encode::resolve_alias($1)) if $_[0] =~ /^:?encoding\((.+)\)$/;
    return;
}

sub croak {
    require Carp; goto &amp;Carp::croak;
}

sub _drop_oldenc {
    # If by the time we arrive here there already is at the top of the
    # perlio layer stack an encoding identical to what we would like
    # to push via this open pragma, we will pop away the old encoding
    # (+utf8) so that we can push ourselves in place (this is easier
    # than ignoring pushing ourselves because of the way how ${^OPEN}
    # works).  So we are looking for something like
    #
    #   stdio encoding(xxx) utf8
    #
    # in the existing layer stack, and in the new stack chunk for
    #
    #   :encoding(xxx)
    #
    # If we find a match, we pop the old stack (once, since
    # the utf8 is just a flag on the encoding layer)
    my ($h, @new) = @_;
    return unless @new &gt;= 1 &amp;&amp; $new[-1] =~ /^:encoding\(.+\)$/;
    my @old = PerlIO::get_layers($h);
    return unless @old &gt;= 3 &amp;&amp;
	          $old[-1] eq 'utf8' &amp;&amp;
                  $old[-2] =~ /^encoding\(.+\)$/;
    require Encode;
    my ($loname, $lcname) = _get_encname($old[-2]);
    unless (defined $lcname) { # Should we trust get_layers()?
	croak(&quot;open: Unknown encoding '$loname'&quot;);
    }
    my ($voname, $vcname) = _get_encname($new[-1]);
    unless (defined $vcname) {
	croak(&quot;open: Unknown encoding '$voname'&quot;);
    }
    if ($lcname eq $vcname) {
	binmode($h, &quot;:pop&quot;); # utf8 is part of the encoding layer
    }
}

sub import {
    my ($class,@args) = @_;
    croak(&quot;open: needs explicit list of PerlIO layers&quot;) unless @args;
    my $std;
    my ($in,$out) = split(/\0/,(${^OPEN} || &quot;\0&quot;), -1);
    while (@args) {
	my $type = shift(@args);
	my $dscp;
	if ($type =~ /^:?(utf8|locale|encoding\(.+\))$/) {
	    $type = 'IO';
	    $dscp = &quot;:$1&quot;;
	} elsif ($type eq ':std') {
	    $std = 1;
	    next;
	} else {
	    $dscp = shift(@args) || '';
	}
	my @val;
	foreach my $layer (split(/\s+/,$dscp)) {
            $layer =~ s/^://;
	    if ($layer eq 'locale') {
		require Encode;
		require encoding;
		$locale_encoding = encoding::_get_locale_encoding()
		    unless defined $locale_encoding;
		(warnings::warnif(&quot;layer&quot;, &quot;Cannot figure out an encoding to use&quot;), last)
		    unless defined $locale_encoding;
                $layer = &quot;encoding($locale_encoding)&quot;;
		$std = 1;
	    } else {
		my $target = $layer;		# the layer name itself
		$target =~ s/^(\w+)\(.+\)$/$1/;	# strip parameters

		unless(PerlIO::Layer::-&gt;find($target,1)) {
		    warnings::warnif(&quot;layer&quot;, &quot;Unknown PerlIO layer '$target'&quot;);
		}
	    }
	    push(@val,&quot;:$layer&quot;);
	    if ($layer =~ /^(crlf|raw)$/) {
		$^H{&quot;open_$type&quot;} = $layer;
	    }
	}
	if ($type eq 'IN') {
	    _drop_oldenc(*STDIN, @val) if $std;
	    $in  = join(' ', @val);
	}
	elsif ($type eq 'OUT') {
	    if ($std) {
		_drop_oldenc(*STDOUT, @val);
		_drop_oldenc(*STDERR, @val);
	    }
	    $out = join(' ', @val);
	}
	elsif ($type eq 'IO') {
	    if ($std) {
		_drop_oldenc(*STDIN, @val);
		_drop_oldenc(*STDOUT, @val);
		_drop_oldenc(*STDERR, @val);
	    }
	    $in = $out = join(' ', @val);
	}
	else {
	    croak &quot;Unknown PerlIO layer class '$type' (need IN, OUT or IO)&quot;;
	}
    }
    ${^OPEN} = join(&quot;\0&quot;, $in, $out);
    if ($std) {
	if ($in) {
	    if ($in =~ /:utf8\b/) {
		    binmode(STDIN,  &quot;:utf8&quot;);
		} elsif ($in =~ /(\w+\(.+\))/) {
		    binmode(STDIN,  &quot;:$1&quot;);
		}
	}
	if ($out) {
	    if ($out =~ /:utf8\b/) {
		binmode(STDOUT,  &quot;:utf8&quot;);
		binmode(STDERR,  &quot;:utf8&quot;);
	    } elsif ($out =~ /(\w+\(.+\))/) {
		binmode(STDOUT,  &quot;:$1&quot;);
		binmode(STDERR,  &quot;:$1&quot;);
	    }
	}
    }
}

1;
__END__

=head1 NAME

open - perl pragma to set default PerlIO layers for input and output

=head1 SYNOPSIS

    use open IN  =&gt; &quot;:crlf&quot;, OUT =&gt; &quot;:bytes&quot;;
    use open OUT =&gt; ':utf8';
    use open IO  =&gt; &quot;:encoding(iso-8859-7)&quot;;

    use open IO  =&gt; ':locale';

    use open ':encoding(UTF-8)';
    use open ':locale';
    use open ':encoding(iso-8859-7)';

    use open ':std';

=head1 DESCRIPTION

Full-fledged support for I/O layers is now implemented provided
Perl is configured to use PerlIO as its IO system (which is now the
default).

The C&lt;open&gt; pragma serves as one of the interfaces to declare default
&quot;layers&quot; (also known as &quot;disciplines&quot;) for all I/O. Any two-argument
open(), readpipe() (aka qx//) and similar operators found within the
lexical scope of this pragma will use the declared defaults.
Even three-argument opens may be affected by this pragma
when they don't specify IO layers in MODE.

With the C&lt;IN&gt; subpragma you can declare the default layers
of input streams, and with the C&lt;OUT&gt; subpragma you can declare
the default layers of output streams.  With the C&lt;IO&gt;  subpragma
you can control both input and output streams simultaneously.

If you have a legacy encoding, you can use the C&lt;:encoding(...)&gt; tag.

If you want to set your encoding layers based on your
locale environment variables, you can use the C&lt;:locale&gt; tag.
For example:

    $ENV{LANG} = 'ru_RU.KOI8-R';
    # the :locale will probe the locale environment variables like LANG
    use open OUT =&gt; ':locale';
    open(O, &quot;&gt;koi8&quot;);
    print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
    close O;
    open(I, &quot;&lt;koi8&quot;);
    printf &quot;%#x\n&quot;, ord(&lt;I&gt;), &quot;\n&quot;; # this should print 0xc1
    close I;

These are equivalent

    use open ':encoding(UTF-8)';
    use open IO =&gt; ':encoding(UTF-8)';

as are these

    use open ':locale';
    use open IO =&gt; ':locale';

and these

    use open ':encoding(iso-8859-7)';
    use open IO =&gt; ':encoding(iso-8859-7)';

The matching of encoding names is loose: case does not matter, and
many encodings have several aliases.  See L&lt;Encode::Supported&gt; for
details and the list of supported locales.

When open() is given an explicit list of layers (with the three-arg
syntax), they override the list declared using this pragma.  open() can
also be given a single colon (:) for a layer name, to override this pragma
and use the default (C&lt;:raw&gt; on Unix, C&lt;:crlf&gt; on Windows).

The C&lt;:std&gt; subpragma on its own has no effect, but if combined with
the C&lt;:utf8&gt; or C&lt;:encoding&gt; subpragmas, it converts the standard
filehandles (STDIN, STDOUT, STDERR) to comply with encoding selected
for input/output handles.  For example, if both input and out are
chosen to be C&lt;:encoding(UTF-8)&gt;, a C&lt;:std&gt; will mean that STDIN, STDOUT,
and STDERR are also in C&lt;:encoding(UTF-8)&gt;.  On the other hand, if only
output is chosen to be in C&lt;&lt; :encoding(koi8r) &gt;&gt;, a C&lt;:std&gt; will cause
only the STDOUT and STDERR to be in C&lt;koi8r&gt;.  The C&lt;:locale&gt; subpragma
implicitly turns on C&lt;:std&gt;.

The logic of C&lt;:locale&gt; is described in full in L&lt;encoding&gt;,
but in short it is first trying nl_langinfo(CODESET) and then
guessing from the LC_ALL and LANG locale environment variables.

Directory handles may also support PerlIO layers in the future.

=head1 NONPERLIO FUNCTIONALITY

If Perl is not built to use PerlIO as its IO system then only the two
pseudo-layers C&lt;:bytes&gt; and C&lt;:crlf&gt; are available.

The C&lt;:bytes&gt; layer corresponds to &quot;binary mode&quot; and the C&lt;:crlf&gt;
layer corresponds to &quot;text mode&quot; on platforms that distinguish
between the two modes when opening files (which is many DOS-like
platforms, including Windows).  These two layers are no-ops on
platforms where binmode() is a no-op, but perform their functions
everywhere if PerlIO is enabled.

=head1 IMPLEMENTATION DETAILS

There is a class method in C&lt;PerlIO::Layer&gt; C&lt;find&gt; which is
implemented as XS code.  It is called by C&lt;import&gt; to validate the
layers:

   PerlIO::Layer::-&gt;find(&quot;perlio&quot;)

The return value (if defined) is a Perl object, of class
C&lt;PerlIO::Layer&gt; which is created by the C code in F&lt;perlio.c&gt;.  As
yet there is nothing useful you can do with the object at the perl
level.

=head1 SEE ALSO

L&lt;perlfunc/&quot;binmode&quot;&gt;, L&lt;perlfunc/&quot;open&quot;&gt;, L&lt;perlunicode&gt;, L&lt;PerlIO&gt;,
L&lt;encoding&gt;

=cut
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fperl5'>Back to Directory</a>