Fix typos (spelling errors) in dist/*

# New Ticket Created by  (Peter J. Acklam)
# Please include the string:  [perl #81888]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt3/Ticket/Display.html?id=81888 >

Signed-off-by: Abigail <abigail@abigail.be>

13 files changed, 43 insertions, 43 deletions

diff --git a/dist/Storable/ChangeLog b/dist/Storable/ChangeLog
index faff5660fc..51642d2ec3 100644
--- a/dist/Storable/ChangeLog
+++ b/dist/Storable/ChangeLog
@@ -177,7 +177,7 @@ Fri Jun  7 23:55:41 BST 2002   Nicholas Clark
 	The bug was introduced as development perl change 16442 (on
 	2002/05/07), so has been present since 2.00.
 	Patches to introduce more regression tests to reduce the chance of
-	a reoccurance of this sort of goof are always welcome.
+	a reoccurence of this sort of goof are always welcome.
 	
 Thu May 30 20:31:08 BST 2002   Nicholas Clark <nick@ccl4.org>
 
@@ -186,7 +186,7 @@ Thu May 30 20:31:08 BST 2002   Nicholas Clark <nick@ccl4.org>
         5.6.x introduced the ability to have IVs as long long.  However,
         Configure still defined BYTEORDER based on the size of a long.
         Storable uses the BYTEORDER value as part of the header, but
-        doesn't explicity store sizeof(IV) anywhere in the header.
+        doesn't explicitly store sizeof(IV) anywhere in the header.
         Hence on 5.6.x built with IV as long long on a platform that
         uses Configure (ie most things except VMS and Windows) headers
         are identical for the different IV sizes, despite the files
@@ -580,7 +580,7 @@ Mon Jul 12 14:37:19 METDST 1999   Raphael Manfredi <Raphael_Manfredi@pobox.com>
 
         changed my e-mail to pobox.
 
-        mentionned it is not thread-safe.
+        mentioned it is not thread-safe.
 
         updated version number.
 
@@ -610,8 +610,8 @@ Fri Jun 12 11:50:04 METDST 1998   Raphael Manfredi <Raphael_Manfredi@grenoble.hp
         scalars tagged as being an lvalue are handled as if they were
         not an lvalue at all.  Added test for that LVALUE bug workaround.
 
-        Now handles Perl immortal scalars explicitely, by storing &sv_yes
-        as such, explicitely.
+        Now handles Perl immortal scalars explicitly, by storing &sv_yes
+        as such, explicitly.
 
         Retrieval of non-immortal undef cannot be shared. Previous
         version was over-optimizing by not creating a separate SV for
@@ -673,7 +673,7 @@ Wed Apr  8 13:14:29 METDST 1998   Raphael Manfredi <Raphael_Manfredi@grenoble.hp
 
         Wrote sizeof(SV *) instead of sizeof(I32) when portable, which
         in effect mangled the object tags and prevented portability
-        accross 32/64 bit architectures!
+        across 32/64 bit architectures!
 
 Wed Mar 25 14:57:02 MET 1998   Raphael Manfredi <Raphael_Manfredi@grenoble.hp.com>
 
@@ -687,7 +687,7 @@ Wed Mar 25 14:57:02 MET 1998   Raphael Manfredi <Raphael_Manfredi@grenoble.hp.co
         exactly what nstore() is meant for...
 
         However, we continue to use SV addresses as tags for plain store(),
-        because benchamarking shows that it saves up to 8% of the store
+        because benchmarking shows that it saves up to 8% of the store
         time, and store() is meant to be fast at the expense of lack
         of portability.
 
diff --git a/dist/Storable/README b/dist/Storable/README
index e9def9d380..247dcc245a 100644
--- a/dist/Storable/README
+++ b/dist/Storable/README
@@ -19,7 +19,7 @@
 | Manfredi for providing us with this very useful module.
 +=======================================================================
 
-The Storable extension brings persistency to your data.
+The Storable extension brings persistence to your data.
 
 You may recursively store to disk any data structure, no matter how
 complex and circular it is, provided it contains only SCALAR, ARRAY,
@@ -44,10 +44,10 @@ To compile this extension, run:
     make
     make install
 
-There is an embeded POD manual page in Storable.pm.
+There is an embedded POD manual page in Storable.pm.
 
 Storable was written by Raphael Manfredi <Raphael_Manfredi@pobox.com>
-Maitainance is now done by the perl5-porters <perl5-porters@perl.org>
+Maintenance is now done by the perl5-porters <perl5-porters@perl.org>
 
 Please e-mail us with problems, bug fixes, comments and complaints,
 although if you have complements you should send them to Raphael.
diff --git a/dist/Storable/Storable.pm b/dist/Storable/Storable.pm
index 83689285b9..689cdb92cc 100644
--- a/dist/Storable/Storable.pm
+++ b/dist/Storable/Storable.pm
@@ -914,7 +914,7 @@ version of Storable fully support (but see discussion of
 C<$Storable::accept_future_minor> above).  The constant
 C<Storable::BIN_WRITE_VERSION_NV> function returns what file version
 is written and might be less than C<Storable::BIN_VERSION_NV> in some
-configuations.
+configurations.
 
 =item C<major>, C<minor>
 
diff --git a/dist/Storable/Storable.xs b/dist/Storable/Storable.xs
index 35788256c8..317ada795d 100644
--- a/dist/Storable/Storable.xs
+++ b/dist/Storable/Storable.xs
@@ -180,7 +180,7 @@ typedef double NV;			/* Older perls lack the NV type */
 
 #define SX_OBJECT	C(0)	/* Already stored object */
 #define SX_LSCALAR	C(1)	/* Scalar (large binary) follows (length, data) */
