a few typo fixes

Message-Id: <200111120515.fAC5FIc74795@ventrue.corp.yahoo.com>

Patching README.foo instead of pod/perlfoo.pod,
not patching Math::BigInt (Tels will take care of that),
dropping broken hv.c and sv.h patches, patching libnetcfg.PL
and perldoc.PL instead of libnetcfg and perldoc, patching
ext/Digest/MD5/t/files.t since MD5.pm was changed.

p4raw-id: //depot/perl@12954

26 files changed, 70 insertions, 70 deletions

diff --git a/pod/perlapi.pod b/pod/perlapi.pod
index e01489ab49..fb6d0a669d 100644
--- a/pod/perlapi.pod
+++ b/pod/perlapi.pod
@@ -575,7 +575,7 @@ returns UV_MAX, sets C<PERL_SCAN_GREATER_THAN_UV_MAX> in the output flags,
 and writes the value to I<*result> (or the value is discarded if I<result>
 is NULL).
 
-The hex number may optinally be prefixed with "0b" or "b" unless
+The hex number may optionally be prefixed with "0b" or "b" unless
 C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
 C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the binary
 number may use '_' characters to separate digits.
@@ -601,7 +601,7 @@ returns UV_MAX, sets C<PERL_SCAN_GREATER_THAN_UV_MAX> in the output flags,
 and writes the value to I<*result> (or the value is discarded if I<result>
 is NULL).
 
-The hex number may optinally be prefixed with "0x" or "x" unless
+The hex number may optionally be prefixed with "0x" or "x" unless
 C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
 C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the hex
 number may use '_' characters to separate digits.
@@ -2285,7 +2285,7 @@ Found in file sv.h
 =item SvIVx
 
 Coerces the given SV to an integer and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvIV> otherwise.
+sv only once. Use the more efficient C<SvIV> otherwise.
 
 	IV	SvIVx(SV* sv)
 
@@ -2410,7 +2410,7 @@ Found in file sv.h
 =item SvNVx
 
 Coerces the given SV to a double and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvNV> otherwise.
+sv only once. Use the more efficient C<SvNV> otherwise.
 
 	NV	SvNVx(SV* sv)
 
@@ -2519,7 +2519,7 @@ Found in file sv.h
 =item SvPVbytex
 
 Like C<SvPV>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
 otherwise.
 
 
@@ -2531,7 +2531,7 @@ Found in file sv.h
 =item SvPVbytex_force
 
 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
 otherwise.
 
 	char*	SvPVbytex_force(SV* sv, STRLEN len)
@@ -2569,7 +2569,7 @@ Found in file sv.h
 =item SvPVutf8x
 
 Like C<SvPV>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
 otherwise.
 
 	char*	SvPVutf8x(SV* sv, STRLEN len)
@@ -2580,7 +2580,7 @@ Found in file sv.h
 =item SvPVutf8x_force
 
 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
 otherwise.
 
 	char*	SvPVutf8x_force(SV* sv, STRLEN len)
@@ -2953,7 +2953,7 @@ Found in file sv.h
 =item SvUVx
 
 Coerces the given SV to an unsigned integer and returns it. Guarantees to
-evaluate sv only once. Use the more efficent C<SvUV> otherwise.
+evaluate sv only once. Use the more efficient C<SvUV> otherwise.
 
 	UV	SvUVx(SV* sv)
 
@@ -4245,7 +4245,7 @@ $utf8::ToLower, which is stored in lib/unicore/To/Lower.pl,
 and loaded by SWASHGET, using lib/utf8_heavy.pl.
 
 The "special" is a string like "utf8::ToSpecLower", which means
-the hash %utf8::ToSpecLower, which is stored in in the same file,
+the hash %utf8::ToSpecLower, which is stored in the same file,
 lib/unicore/To/Lower.pl, and also loaded by SWASHGET.  The access
 to the hash is by Perl_to_utf8_case().
 
