Integrate perlio:

[ 10616]
pTHX_ / aTHX_ for ExtUtils/Constant.pm

p4raw-link: @10616 on //depot/perlio: a2c454fab251f31050e7634776a305ebcdba5ec4

p4raw-id: //depot/perl@10617

diff --git a/pod/perlapi.pod b/pod/perlapi.pod
index 5128dc3..f950bd0 100644 (file)
--- a/pod/perlapi.pod
+++ b/pod/perlapi.pod
@@ -329,7 +329,7 @@ L<perlsub/"Constant Functions">.
        SV*     cv_const_sv(CV* cv)
 
 =for hackers
-Found in file opmini.c
+Found in file op.c
 
 =item dAX
 
@@ -1153,7 +1153,7 @@ method, similar to C<use Foo::Bar VERSION LIST>.
        void    load_module(U32 flags, SV* name, SV* ver, ...)
 
 =for hackers
-Found in file opmini.c
+Found in file op.c
 
 =item looks_like_number
 
@@ -1292,7 +1292,7 @@ eligible for inlining at compile-time.
        CV*     newCONSTSUB(HV* stash, char* name, SV* sv)
 
 =for hackers
-Found in file opmini.c
+Found in file op.c
 
 =item newHV
 
@@ -1438,7 +1438,7 @@ Found in file sv.c
 Used by C<xsubpp> to hook up XSUBs as Perl subs.
 
 =for hackers
-Found in file opmini.c
+Found in file op.c
 
 =item newXSproto
 

diff --git a/t/lib/mimeqp.t b/t/lib/mimeqp.t
old mode 100644 (file)
new mode 100755 (executable)

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'

diff --git a/t/op/utf8decode.t b/t/op/utf8decode.t
old mode 100755 (executable)
new mode 100644 (file)