-#define SX_ARRAY	C(2)	/* Array forthcominng (size, item list) */
+#define SX_ARRAY	C(2)	/* Array forthcoming (size, item list) */
 #define SX_HASH		C(3)	/* Hash forthcoming (size, key/value pair list) */
 #define SX_REF		C(4)	/* Reference to object forthcoming */
 #define SX_UNDEF	C(5)	/* Undefined scalar */
@@ -249,12 +249,12 @@ typedef double NV;			/* Older perls lack the NV type */
  * keys are not enough a motivation to reclaim that space).
  *
  * This structure is also used for memory store/retrieve operations which
- * happen in a fixed place before being malloc'ed elsewhere if persistency
+ * happen in a fixed place before being malloc'ed elsewhere if persistence
  * is required. Hence the aptr pointer.
  */
 struct extendable {
 	char *arena;		/* Will hold hash key strings, resized as needed */
-	STRLEN asiz;		/* Size of aforementionned buffer */
+	STRLEN asiz;		/* Size of aforementioned buffer */
 	char *aptr;			/* Arena pointer, for in-place read/write ops */
 	char *aend;			/* First invalid address */
 };
@@ -267,7 +267,7 @@ struct extendable {
  *
  * At retrieve time:
  * An array table records the objects which have already been retrieved,
- * as seen by the tag determind by counting the objects themselves. The
+ * as seen by the tag determined by counting the objects themselves. The
  * reference to that retrieved object is kept in the table, and is returned
  * when an SX_OBJECT is found bearing that same tag.
  *
@@ -369,7 +369,7 @@ typedef struct stcxt {
 	SV *eval;           /* whether to eval source code */
 	int canonical;		/* whether to store hashes sorted by key */
 #ifndef HAS_RESTRICTED_HASHES
-        int derestrict;         /* whether to downgrade restrcted hashes */
+        int derestrict;         /* whether to downgrade restricted hashes */
 #endif
 #ifndef HAS_UTF8_ALL
         int use_bytes;         /* whether to bytes-ify utf8 */
@@ -791,12 +791,12 @@ static const char magicstr[] = "pst0";		 /* Used as a magic number */
 /* 5.6.x introduced the ability to have IVs as long long.
    However, Configure still defined BYTEORDER based on the size of a long.
    Storable uses the BYTEORDER value as part of the header, but doesn't
-   explicity store sizeof(IV) anywhere in the header.  Hence on 5.6.x built
+   explicitly store sizeof(IV) anywhere in the header.  Hence on 5.6.x built
    with IV as long long on a platform that uses Configure (ie most things
    except VMS and Windows) headers are identical for the different IV sizes,
    despite the files containing some fields based on sizeof(IV)
    Erk. Broken-ness.
-   5.8 is consistent - the following redifinition kludge is only needed on
+   5.8 is consistent - the following redefinition kludge is only needed on
    5.6.x, but the interwork is needed on 5.8 while data survives in files
    with the 5.6 header.
 
@@ -1299,7 +1299,7 @@ static void init_store_context(
 	 * values stored are not real SV, just integers cast to (SV *),
 	 * which explains the freeing below.
 	 *
-	 * It is also one possible bottlneck to achieve good storing speed,
+	 * It is also one possible bottleneck to achieve good storing speed,
 	 * so the "shared keys" optimization is turned off (unlikely to be
 	 * of any use here), and the hash table is "pre-extended". Together,
 	 * those optimizations increase the throughput by 12%.
@@ -1406,7 +1406,7 @@ static void clean_store_context(pTHX_ stcxt_t *cxt)
 	 *
 	 * The surrounding if() protection has been added because there might be
 	 * some cases where this routine is called more than once, during
-	 * exceptionnal events.  This was reported by Marc Lehmann when Storable
+	 * exceptional events.  This was reported by Marc Lehmann when Storable
 	 * is executed from mod_perl, and the fix was suggested by him.
 	 * 		-- RAM, 20/12/2000
 	 */
@@ -1486,7 +1486,7 @@ static void init_retrieve_context(pTHX_ stcxt_t *cxt, int optype, int is_tainted
 	/*
 	 * If retrieving an old binary version, the cxt->retrieve_vtbl variable
 	 * was set to sv_old_retrieve. We'll need a hash table to keep track of
-	 * the correspondance between the tags and the tag number used by the
+	 * the correspondence between the tags and the tag number used by the
 	 * new retrieve routines.
 	 */
 
@@ -1947,7 +1947,7 @@ static int known_class(
 }
 
 /***
- *** Sepcific store routines.
+ *** Specific store routines.
  ***/
 
 /*
@@ -2199,7 +2199,7 @@ static int store_scalar(pTHX_ stcxt_t *cxt, SV *sv)
  *
  * Store an array.
  *
- * Layout is SX_ARRAY <size> followed by each item, in increading index order.
+ * Layout is SX_ARRAY <size> followed by each item, in increasing index order.
  * Each item is stored as <object>.
  */
 static int store_array(pTHX_ stcxt_t *cxt, AV *av)
@@ -2279,7 +2279,7 @@ sortcmp(const void *a, const void *b)
  * Values are stored as <object>.
  * Keys are stored as <flags> <length> <data>, the <data> section being omitted
  * if length is 0.
- * Currently the only hash flag is "restriced"
+ * Currently the only hash flag is "restricted"
  * Key flags are as for hv.h
  */
 static int store_hash(pTHX_ stcxt_t *cxt, HV *hv)
@@ -2767,7 +2767,7 @@ static int store_tied(pTHX_ stcxt_t *cxt, SV *sv)
 	 * Note that we store the Perl object as-is. We don't call its FETCH
 	 * method along the way. At retrieval time, we won't call its STORE
 	 * method either, but the tieing magic will be re-installed. In itself,
-	 * that ensures that the tieing semantics are preserved since futher
+	 * that ensures that the tieing semantics are preserved since further
 	 * accesses on the retrieved object will indeed call the magic methods...
 	 */
 
@@ -3788,7 +3788,7 @@ static int do_store(
 	 * Ensure sv is actually a reference. From perl, we called something
 	 * like:
 	 *       pstore(aTHX_ FILE, \@array);
-	 * so we must get the scalar value behing that reference.
+	 * so we must get the scalar value behind that reference.
 	 */
 
 	if (!SvROK(sv))
@@ -4225,7 +4225,7 @@ static SV *retrieve_hook(pTHX_ stcxt_t *cxt, const char *cname)
 	 *
 	 * We read object tags and we can convert them into SV* on the fly
 	 * because we know all the references listed in there (as tags)
-	 * have been already serialized, hence we have a valid correspondance
+	 * have been already serialized, hence we have a valid correspondence
 	 * between each of those tags and the recreated SV.
 	 */
 
@@ -5084,7 +5084,7 @@ static SV *retrieve_sv_no(pTHX_ stcxt_t *cxt, const char *cname)
  * retrieve_array
  *
  * Retrieve a whole array.
- * Layout is SX_ARRAY <size> followed by each item, in increading index order.
+ * Layout is SX_ARRAY <size> followed by each item, in increasing index order.
  * Each item is stored as <object>.
  *
  * When we come here, SX_ARRAY has been read already.
@@ -5477,7 +5477,7 @@ static SV *retrieve_code(pTHX_ stcxt_t *cxt, const char *cname)
  *
  * Retrieve a whole array in pre-0.6 binary format.
  *
- * Layout is SX_ARRAY <size> followed by each item, in increading index order.
+ * Layout is SX_ARRAY <size> followed by each item, in increasing index order.
  * Each item is stored as SX_ITEM <object> or SX_IT_UNDEF for "holes".
  *
  * When we come here, SX_ARRAY has been read already.
@@ -5770,7 +5770,7 @@ static SV *magic_check(pTHX_ stcxt_t *cxt)
     if ((cxt->netorder = (use_network_order & 0x1)))	/* Extra () for -Wall */
         return &PL_sv_undef;			/* No byte ordering info */
 
-    /* In C truth is 1, falsehood is 0. Very convienient.  */
+    /* In C truth is 1, falsehood is 0. Very convenient.  */
     use_NV_size = version_major >= 2 && version_minor >= 2;
 
     if (version_major >= 0) {
@@ -5839,7 +5839,7 @@ static SV *retrieve(pTHX_ stcxt_t *cxt, const char *cname)
 	/*
 	 * Grab address tag which identifies the object if we are retrieving
 	 * an older format. Since the new binary format counts objects and no
-	 * longer explicitely tags them, we must keep track of the correspondance
+	 * longer explicitly tags them, we must keep track of the correspondence
 	 * ourselves.
 	 *
 	 * The following section will disappear one day when the old format is
@@ -6189,7 +6189,7 @@ static SV *do_retrieve(
 	 * so that we can croak when behaviour cannot be re-installed, and also
 	 * avoid testing for overloading magic at each reference retrieval.
 	 *
-	 * Unfortunately, the root reference is implicitely stored, so we must
+	 * Unfortunately, the root reference is implicitly stored, so we must
 	 * check for possible overloading now.  Furthermore, if we don't restore
 	 * overloading, we cannot croak as if the original ref was, because we
 	 * have no way to determine whether it was an overloaded ref or not in
diff --git a/dist/Storable/t/attach_singleton.t b/dist/Storable/t/attach_singleton.t
index 7b140322be..d05e9bac2c 100644
--- a/dist/Storable/t/attach_singleton.t
+++ b/dist/Storable/t/attach_singleton.t
@@ -51,7 +51,7 @@ is( "$struct->[1]", "$thawed->[1]", 'Singleton thaws correctly' );
 
 # We can also test this empirically
 $struct->[1]->{value} = 'Goodbye cruel world!';
-is_deeply( $struct, $thawed, 'Empiric testing corfirms correct behaviour' );
+is_deeply( $struct, $thawed, 'Empiric testing confirms correct behaviour' );
 
 # End Tests
 ###########
diff --git a/dist/Storable/t/canonical.t b/dist/Storable/t/canonical.t
index 243ffa5b4b..7085d360ee 100644
--- a/dist/Storable/t/canonical.t
+++ b/dist/Storable/t/canonical.t
@@ -22,7 +22,7 @@ use vars qw($debugging $verbose);
 
 use Test::More tests => 8;
 
-# Uncomment the folowing line to get a dump of the constructed data structure
+# Uncomment the following line to get a dump of the constructed data structure
 # (you may want to reduce the size of the hashes too)
 # $debugging = 1;
 
@@ -106,7 +106,7 @@ is($x1, $x2);
 is($x1, $x3);
 
 # In normal mode it is exceedingly unlikely that the frozen
-# representaions of all the hashes will be the same (normally the hash
+# representations of all the hashes will be the same (normally the hash
 # elements are frozen in the order they are stored internally,
 # i.e. pseudo-randomly).
 
diff --git a/dist/Storable/t/circular_hook.t b/dist/Storable/t/circular_hook.t
index 7dca1192ab..fd635c0c6e 100644
--- a/dist/Storable/t/circular_hook.t
+++ b/dist/Storable/t/circular_hook.t
@@ -34,7 +34,7 @@ my $array = [ $ddd ];
 my $string = Storable::freeze( $array );
 my $thawed = Storable::thaw( $string );
 
-# is_deeply infinite loops in ciculars, so do it manually
+# is_deeply infinite loops in circulars, so do it manually
 # is_deeply( $array, $thawed, 'Circular hooked objects work' );
 is( ref($thawed), 'ARRAY', 'Top level ARRAY' );
 is( scalar(@$thawed), 1, 'ARRAY contains one element' );
diff --git a/dist/Storable/t/downgrade.t b/dist/Storable/t/downgrade.t
index 8520c59784..db7d457498 100644
--- a/dist/Storable/t/downgrade.t
+++ b/dist/Storable/t/downgrade.t
@@ -96,7 +96,7 @@ sub thaw_scalar {
     # TODO tests.
     warn "# Test skipped because eq is buggy for certain Unicode cases in 5.6.0";
     warn "# Please upgrade to 5.6.1\n";
-    ok ("I'd really like to fail this test on 5.6.0 but I'm told that CPAN auto-dependancies mess up, and certain vendors only ship 5.6.0. Get your vendor to ugrade. Else upgrade your vendor.");
+    ok ("I'd really like to fail this test on 5.6.0 but I'm told that CPAN auto-dependencies mess up, and certain vendors only ship 5.6.0. Get your vendor to ugrade. Else upgrade your vendor.");
     # One such vendor being the folks who brought you LONG_MIN as a positive
     # integer.
   } else {
diff --git a/dist/Storable/t/overload.t b/dist/Storable/t/overload.t
index 2a14710dd1..bf1441bb67 100644
--- a/dist/Storable/t/overload.t
+++ b/dist/Storable/t/overload.t
@@ -99,7 +99,7 @@ is($$$t, 'snow');
 
 
 #---
-# blessed reference to overloded object.
+# blessed reference to overloaded object.
 {
   my $a = bless [88], 'OVERLOADED';
   my $c = thaw freeze bless \$a, 'main';
diff --git a/dist/Storable/t/restrict.t b/dist/Storable/t/restrict.t
index b21b37cea4..c27d874e45 100644
--- a/dist/Storable/t/restrict.t
+++ b/dist/Storable/t/restrict.t
@@ -20,7 +20,7 @@ sub BEGIN {
 	    print "1..0 # Skip: No Hash::Util pre 5.005\n";
 	    exit 0;
 	    # And doing this seems on 5.004 seems to create bogus warnings about
-	    # unitialized variables, or coredumps in Perl_pp_padsv
+	    # uninitialized variables, or coredumps in Perl_pp_padsv
 	} elsif (!eval "require Hash::Util") {
             if ($@ =~ /Can\'t locate Hash\/Util\.pm in \@INC/s) {
                 print "1..0 # Skip: No Hash::Util:\n";
diff --git a/dist/Storable/t/st-dump.pl b/dist/Storable/t/st-dump.pl
index 4add56087b..e9652f02e2 100644
--- a/dist/Storable/t/st-dump.pl
+++ b/dist/Storable/t/st-dump.pl
@@ -31,7 +31,7 @@ sub main'dump {
 # This is the root recursive dumping routine that may indirectly be
 # called by one of the routine it calls...
 # The link parameter is set to false when the reference passed to
-# the routine is an internal temporay variable, implying the object's
+# the routine is an internal temporary variable, implying the object's
 # address is not to be dumped in the %dumped table since it's not a
 # user-visible object.
 sub recursive_dump {
diff --git a/dist/Storable/t/tied.t b/dist/Storable/t/tied.t
index 7e2adb0524..6c6381abb4 100644
--- a/dist/Storable/t/tied.t
+++ b/dist/Storable/t/tied.t
@@ -131,7 +131,7 @@ tie $scalar, TIED_SCALAR;
 
 ### If I say
 ###   $hash{'attribute'} = $d;
-### below, then dump() incorectly dumps the hash value as a string the second
+### below, then dump() incorrectly dumps the hash value as a string the second
 ### time it is reached. I have not investigated enough to tell whether it's
 ### a bug in my dump() routine or in the Perl tieing mechanism.
 $scalar = 'foo';
diff --git a/dist/Storable/t/utf8.t b/dist/Storable/t/utf8.t
index 284a44a31f..fd20ef6caa 100644
--- a/dist/Storable/t/utf8.t
+++ b/dist/Storable/t/utf8.t
@@ -37,7 +37,7 @@ $x = chr (175) . chr (256);
 chop $x;
 is($x, ${thaw freeze \$x});
 
-# Storable needs to cope if a frozen string happens to be internall utf8
+# Storable needs to cope if a frozen string happens to be internal utf8
 # encoded
 
 $x = chr 256;
@@ -50,6 +50,6 @@ is($x, ${thaw $data});
 
 
 $data .= chr 256;
-# This definately isn't valid
+# This definitely isn't valid
 eval {thaw $data};
 like($@, qr/corrupt.*characters outside/);