diff --git a/pod/perlcompile.pod b/pod/perlcompile.pod
index 282592e9fb..07c4202bc1 100644
--- a/pod/perlcompile.pod
+++ b/pod/perlcompile.pod
@@ -9,7 +9,7 @@ internal form (a parse tree) which is then optimized before being
 run.  Since version 5.005, Perl has shipped with a module
 capable of inspecting the optimized parse tree (C<B>), and this has
 been used to write many useful utilities, including a module that lets
-you turn your Perl into C source code that can be compiled into an
+you turn your Perl into C source code that can be compiled into a
 native executable.
 
 The C<B> module provides access to the parse tree, and other modules
diff --git a/pod/perldebguts.pod b/pod/perldebguts.pod
index efc979861f..ff2b074ec4 100644
--- a/pod/perldebguts.pod
+++ b/pod/perldebguts.pod
@@ -774,7 +774,7 @@ were
 	   4     12    24    48    80
 
 With non-C<DEBUGGING> perl, the buckets starting from C<128> have
-a 4-byte overhead, and thus a 8192-long bucket may take up to
+a 4-byte overhead, and thus an 8192-long bucket may take up to
 8188-byte allocations.
 
 =item C<Total sbrk(): SBRKed/SBRKs:CONTINUOUS>
diff --git a/pod/perldiag.pod b/pod/perldiag.pod
index 365faa6928..a4c6543bd2 100644
--- a/pod/perldiag.pod
+++ b/pod/perldiag.pod
@@ -611,7 +611,7 @@ line.
 
 =item Can't exec "%s": %s
 
-(W exec) An system(), exec(), or piped open call could not execute the
+(W exec) A system(), exec(), or piped open call could not execute the
 named program for the indicated reason.  Typical reasons include: the
 permissions were wrong on the file, the file wasn't found in
 C<$ENV{PATH}>, the executable in question was compiled for another
@@ -1629,11 +1629,11 @@ two from 1 to 32 (or 64, if your platform supports that).
 
 =item Illegal octal digit %s
 
-(F) You used an 8 or 9 in a octal number.
+(F) You used an 8 or 9 in an octal number.
 
 =item Illegal octal digit %s ignored
 
-(W digit) You may have tried to use an 8 or 9 in a octal number.
+(W digit) You may have tried to use an 8 or 9 in an octal number.
 Interpretation of the octal number stopped before the 8 or 9.
 
 =item Illegal switch in PERL5OPT: %s
@@ -1837,7 +1837,7 @@ L<perlfunc/listen>.
 
 =item lstat() on filehandle %s
 
-(W io) You tried to do a lstat on a filehandle.  What did you mean
+(W io) You tried to do an lstat on a filehandle.  What did you mean
 by that?  lstat() makes sense only on filenames.  (Perl did a fstat()
 instead on the filehandle.)
 
@@ -2688,7 +2688,7 @@ the result of the value of the environment variable PERLIO.
 =item perlio: invalid separator character %s in attribute list
 
 (S) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of an layer list.
+colon or whitespace was seen between the elements of a layer list.
 If the previous attribute had a parenthesised parameter list, perhaps that
 list was terminated too soon.
 
@@ -3284,13 +3284,13 @@ L<perlop/"Quote and Quote-like Operators">.
 
 =item Substitution pattern not terminated
 
-(F) The lexer couldn't find the interior delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
 construct.  Remember that bracketing delimiters count nesting level.
 Missing the leading C<$> from variable C<$s> may cause this error.
 
 =item Substitution replacement not terminated
 
-(F) The lexer couldn't find the final delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the final delimiter of an s/// or s{}{}
 construct.  Remember that bracketing delimiters count nesting level.
 Missing the leading C<$> from variable C<$s> may cause this error.
 
diff --git a/pod/perldsc.pod b/pod/perldsc.pod
index 5ab97e1795..11304a67ac 100644
--- a/pod/perldsc.pod
+++ b/pod/perldsc.pod
@@ -15,7 +15,7 @@ hacked Perl's internal symbol table directly, a strategy that proved hard
 to develop and maintain--to put it mildly.
 
 The 5.0 release of Perl let us have complex data structures.  You
