Integrate perlio:

[  7711]
Minor tweaks:
consistent way of getting 'rb', 'wb' etc. for binary opens
move *perlio::layers to *open::layers
a #define to show layers available
DOSISH popen/PerlIO had export/import sense inverted.

p4raw-link: @7711 on //depot/perlio: a1d180c4a5147aa338f86b44d91b356bec0875ac

p4raw-id: //depot/perl@7713

diff --git a/perlapi.c b/perlapi.c
index d71ac49..a9dd2f0 100644 (file)
--- a/perlapi.c
+++ b/perlapi.c
@@ -2237,21 +2237,21 @@ Perl_init_i18nl14n(pTHXo_ int printwarn)
 
 #undef  Perl_new_collate
 void
-Perl_new_collate(pTHXo_ const char* newcoll)
+Perl_new_collate(pTHXo_ char* newcoll)
 {
     ((CPerlObj*)pPerl)->Perl_new_collate(newcoll);
 }
 
 #undef  Perl_new_ctype
 void
-Perl_new_ctype(pTHXo_ const char* newctype)
+Perl_new_ctype(pTHXo_ char* newctype)
 {
     ((CPerlObj*)pPerl)->Perl_new_ctype(newctype);
 }
 
 #undef  Perl_new_numeric
 void
-Perl_new_numeric(pTHXo_ const char* newcoll)
+Perl_new_numeric(pTHXo_ char* newcoll)
 {
     ((CPerlObj*)pPerl)->Perl_new_numeric(newcoll);
 }

diff --git a/t/lib/tie-refhash.t b/t/lib/tie-refhash.t
index a82c19c..d80b2e1 100644 (file)
--- a/t/lib/tie-refhash.t
+++ b/t/lib/tie-refhash.t
@@ -1,19 +1,19 @@
 #!/usr/bin/perl -w
-#
+# 
 # Basic test suite for Tie::RefHash and Tie::RefHash::Nestable.
-#
+# 
 # The testing is in two parts: first, run lots of tests on both a tied
 # hash and an ordinary un-tied hash, and check they give the same
 # answer.  Then there are tests for those cases where the tied hashes
 # should behave differently to normal hashes, that is, when using
 # references as keys.
-#
+# 
 
 BEGIN {
     chdir 't' if -d 't';
-    @INC = '.';
+    @INC = '.'; 
     push @INC, '../lib';
-}
+}    
 
 use strict;
 use Tie::RefHash;
@@ -28,7 +28,7 @@ my $ref = []; my $ref1 = [];
 # on a tied hash and on a normal hash, and checking that the results
 # are the same.  This does of course assume that Perl hashes are not
 # buggy :-)
-#
+# 
 my @tests = standard_hash_tests();
 
 my @ordinary_results = runtests(\@tests, undef);
@@ -40,13 +40,13 @@ foreach my $class ('Tie::RefHash', 'Tie::RefHash::Nestable') {
     foreach my $i (0 .. $#ordinary_results) {
         my ($or, $ow, $oe) = @{$ordinary_results[$i]};
         my ($tr, $tw, $te) = @{$tied_results[$i]};
-
+        
         my $ok = 1;
         local $^W = 0;
         $ok = 0 if (defined($or) != defined($tr)) or ($or ne $tr);
         $ok = 0 if (defined($ow) != defined($tw)) or ($ow ne $tw);
         $ok = 0 if (defined($oe) != defined($te)) or ($oe ne $te);
-
+        
         if (not $ok) {
             print STDERR
               "failed for $class: $tests[$i]\n",
@@ -127,7 +127,7 @@ exit();
 
 # Print 'ok X' if true, 'not ok X' if false
 # Uses global $currtest.
-#
+# 
 sub test {
     my $t = shift;
     print 'not ' if not $t;
@@ -135,7 +135,7 @@ sub test {
 }
 
 
-# Wrapper for Data::Dumper to 'dump' a scalar as an EXPR string.
+# Wrapper for Data::Dumper to 'dump' a scalar as an EXPR string. 
 sub dumped {
     my $s = shift;
     my $d = Dumper($s);
@@ -148,7 +148,7 @@ sub dumped {
 # Crudely dump a hash into a canonical string representation (because
 # hash keys can appear in any order, Data::Dumper may give different
 # strings for the same hash).
-#
+# 
 sub dumph {
     my $h = shift;
     my $r = '';
@@ -159,17 +159,17 @@ sub dumph {
 }
 
 # Run the tests and give results.
-#
+# 
 # Parameters: reference to list of tests to run
 #             name of class to use for tied hash, or undef if not tied
-#
+# 
 # Returns: list of [R, W, E] tuples, one for each test.
 # R is the return value from running the test, W any warnings it gave,
 # and E any exception raised with 'die'.  E and W will be tidied up a
 # little to remove irrelevant details like line numbers :-)
-#
+# 
 # Will also run a few of its own 'ok N' tests.
-#
+# 
 sub runtests {
     my ($tests, $class) = @_;
     my @r;
@@ -215,14 +215,14 @@ sub runtests {
 
 # Things that should work just the same for an ordinary hash and a
 # Tie::RefHash.
-#
+# 
 # Each test is a code string to be eval'd, it should do something with
 # %h and give a scalar return value.  The global $ref and $ref1 may
 # also be used.
-#
+# 
 # One thing we don't test is that the ordering from 'keys', 'values'
 # and 'each' is the same.  You can't reasonably expect that.
-#
+# 
 sub standard_hash_tests {
     my @r;
 
@@ -234,12 +234,12 @@ sub standard_hash_tests {
     { my ($k, $v, %tmp); $tmp{"$k$;$v"}++ while (($k, $v) = each %h); dumph(\%tmp) }
 END
   ;
-
+    
     # Tests on the existence of the element 'foo'
     my $FOO_TESTS = <<'END'
     defined $h{foo};
     exists $h{foo};
-    $h{foo};
+    $h{foo};    
 END
   ;
 
@@ -278,7 +278,7 @@ END
   ;
         }
     }
-
+    
     # Test hash slices
     my @slicetests;
     @slicetests = split /\n/, <<'END'