use Carp;
$open::hint_bits = 0x20000;
-# layers array and hash mainly manipulated by C code in perlio.c
-use vars qw(%layers @layers);
+our $VERSION = '1.01';
-# Populate hash in non-PerlIO case
-%layers = (crlf => 1, raw => 0) unless (@layers);
+my $locale_encoding;
-# warn join(',',keys %layers);
+sub in_locale { $^H & $locale::hint_bits }
-our $VERSION = '1.00';
+sub _get_locale_encoding {
+ unless (defined $locale_encoding) {
+ eval { use I18N::Langinfo qw(langinfo CODESET) };
+ unless ($@) {
+ $locale_encoding = langinfo(CODESET);
+ }
+ my $country_language;
+ if (not $locale_encoding && in_locale()) {
+ if ($ENV{LC_ALL} =~ /^([^.]+)\.([^.]+)$/) {
+ ($country_language, $locale_encoding) = ($1, $2);
+ } elsif ($ENV{LANG} =~ /^([^.]+)\.([^.]+)$/) {
+ ($country_language, $locale_encoding) = ($1, $2);
+ }
+ } else {
+ # Could do heuristics based on the country and language
+ # parts of LC_ALL and LANG (the parts before the dot (if any)),
+ # since we have Locale::Country and Locale::Language available.
+ # TODO: get a database of Language -> Encoding mappings
+ # (the Estonian database would be excellent!)
+ # --jhi
+ }
+ if (defined $locale_encoding &&
+ $locale_encoding eq 'euc' &&
+ defined $country_language) {
+ if ($country_language =~ /^ja_JP|japan(?:ese)$/i) {
+ $locale_encoding = 'eucjp';
+ } elsif ($country_language =~ /^ko_KR|korea(?:n)$/i) {
+ $locale_encoding = 'euckr';
+ } elsif ($country_language =~ /^zh_TW|taiwan(?:ese)$/i) {
+ $locale_encoding = 'euctw';
+ }
+ croak "Locale encoding 'euc' too ambiguous"
+ if $locale_encoding eq 'euc';
+ }
+ }
+}
sub import {
my ($class,@args) = @_;
my @val;
foreach my $layer (split(/\s+/,$discp)) {
$layer =~ s/^://;
- unless(exists $layers{$layer}) {
+ if ($layer eq 'locale') {
+ use Encode;
+ _get_locale_encoding()
+ unless defined $locale_encoding;
+ croak "Cannot figure out an encoding to use"
+ unless defined $locale_encoding;
+ if ($locale_encoding =~ /^utf-?8$/i) {
+ $layer = "utf8";
+ } else {
+ $layer = "encoding($locale_encoding)";
+ }
+ }
+ unless(PerlIO::Layer::->find($layer)) {
carp("Unknown discipline layer '$layer'");
}
push(@val,":$layer");
=head1 IMPLEMENTATION DETAILS
-There are two package variables C<%layers> and C<@layers> which are
-mainly manipulated by C code in F<perlio.c>, but are visible to the
-nosy:
-
- print "Have ",join(',',keys %open::layers),"\n";
- print "Using ",join(',',@open::layers),"\n";
-
-The C<%open::layers> hash is a record of the available "layers" that
-may be pushed onto a C<PerlIO> stream. The values of the hash are Perl
-objects, of class C<PerlIO::Layer> which are created by the C code in
-F<perlio.c>. As yet there is nothing useful you can do with the
-objects at the perl level.
-
-The C<@open::layers> array is the current set of layers and their
-arguments. The array consists of layer => argument pairs and I<must>
-always have even number of entries and the even entries I<must> be
-C<PerlIO::Layer> objects or Perl will "die" when it attempts to open a
-filehandle. In most cases the odd entry will be C<undef>, but in the
-case of (say) ":encoding(iso-8859-1)" it will be 'iso-8859-1'. These
-argument entries are currently restricted to being strings.
-
-When a new C<PerlIO> stream is opened, the C code looks at the array
-to determine the default layers to be pushed. So with care it is
-possible to manipulate the default layer "stack":
-
- splice(@PerlIO::layers,-2,2);
- push(@PerlIO::layers,$PerlIO::layers{'stdio'} => undef);
+There is a class method in C<PerlIO::Layer> C<find> which is implemented as XS code.
+It is called by C<import> to validate the layers:
+
+ PerlIO::Layer::->find("perlio")
+
+The return value (if defined) is a Perl object, of class C<PerlIO::Layer> which is
+created by the C code in F<perlio.c>. As yet there is nothing useful you can do with the
+object at the perl level.
=head1 SEE ALSO