-may now write something like this and all of a sudden, you'd have a array
+may now write something like this and all of a sudden, you'd have an array
 with three dimensions!
 
     for $x (1 .. 10) {
@@ -32,7 +32,7 @@ elaborate construct than meets the eye!
 
 How do you print it out?  Why can't you say just C<print @AoA>?  How do
 you sort it?  How can you pass it to a function or get one of these back
-from a function?  Is is an object?  Can you save it to disk to read
+from a function?  Is it an object?  Can you save it to disk to read
 back later?  How do you access whole rows or columns of that matrix?  Do
 all the values have to be numeric?
 
@@ -76,7 +76,7 @@ one-dimensional.  They can hold only scalar values (meaning a string,
 number, or a reference).  They cannot directly contain other arrays or
 hashes, but instead contain I<references> to other arrays or hashes.
 
-You can't use a reference to a array or hash in quite the same way that you
+You can't use a reference to an array or hash in quite the same way that you
 would a real array or hash.  For C or C++ programmers unused to
 distinguishing between arrays and pointers to the same, this can be
 confusing.  If so, just think of it as the difference between a structure
@@ -332,7 +332,7 @@ types of data structures.
 
 =head1 ARRAYS OF ARRAYS
 
-=head2 Declaration of a ARRAY OF ARRAYS
+=head2 Declaration of an ARRAY OF ARRAYS
 
  @AoA = (
         [ "fred", "barney" ],
@@ -340,7 +340,7 @@ types of data structures.
         [ "homer", "marge", "bart" ],
       );
 
-=head2 Generation of a ARRAY OF ARRAYS
+=head2 Generation of an ARRAY OF ARRAYS
 
  # reading from file
  while ( <> ) {
@@ -361,7 +361,7 @@ types of data structures.
  # add to an existing row
  push @{ $AoA[0] }, "wilma", "betty";
 
-=head2 Access and Printing of a ARRAY OF ARRAYS
+=head2 Access and Printing of an ARRAY OF ARRAYS
 
  # one element
  $AoA[0][0] = "Fred";
@@ -466,7 +466,7 @@ types of data structures.
 
 =head1 ARRAYS OF HASHES
 
-=head2 Declaration of a ARRAY OF HASHES
+=head2 Declaration of an ARRAY OF HASHES
 
  @AoH = (
         {
@@ -485,7 +485,7 @@ types of data structures.
         }
   );
 
-=head2 Generation of a ARRAY OF HASHES
+=head2 Generation of an ARRAY OF HASHES
 
  # reading from file
  # format: LEAD=fred FRIEND=barney
@@ -521,7 +521,7 @@ types of data structures.
  $AoH[0]{pet} = "dino";
  $AoH[2]{pet} = "santa's little helper";
 
-=head2 Access and Printing of a ARRAY OF HASHES
+=head2 Access and Printing of an ARRAY OF HASHES
 
  # one element
  $AoH[0]{lead} = "fred";
diff --git a/pod/perlembed.pod b/pod/perlembed.pod
index 1a08a77390..e8634577b0 100644
--- a/pod/perlembed.pod
+++ b/pod/perlembed.pod
@@ -792,7 +792,7 @@ Now compile:
 
  % cc -o persistent persistent.c `perl -MExtUtils::Embed -e ccopts -e ldopts`
 
-Here's a example script file:
+Here's an example script file:
 
  #test.pl
  my $string = "hello";
diff --git a/pod/perlfaq6.pod b/pod/perlfaq6.pod
index be7e8ecc73..7c9fa6a202 100644
--- a/pod/perlfaq6.pod
+++ b/pod/perlfaq6.pod
@@ -279,7 +279,7 @@ consider an underscore a letter).
 
 The Perl parser will expand $variable and @variable references in
 regular expressions unless the delimiter is a single quote.  Remember,
-too, that the right-hand side of a C<s///> substitution is considered
+too, that the right-hand side of an C<s///> substitution is considered
 a double-quoted string (see L<perlop> for more details).  Remember
 also that any regex special characters will be acted on unless you
 precede the substitution with \Q.  Here's an example:
diff --git a/pod/perlfilter.pod b/pod/perlfilter.pod
index 4221371a05..0103f8cfa3 100644
--- a/pod/perlfilter.pod
+++ b/pod/perlfilter.pod
@@ -527,7 +527,7 @@ blocks get included.
 Once you can identify individual blocks, try allowing them to be
 nested. That isn't difficult either.
 
-Here is a interesting idea that doesn't involve the Debug filter.
+Here is an interesting idea that doesn't involve the Debug filter.
 Currently Perl subroutines have fairly limited support for formal
 parameter lists. You can specify the number of parameters and their
 type, but you still have to manually take them out of the C<@_> array
diff --git a/pod/perlfunc.pod b/pod/perlfunc.pod
index 8722105c2b..174ff60f27 100644
--- a/pod/perlfunc.pod
+++ b/pod/perlfunc.pod
@@ -69,7 +69,7 @@ last value in the list.  Some operators return a count of successful
 operations.  In general, they do what you want, unless you want
 consistency.
 
-An named array in scalar context is quite different from what would at
+A named array in scalar context is quite different from what would at
 first glance appear to be a list in scalar context.  You can't get a list
 like C<(1,2,3)> into being in scalar context, because the compiler knows
 the context at compile time.  It would generate the scalar comma operator
@@ -857,7 +857,7 @@ back.  Look at the F<by-module/Crypt> and F<by-module/PGP> directories
 on your favorite CPAN mirror for a slew of potentially useful
 modules.
 
-If using crypt() on an Unicode string (which potentially has
+If using crypt() on a Unicode string (which potentially has
 characters with codepoints above 255), Perl tries to make sense of
 the situation by using only the low eight bits of the characters when
 calling crypt().
@@ -2004,7 +2004,7 @@ C<File::Glob> extension.  See L<File::Glob> for details.
 
 =item gmtime EXPR
 
-Converts a time as returned by the time function to a 8-element list
+Converts a time as returned by the time function to an 8-element list
 with the time localized for the standard Greenwich time zone.
 Typically used as follows:
 
@@ -2327,7 +2327,7 @@ C<redo> work.
 
 =item lc
 
-Returns an lowercased version of EXPR.  This is the internal function
+Returns a lowercased version of EXPR.  This is the internal function
 implementing the C<\L> escape in double-quoted strings.  Respects
 current LC_CTYPE locale if C<use locale> in force.  See L<perllocale>
 and L<perlunicode> for more details about locale and Unicode support.
@@ -3925,7 +3925,7 @@ may vary from one execution to the next (see C<wantarray>).  If no EXPR
 is given, returns an empty list in list context, the undefined value in
 scalar context, and (of course) nothing at all in a void context.
 
-(Note that in the absence of a explicit C<return>, a subroutine, eval,
+(Note that in the absence of an explicit C<return>, a subroutine, eval,
 or do FILE will automatically return the value of the last expression
 evaluated.)
 
diff --git a/pod/perlguts.pod b/pod/perlguts.pod
index 8ccdde8fa8..148ae9600c 100644
--- a/pod/perlguts.pod
+++ b/pod/perlguts.pod
@@ -405,7 +405,7 @@ specified below.
             /* Get the key from an HE structure and also return
                the length of the key string */
     SV*    hv_iterval(HV*, HE* entry);
-            /* Return a SV pointer to the value of the HE
+            /* Return an SV pointer to the value of the HE
                structure */
     SV*    hv_iternextsv(HV*, char** key, I32* retlen);
             /* This convenience routine combines hv_iternext,
@@ -609,7 +609,7 @@ package.
 
 =head2 Reference Counts and Mortality
 
-Perl uses an reference count-driven garbage collection mechanism. SVs,
+Perl uses a reference count-driven garbage collection mechanism. SVs,
 AVs, or HVs (xV for short in the following) start their life with a
 reference count of 1.  If the reference count of an xV ever drops to 0,
 then it will be destroyed and its memory made available for reuse.
@@ -866,7 +866,7 @@ was initially made magical.
 
 =head2 Magic Virtual Tables
 
-The C<mg_virtual> field in the C<MAGIC> structure is a pointer to a
+The C<mg_virtual> field in the C<MAGIC> structure is a pointer to an
 C<MGVTBL>, which is a structure of function pointers and stands for
 "Magic Virtual Table" to handle the various operations that might be
 applied to that variable.
@@ -1255,7 +1255,7 @@ C<sarg> of C<SV*> of length C<maxsarg>.
 
 =item C<SV* save_svref(SV **sptr)>
 
-Similar to C<save_scalar>, but will reinstate a C<SV *>.
+Similar to C<save_scalar>, but will reinstate an C<SV *>.
 
 =item C<void save_aptr(AV **aptr)>
 
diff --git a/pod/perlintro.pod b/pod/perlintro.pod
index ee4a0118c8..cde6742746 100644
--- a/pod/perlintro.pod
+++ b/pod/perlintro.pod
@@ -169,7 +169,7 @@ The elements we're getting from the array start with a C<$> because
 we're getting just a single value out of the array -- you ask for a scalar, 
 you get a scalar.
 
-To get multiple values from a array:
+To get multiple values from an array:
 
     @animals[0,1];                  # gives ("camel", "llama");
     @animals[0..2];                 # gives ("camel", "llama", "owl");
diff --git a/pod/perliol.pod b/pod/perliol.pod
index 037c9f4a8f..a31ffd1847 100644
--- a/pod/perliol.pod
+++ b/pod/perliol.pod
@@ -19,7 +19,7 @@ C<USE_SFIO> is not).
 
 The PerlIO abstraction was introduced in perl5.003_02 but languished as
 just an abstraction until perl5.7.0. However during that time a number
-of perl extentions switched to using it, so the API is mostly fixed to
+of perl extensions switched to using it, so the API is mostly fixed to
 maintain (source) compatibility.
 
 The aim of the implementation is to provide the PerlIO API in a flexible
@@ -53,7 +53,7 @@ The basic data structure is a PerlIOl:
 	 IV		flags;      /* Various flags for state */
 	};
 
-A C<PerlIOl *> is a pointer to to the struct, and the I<application> level
+A C<PerlIOl *> is a pointer to the struct, and the I<application> level
 C<PerlIO *> is a pointer to a C<PerlIOl *> - i.e. a pointer to a pointer to
 the struct. This allows the application level C<PerlIO *> to remain
 constant while the actual C<PerlIOl *> underneath changes. (Compare perl's
@@ -214,7 +214,7 @@ not having a buffer layer.
 
 Extra layers can be inserted to process the data as it flows through.
 This was the driving need for including the scheme in perl 5.7.0+ - we
-needed a mechanism to allow data to be translated bewteen perl's
+needed a mechanism to allow data to be translated between perl's
 internal encoding (conceptually at least Unicode as UTF-8), and the
 "native" format used by the system. This is provided by the
 ":encoding(xxxx)" layer which typically sits above the buffering layer.
@@ -248,7 +248,7 @@ Reads are permitted i.e. opened "r" or "w+" (or even "a+" - ick).
 
 =item PERLIO_F_ERROR
 
-An error has occured (for C<PerlIO_error()>)
+An error has occurred (for C<PerlIO_error()>)
 
 =item PERLIO_F_TRUNCATE
 
@@ -305,10 +305,10 @@ Handle is open.
 
 This instance of this layer supports the "fast C<gets>" interface.
 Normally set based on C<PERLIO_K_FASTGETS> for the class and by the
-existance of the function(s) in the table. However a class that
+existence of the function(s) in the table. However a class that
 normally provides that interface may need to avoid it on a
 particular instance. The "pending" layer needs to do this when
-it is pushed above an layer which does not support the interface.
+it is pushed above a layer which does not support the interface.
 (Perl's C<sv_gets()> does not expect the streams fast C<gets> behaviour
 to change during one "get".)
 
@@ -320,7 +320,7 @@ to change during one "get".)
 
 =item  IV		(*Pushed)(PerlIO *f,const char *mode, SV *arg);
 
-The only absoultely mandatory method. Called when the layer is pushed onto the stack.
+The only absolutely mandatory method. Called when the layer is pushed onto the stack.
 The C<mode> argument may  be NULL if this occurs post-open. The C<arg> will be non-C<NULL>
 if an argument string was passed. In most cases this should call
 C<PerlIOBase_pushed()> to convert C<mode> into the appropriate
@@ -366,15 +366,15 @@ The C<'I'> prefix is used during creation of C<stdin>..C<stderr> via special
 C<PerlIO_fdopen> calls; the C<'#'> prefix means that this is C<sysopen> and that I<imode> and
 I<perm> should be passed to C<PerlLIO_open3>; C<'r'> means B<r>ead, C<'w'> means B<w>rite
 and C<'a'> means B<a>ppend. The C<'+'> suffix means that both reading and writing/appending
-are permited. The C<'b'> suffix means file should be binary, and C<'t'> means it
+are permitted. The C<'b'> suffix means file should be binary, and C<'t'> means it
 is text. (Binary/Text should be ignored by almost all layers and binary IO done,
 with PerlIO. The C<:crlf> layer should be pushed to handle the distinction.)
 
-If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl iteself does not use
+If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl itself does not use
 this (yet?) and semantics are a little vague.
 
 If I<fd> not negative then it is the numeric file descriptor I<fd>, which will
-be open in an manner compatible with the supplied mode string, the call is
+be open in a manner compatible with the supplied mode string, the call is
 thus equivalent to C<PerlIO_fdopen>. In this case I<nargs> will be zero.
 
 If I<nargs> is greater than zero then it gives the number of arguments passed
@@ -383,7 +383,7 @@ In simple cases SvPV(*args) is the pathname to open.
 
 Having said all that translation-only layers do not need to provide C<Open()> at all,
 but rather leave the opening to a lower level layer and wait to be "pushed".
-If a layer does provide C<Open()> it should normaly call the C<Open()> method
+If a layer does provide C<Open()> it should normally call the C<Open()> method
 of next layer down (if any) and then push itself on top if that succeeds.
 
 =item SV *		(*Getarg)(PerlIO *f);
@@ -394,7 +394,7 @@ return an SvPV with value "ascii".
 
 =item IV	(*Fileno)(PerlIO *f);
 
-Returns the Unix/Posix numeric file decriptor for the handle. Normally
+Returns the Unix/Posix numeric file descriptor for the handle. Normally
 C<PerlIOBase_fileno()> (which just asks next layer down) will suffice
 for this.
 
@@ -437,7 +437,7 @@ structure.
 
 Should make stream's state consistent with layers below. That is, any
 buffered write data should be written, and file position of lower layers
-adjusted for data read fron below but not actually consumed.
+adjusted for data read from below but not actually consumed.
 (Should perhaps C<Unread()> such data to the lower layer.)
 
 =item  IV		(*Fill)(PerlIO *f);
diff --git a/pod/perlipc.pod b/pod/perlipc.pod
index 56816b15d6..e591f54bf8 100644
--- a/pod/perlipc.pod
+++ b/pod/perlipc.pod
@@ -1218,8 +1218,8 @@ clear out.
 
 Once the generic server socket has been created using the parameters
 listed above, the server then waits for a new client to connect
-to it.  The server blocks in the C<accept> method, which eventually an
-bidirectional connection to the remote client.  (Make sure to autoflush
+to it.  The server blocks in the C<accept> method, which eventually accepts a
+bidirectional connection from the remote client.  (Make sure to autoflush
 this handle to circumvent buffering.)
 
 To add to user-friendliness, our server prompts the user for commands.
diff --git a/pod/perlmodlib.pod b/pod/perlmodlib.pod
index 53e491c8a2..80ad7c1de5 100644
--- a/pod/perlmodlib.pod
+++ b/pod/perlmodlib.pod
@@ -990,7 +990,7 @@ system B<man> command, you might try the B<perldoc> program.
 
 Extension modules are written in C (or a mix of Perl and C).  They
 are usually dynamically loaded into Perl if and when you need them,
-but may also be be linked in statically.  Supported extension modules
+but may also be linked in statically.  Supported extension modules
 include Socket, Fcntl, and POSIX.
 
 Many popular C extension modules do not come bundled (at least, not
diff --git a/pod/perlopentut.pod b/pod/perlopentut.pod
index a1d3955930..b158480935 100644
--- a/pod/perlopentut.pod
+++ b/pod/perlopentut.pod
@@ -765,7 +765,7 @@ uses locking and another doesn't, all bets are off.
 
 By default, the C<flock> call will block until a lock is granted.
 A request for a shared lock will be granted as soon as there is no
-exclusive locker.  A request for a exclusive lock will be granted as
+exclusive locker.  A request for an exclusive lock will be granted as
 soon as there is no locker of any kind.  Locks are on file descriptors,
 not file names.  You can't lock a file until you open it, and you can't
 hold on to a lock once the file has been closed.
diff --git a/pod/perlpodspec.pod b/pod/perlpodspec.pod
index 6b6e08d3a4..46d3ec8707 100644
--- a/pod/perlpodspec.pod
+++ b/pod/perlpodspec.pod
@@ -758,7 +758,7 @@ the CE<lt>interest rate> attribute...'").
 Pod parsers, when processing a series of verbatim paragraphs one
 after another, should consider them to be one large verbatim
 paragraph that happens to contain blank lines.  I.e., these two
-lines, which have an blank line between them:
+lines, which have a blank line between them:
 
 	use Foo;
 
diff --git a/pod/perlport.pod b/pod/perlport.pod
index 4edf7108a6..5869135020 100644
--- a/pod/perlport.pod
+++ b/pod/perlport.pod
@@ -559,7 +559,7 @@ often happens when tests spawn off other processes or call external
 programs to aid in the testing, or when (as noted above) the tests
 assume certain things about the filesystem and paths.  Be careful
 not to depend on a specific output style for errors, such as when
-checking C<$!> after an system call.  Some platforms expect a certain
+checking C<$!> after a system call.  Some platforms expect a certain
 output format, and perl on those platforms may have been adjusted
 accordingly.  Most specifically, don't anchor a regex when testing
 an error value.
diff --git a/pod/perlre.pod b/pod/perlre.pod
index 874fed419f..6c687495cb 100644
--- a/pod/perlre.pod
+++ b/pod/perlre.pod
@@ -1024,7 +1024,7 @@ Some people get too used to writing things like:
 
 This is grandfathered for the RHS of a substitute to avoid shocking the
 B<sed> addicts, but it's a dirty habit to get into.  That's because in
-PerlThink, the righthand side of a C<s///> is a double-quoted string.  C<\1> in
+PerlThink, the righthand side of an C<s///> is a double-quoted string.  C<\1> in
 the usual double-quoted string means a control-A.  The customary Unix
 meaning of C<\1> is kludged in for C<s///>.  However, if you get into the habit
 of doing that, you get yourself into trouble if you then add an C</e>
diff --git a/pod/perlref.pod b/pod/perlref.pod
index e8e9ab78fa..7255162fcd 100644
--- a/pod/perlref.pod
+++ b/pod/perlref.pod
@@ -31,7 +31,7 @@ have been officially "blessed" into a class package.)
 
 Symbolic references are names of variables or other objects, just as a
 symbolic link in a Unix filesystem contains merely the name of a file.
-The C<*glob> notation is something of a of symbolic reference.  (Symbolic
+The C<*glob> notation is something of a symbolic reference.  (Symbolic
 references are sometimes called "soft references", but please don't call
 them that; references are confusing enough without useless synonyms.)
 
diff --git a/pod/perlretut.pod b/pod/perlretut.pod
index cc8f5c4c9b..65dfb4782c 100644
--- a/pod/perlretut.pod
+++ b/pod/perlretut.pod
@@ -1415,7 +1415,7 @@ naive regexp
     $dna = "ATCGTTGAATGCAAATGACATGAC";
     $dna =~ /TGA/;
 
-doesn't work; it may match an C<TGA>, but there is no guarantee that
+doesn't work; it may match a C<TGA>, but there is no guarantee that
 the match is aligned with codon boundaries, e.g., the substring
 S<C<GTT GAA> > gives a match.  A better solution is
 
diff --git a/pod/perltoc.pod b/pod/perltoc.pod
index ca73c5ee09..0d2e6137ad 100644
--- a/pod/perltoc.pod
+++ b/pod/perltoc.pod
@@ -9910,7 +9910,7 @@ Fixed length 32-bit encodings, Multi-byte encodings, "Escape" encodings
 =item Encoding Names
 
 The MIME name as defined in IETF RFC-XXXX, The name in the IANA registry,
-The name used by the the organization that defined it
+The name used by the organization that defined it
 
 =back
 
diff --git a/pod/perltodo.pod b/pod/perltodo.pod
index 534580ac18..44a7d1030e 100644
--- a/pod/perltodo.pod
+++ b/pod/perltodo.pod
@@ -194,7 +194,7 @@ Cozens has some ideas on this.
 
 =head2 DLL Versioning
 
-Windows needs a way to know what version of a XS or C<libperl> DLL it's
+Windows needs a way to know what version of an XS or C<libperl> DLL it's
 loading.
 
 =head2 Introduce @( and @)
diff --git a/pod/perltooc.pod b/pod/perltooc.pod
index c162220061..2ba6b42a0b 100644
--- a/pod/perltooc.pod
+++ b/pod/perltooc.pod
@@ -646,7 +646,7 @@ name them whatever you care to.  Blindly and obediently using new()
 for each and every constructor you ever write is to speak Perl with
 such a severe C++ accent that you do a disservice to both languages.
 There's no reason to insist that each class have but one constructor,
-or that that constructor be named new(), or that that constructor be
+or that a constructor be named new(), or that a constructor be
 used solely as a class method and not an object method.
 
 The next section shows how useful it can be to further distance ourselves
diff --git a/pod/perltrap.pod b/pod/perltrap.pod
index 753e721fcb..262937910d 100644
--- a/pod/perltrap.pod
+++ b/pod/perltrap.pod
@@ -688,7 +688,7 @@ If in doubt:
 
 Assignment of return values from numeric equality tests
 does not work in perl5 when the test evaluates to false (0).
-Logical tests now return an null, instead of 0
+Logical tests now return a null, instead of 0
 
     $p = ($test == 1);
     print $p,"\n";
diff --git a/pod/perlunicode.pod b/pod/perlunicode.pod
index 277238e452..e56f3ff9da 100644
--- a/pod/perlunicode.pod
+++ b/pod/perlunicode.pod
@@ -20,7 +20,7 @@ Other encodings can be converted to perl's encoding on input, or from
 perl's encoding on output by use of the ":encoding(...)" layer.
 See L<open>.
 
-To mark the Perl source itself as being in an particular encoding,
+To mark the Perl source itself as being in a particular encoding,
 see L<encoding>.
 
 =item Regular Expressions
diff --git a/pod/perlxs.pod b/pod/perlxs.pod
index ab38dcc40c..cee8e168b0 100644
--- a/pod/perlxs.pod
+++ b/pod/perlxs.pod
@@ -816,7 +816,7 @@ pointer would not modify the Perl parameter, but is put in the output
 list.
 
 The C<OUTLIST>/C<OUT> parameter differ from C<IN_OUTLIST>/C<IN_OUT>
-parameters only by the the initial value of the Perl parameter not
+parameters only by the initial value of the Perl parameter not
 being read (and not being given to the C function - which gets some
 garbage instead).  For example, the same C function as above can be
 interfaced with as
@@ -1344,7 +1344,7 @@ of C<&>, but provide a pointer to this value when the C function is called.
 
 This is useful to avoid a CODE: block for a C function which takes a parameter
 by reference.  Typically, the parameter should be not a pointer type (an
-C<int> or C<long> but not a C<int*> or C<long*>).
+C<int> or C<long> but not an C<int*> or C<long*>).
 
 The following XSUB will generate incorrect C code.  The B<xsubpp> compiler will
 turn this into code which calls C<rpcb_gettime()> with parameters C<(char