This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
podcheck.t: Use new Pod::Checker
authorKarl Williamson <khw@cpan.org>
Wed, 25 May 2016 17:10:18 +0000 (11:10 -0600)
committerKarl Williamson <khw@cpan.org>
Fri, 27 May 2016 17:23:05 +0000 (11:23 -0600)
podcheck.t extends the Pod::Checker class.  Pod::Checker has been
rewritten to base off of Pod::Simple instead of Pod::Parser, and so
podcheck.t must switch to use use the completely new methods defined.

t/porting/known_pod_issues.dat
t/porting/podcheck.t

index e22d4bc..322c43d 100644 (file)
@@ -331,6 +331,7 @@ pod/perlce.pod      Verbatim line length including indents exceeds 79 by    3
 pod/perldebguts.pod    Verbatim line length including indents exceeds 79 by    27
 pod/perldebtut.pod     Verbatim line length including indents exceeds 79 by    3
 pod/perldtrace.pod     Verbatim line length including indents exceeds 79 by    7
+pod/perlgit.pod        ? Should you be using F<...> or maybe L<...> instead of 1
 pod/perlgit.pod        Verbatim line length including indents exceeds 79 by    1
 pod/perlguts.pod       ? Should you be using L<...> instead of 1
 pod/perlhack.pod       ? Should you be using L<...> instead of 1
@@ -341,6 +342,7 @@ pod/perlirix.pod    Verbatim line length including indents exceeds 79 by    1
 pod/perlmacosx.pod     Verbatim line length including indents exceeds 79 by    3
 pod/perlmodlib.pod     Verbatim line length including indents exceeds 79 by    3
 pod/perlmroapi.pod     ? Should you be using L<...> instead of 1
+pod/perlop.pod ? Should you be using F<...> or maybe L<...> instead of 2
 pod/perlos2.pod        ? Should you be using L<...> instead of 2
 pod/perlos2.pod        Verbatim line length including indents exceeds 79 by    5
 pod/perlos390.pod      Verbatim line length including indents exceeds 79 by    2
@@ -353,7 +355,8 @@ pod/perltru64.pod   Verbatim line length including indents exceeds 79 by    1
 pod/perlwin32.pod      Verbatim line length including indents exceeds 79 by    7
 porting/epigraphs.pod  Verbatim line length including indents exceeds 79 by    16
 porting/release_managers_guide.pod     Verbatim line length including indents exceeds 79 by    1
-utils/encguess There is no NAME        1
+porting/todo.pod       ? Should you be using F<...> or maybe L<...> instead of 1
+utils/ptar     Verbatim paragraph in NAME section      1
 lib/benchmark.pm       Verbatim line length including indents exceeds 79 by    2
 lib/config.pod ? Should you be using L<...> instead of -1
 lib/perl5db.pl ? Should you be using L<...> instead of 1
index cefe58f..d267f71 100644 (file)
@@ -1,5 +1,7 @@
 #!/usr/bin/perl -w
 
+package main;
+
 BEGIN {
     chdir 't';
     @INC = "../lib";
@@ -56,8 +58,7 @@ pods in the distribution workspace, except certain known special ones
 (specified below).  It does additional checking beyond that done by
 Pod::Checker, and keeps a database of known potential problems, and will
 fail a pod only if the number of such problems differs from that given in the
-database.  It also suppresses the C<(section) deprecated> message from
-Pod::Checker, since specifying the man page section number is quite proper to do.
+database.
 
 The additional checks it always makes are:
 
@@ -92,13 +93,6 @@ missing from the C<LE<lt>E<gt>> pod command.
 A pod can't be linked to unless it has a unique name.
 And a NAME should have a dash and short description after it.
 
-=item =encoding statement issues
-
-This indicates if an C<=encoding> statement should be present, or moved to the
-front of the pod.
-
-=back
-
 If the C<PERL_POD_PEDANTIC> environment variable is set or the C<--pedantic>
 command line argument is provided then a few more checks are made.
 The pedantic checks are:
@@ -161,6 +155,8 @@ Another problem is that there is currently no check that modules listed as
 valid in the database
 actually are.  Thus any errors introduced there will remain there.
 
+=back
+
 =head2 Specially handled pods
 
 =over
@@ -363,8 +359,6 @@ my $broken_link = "Apparent broken link";
 my $broken_internal_link = "Apparent internal link is missing its forward slash";
 my $multiple_targets = "There is more than one target";
 my $duplicate_name = "Pod NAME already used";
-my $need_encoding = "Should have =encoding statement because have non-ASCII";
-my $encoding_first = "=encoding must be first command (if present)";
 my $no_name = "There is no NAME";
 my $missing_name_description = "The NAME should have a dash and short description after it";
 # the pedantic warnings messages
@@ -385,9 +379,6 @@ my $dl_ext  = $Config{'dlext'};   $dl_ext  =~ tr/.//d;
 my %excluded_files = (
                         canonicalize("lib/unicore/mktables") => 1,
                         canonicalize("Porting/make-rmg-checklist") => 1,
-                        # this one is a POD, but unfinished, so skip
-                        # it for now
-                        canonicalize("Porting/perl5200delta.pod") => 1,
                         canonicalize("Porting/perldelta_template.pod") => 1,
                         canonicalize("regen/feature.pl") => 1,
                         canonicalize("regen/warnings.pl") => 1,
@@ -440,19 +431,26 @@ my $non_pods = qr/ (?: \.
                 /x;
 
 # Matches something that looks like a file name, but is enclosed in C<...>
-my $C_path_re = qr{ \b ( C<
+my $C_path_re = qr{ ^
                         # exclude various things that have slashes
                         # in them but aren't paths
                         (?!
                             (?: (?: s | qr | m) / ) # regexes
-                            | \d+/\d+>       # probable fractions
-                            | OS/2>
-                            | Perl/Tk>
-                            | origin/blead>
-                            | origin/maint
-                            | -    # File names don't begin with "-"
-                            )
-                            [-\w]+ (?: / [-\w]+ )+ (?: \. \w+ )? > )
+                            | \d+/\d+ \b       # probable fractions
+                            | (?: [LF] < )+
+                            | OS/2 \b
+                            | Perl/Tk \b
+                            | origin/blead \b
+                            | origin/maint \b
+
+                        )
+                        /?  # Optional initial slash
+                        \w+ # First component of path, doesn't begin with
+                            # a minus
+                        (?: / [-\w]+ )+ # Subsequent path components
+                        (?: \. \w+ )?   # Optional trailing dot and suffix
+                        >*  # Any enclosed L< F< have matching closing >
+                        $
                     }x;
 
 # '.PL' files should be excluded, as they aren't final pods, but often contain
@@ -480,20 +478,19 @@ close $manifest_fh, or die "Can't close $MANIFEST";
 
 # Pod::Checker messages to suppress
 my @suppressed_messages = (
-    "(section) in",                         # Checker is wrong to flag this
-    "multiple occurrence of link target",   # We catch independently the ones
-                                            # that are real problems.
-    "unescaped <>",
-    "Entity number out of range",   # Checker outputs this for anything above
-                                    # 255, but in fact all Unicode is valid
-    "No items in =over",            # ie a blockquote
+    # We catch independently the ones that are real problems.
+    qr/multiple occurrences \(\d+\) of link target/,
+
+    "unescaped <>",                 # Not every '<' or '>' need be escaped
+    qr/No items in =over/,          # i.e., a blockquote, which we consider legal
 );
 
 sub suppressed {
     # Returns bool as to if input message is one that is to be suppressed
 
     my $message = shift;
-    return grep { $message =~ /^\Q$_/i } @suppressed_messages;
+
+    return grep { $message =~ /^$_/i } @suppressed_messages;
 }
 
 {   # Closure to contain a simple subset of test.pl.  This is to get rid of the
@@ -643,37 +640,54 @@ package My::Pod::Checker {      # Extend Pod::Checker
 
     # Uses inside out hash to protect from typos
     # For new fields, remember to add to destructor DESTROY()
-    my %indents;            # Stack of indents from =over's in effect for
-                            # current line
+    my %CFL_text;           # The text comprising the current C<>, F<>, or L<>
+    my %C_text;             # If defined, are in a C<> section, and includes
+                            # the accumulated text from that
     my %current_indent;     # Current line's indent
     my %filename;           # The pod is store in this file
-    my %skip;               # is SKIP set for this pod
+    my %in_CFL;             # count of stacked C<>, F<>, L<> directives
+    my %indents;            # Stack of indents from =over's in effect for
+                            # current line
+    my %in_for;             # true if in a =for or =begin
     my %in_NAME;            # true if within NAME section
     my %in_begin;           # true if within =begin section
+    my %in_X;               # true if in a X<>
     my %linkable_item;      # Bool: if the latest =item is linkable.  It isn't
                             # for bullet and number lists
     my %linkable_nodes;     # Pod::Checker adds all =items to its node list,
                             # but not all =items are linkable to
-    my %seen_encoding_cmd;  # true if have =encoding earlier
+    my %running_CFL_text;   # The current text that is being accumulated until
+                            # an end_FOO is found, and this includes any C<>,
+                            # F<>, or L<> directives.
+    my %running_simple_text; # The currentt text that is being accumulated
+                            # until an end_FOO is found, and all directives
+                            # have been expanded into plain text
     my %command_count;      # Number of commands seen
     my %seen_pod_cmd;       # true if have =pod earlier
-    my %warned_encoding;    # true if already have warned about =encoding
-                            # problems
+    my %skip;               # is SKIP set for this pod
+    my %start_line;         # the first input line number in the the thing
+                            # currently being worked on
 
     sub DESTROY {
         my $addr = Scalar::Util::refaddr $_[0];
+        delete $CFL_text{$addr};
+        delete $C_text{$addr};
         delete $command_count{$addr};
         delete $current_indent{$addr};
         delete $filename{$addr};
         delete $in_begin{$addr};
+        delete $in_CFL{$addr};
         delete $indents{$addr};
+        delete $in_for{$addr};
         delete $in_NAME{$addr};
+        delete $in_X{$addr};
         delete $linkable_item{$addr};
         delete $linkable_nodes{$addr};
-        delete $seen_encoding_cmd{$addr};
+        delete $running_CFL_text{$addr};
+        delete $running_simple_text{$addr};
         delete $seen_pod_cmd{$addr};
         delete $skip{$addr};
-        delete $warned_encoding{$addr};
+        delete $start_line{$addr};
         return;
     }
 
@@ -688,11 +702,11 @@ package My::Pod::Checker {      # Extend Pod::Checker
         $current_indent{$addr} = 0;
         $filename{$addr} = $filename;
         $in_begin{$addr} = 0;
+        $in_X{$addr} = 0;
+        $in_CFL{$addr} = 0;
         $in_NAME{$addr} = 0;
         $linkable_item{$addr} = 0;
-        $seen_encoding_cmd{$addr} = 0;
         $seen_pod_cmd{$addr} = 0;
-        $warned_encoding{$addr} = 0;
         return $self;
     }
 
@@ -794,88 +808,163 @@ package My::Pod::Checker {      # Extend Pod::Checker
         #push @{$problems{$self->get_filename}{$message}}, $opts;
     }
 
-    sub check_encoding {    # Does it need an =encoding statement?
-        my ($self, $paragraph, $line_num, $pod_para) = @_;
+    # In the next subroutines, we keep track of the text of the current
+    # innermost thing, like F<fooC<bar>baz>.  The things we care about raising
+    # messages about in this program all come from a single sequence of
+    # characters uninterrupted by other pod commands.  Therefore we don't have
+    # to worry about recursion, and we can just set the string we care about
+    # to empty on entrance to each command.
+
+    sub handle_text {
+        # This is called by the parent class to deal with any straight text.
+        # We mostly just append this to the running current value which will
+        # be dealt with upon the end of the current construct, like a
+        # paragraph.  But certain things don't contribute to checking the pod
+        # and are ignored.  We also have set flags to indicate this text is
+        # going towards constructing certain constructs, and handle those
+        # specially.
 
-        # Do nothing if there is an =encoding in the file, or if the line
-        # doesn't require an =encoding, or have already warned.
+        my $self = shift;
         my $addr = Scalar::Util::refaddr $self;
-        return if $seen_encoding_cmd{$addr}
-                    || $warned_encoding{$addr}
-                    || $paragraph !~ /\P{ASCII}/;
-
-        $warned_encoding{$addr} = 1;
-        my ($file, $line) = $pod_para->file_line;
-        $self->poderror({ -line => $line, -file => $file,
-                          -msg => $need_encoding
-                        });
-        return;
+
+        my $return = $self->SUPER::handle_text(@_);
+
+        if ($in_X{$addr} || $in_for{$addr}) { # ignore
+            return $return;
+        }
+
+        my $text = join "\n", @_;
+        $running_simple_text{$addr} .= $text;
+
+        # Keep separate tabs on C<>, F<>, and L<> directives, and one
+        # especially for C<> ones.
+        if ($in_CFL{$addr}) {
+            $CFL_text{$addr} .= $text;
+            $C_text{$addr} .= $text if defined $C_text{$addr};
+        }
+        else {
+            # This variable is updated instead in the corresponding C, F, or L
+            # handler.
+            $running_CFL_text{$addr} .= $text;
+        }
+
+        return $return;
     }
 
-    sub verbatim {
-        my ($self, $paragraph, $line_num, $pod_para) = @_;
-        $self->check_encoding($paragraph, $line_num, $pod_para);
+    # The start_FOO routines check that somehow a C<> construct hasn't escaped
+    # without being checked, and initialize things, and call the parent
+    # class's equivalent routine.
+
+    # The end_FOO routines close things off, and check the text that has been
+    # accumulated for FOO, then call the parent's corresponding routine.
 
-        $self->SUPER::verbatim($paragraph, $line_num, $pod_para);
+    sub start_Para {
+        my $self = shift;
+        check_see_but_not_link($self);
 
         my $addr = Scalar::Util::refaddr $self;
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+        return $self->SUPER::start_Para(@_);
+    }
 
-        # Pick up the name, since the parent class doesn't in verbatim
-        # NAMEs; so treat as non-verbatim.  The parent class only allows one
-        # paragraph in a NAME section, so if there is an extra blank line, it
-        # will trigger a message, but such a blank line is harmless, so skip
-        # in that case.
-        if ($in_NAME{$addr} && $paragraph =~ /\S/) {
-            $self->textblock($paragraph, $line_num, $pod_para);
-        }
+    sub start_item_text {
+        my $self = shift;
+        check_see_but_not_link($self);
 
-        my @lines = split /^/, $paragraph;
-        for my $i (0 .. @lines - 1) {
-            if ( my $encoding = $seen_encoding_cmd{$addr} ) {
-              require Encode;
-              $lines[$i] = Encode::decode($encoding, $lines[$i]);
-            }
-            $lines[$i] =~ s/\s+$//;
-            my $indent = $self->get_current_indent;
-
-            if ($pedantic) { # TODO: this check should be moved higher
-                                 # to avoid more unnecessary work
-                my $exceeds = length(Text::Tabs::expand($lines[$i]))
-                    + $indent - $MAX_LINE_LENGTH;
-                next unless $exceeds > 0;
-                my ($file, $line) = $pod_para->file_line;
-                $self->poderror({ -line => $line + $i, -file => $file,
-                    -msg => $line_length,
-                    parameter => "+$exceeds (including " . ($indent - $INDENT) . " from =over's)",
-                });
-            }
-        }
+        my $addr = Scalar::Util::refaddr $self;
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+
+        # This is the only =item that is linkable
+        $linkable_item{$addr} = 1;
+
+        return $self->SUPER::start_item_text(@_);
     }
 
-    sub textblock {
-        my ($self, $paragraph, $line_num, $pod_para) = @_;
-        $self->check_encoding($paragraph, $line_num, $pod_para);
+    sub start_item_number {
+        my $self = shift;
+        check_see_but_not_link($self);
 
-        $self->SUPER::textblock($paragraph, $line_num, $pod_para);
+        my $addr = Scalar::Util::refaddr $self;
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+
+        return $self->SUPER::start_item_number(@_);
+    }
+
+    sub start_item_bullet {
+        my $self = shift;
+        check_see_but_not_link($self);
 
-        my ($file, $line) = $pod_para->file_line;
         my $addr = Scalar::Util::refaddr $self;
-        if ($in_NAME{$addr}) {
-            if (! $self->name) {
-                my $text = $self->interpolate($paragraph, $line_num);
-                if ($text =~ /^\s*(\S+?)\s*$/) {
-                    $self->name($1);
-                    $self->poderror({ -line => $line, -file => $file,
-                        -msg => $missing_name_description,
-                        parameter => $1});
-                }
-            }
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+
+        return $self->SUPER::start_item_bullet(@_);
+    }
+
+    sub end_item {  # No difference in =item types endings
+        my $self = shift;
+        check_see_but_not_link($self);
+        return $self->SUPER::end_item(@_);
+    }
+
+    sub start_over {
+        my $self = shift;
+        check_see_but_not_link($self);
+
+        my $addr = Scalar::Util::refaddr $self;
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+
+        # Save this indent on a stack, and keep track of total indent
+        my $indent =  $_[0]{'indent'};
+        push @{$indents{$addr}}, $indent;
+        $current_indent{$addr} += $indent;
+
+        return $self->SUPER::start_over(@_);
+    }
+
+    sub end_over_bullet { shift->end_over(@_) }
+    sub end_over_number { shift->end_over(@_) }
+    sub end_over_text   { shift->end_over(@_) }
+    sub end_over_block  { shift->end_over(@_) }
+    sub end_over_empty  { shift->end_over(@_) }
+    sub end_over {
+        my $self = shift;
+        check_see_but_not_link($self);
+
+        my $addr = Scalar::Util::refaddr $self;
+
+        # Pop current indent
+        if (@{$indents{$addr}}) {
+            $current_indent{$addr} -= pop @{$indents{$addr}};
         }
-        $paragraph = join " ", split /^/, $paragraph;
+        else {
+            # =back without corresponding =over, but should have
+            # warned already
+            $current_indent{$addr} = 0;
+        }
+    }
+
+    sub check_see_but_not_link {
 
-        # If looks like a reference to other documentation by containing the
-        # word 'See' and then a likely pod directive, warn.
-        while ($paragraph =~ m{
+        # Looks through accumulated text for current element that includes the
+        # C<>, F<>, and L<> directives for ones that look like they are
+        # C<link> instead of L<link>.
+
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        return unless defined $running_CFL_text{$addr};
+
+        while ($running_CFL_text{$addr} =~ m{
                                 ( (?: \w+ \s+ )* )  # The phrase before, if any
                                 \b [Ss]ee \s+
                                 ( ( [^L] )
@@ -884,7 +973,8 @@ package My::Pod::Checker {      # Extend Pod::Checker
                                   >
                                 )
                                 ( \s+ (?: under | in ) \s+ L< )?
-                            }xg) {
+                            }xg)
+        {
             my $prefix = $1 // "";
             my $construct = $2;     # The whole thing, like C<...>
             my $type = $3;
@@ -901,25 +991,13 @@ package My::Pod::Checker {      # Extend Pod::Checker
                 # construct would be if it actually has L<> syntax.  If it
                 # doesn't have that syntax, will set the module to the entire
                 # interior.
-                $interior =~ m/ ^
-                                (?: [^|]+ \| )? # Optional arbitrary text ending
-                                                # in "|"
-                                ( .+? )         # module, etc. name
-                                (?: \/ .+ )?    # target within module
-                                $
-                            /xs;
-                my $module = $1;
                 if (! defined $trailing # not referring to something in another
                                         # section
                     && $interior !~ /$non_pods/
 
-                    # C<> that look like files have their own message below, so
-                    # exclude them
-                    && $construct !~ /$C_path_re/g
-
                     # There can't be spaces (I think) in module names or man
                     # pages
-                    && $module !~ / \s /x
+                    && $interior !~ / \s /x
 
                     # F<> that end in eg \.pl are almost certainly ok, as are
                     # those that look like a path with multiple "/" chars
@@ -930,139 +1008,266 @@ package My::Pod::Checker {      # Extend Pod::Checker
                     )
                 ) {
                     # TODO: move the checking of $pedantic higher up
-                    $self->poderror({ -line => $line, -file => $file,
+                    $self->poderror({ -line => $start_line{$addr},
                         -msg => $C_not_linked,
                         parameter => $construct
-                    }) if $pedantic;
+                    });
                 }
             }
         }
-        while ($paragraph =~ m/$C_path_re/g) {
-            my $construct = $1;
-            # TODO: move the checking of $pedantic higher up
-            $self->poderror({ -line => $line, -file => $file,
-                -msg => $C_with_slash,
-                parameter => $construct
-            }) if $pedantic;
-        }
-        return;
+
+        undef $running_CFL_text{$addr};
     }
 
-    sub command {
-        my ($self, $cmd, $paragraph, $line_num, $pod_para) = @_;
+    sub end_Para {
+        my $self = shift;
+        check_see_but_not_link($self);
+
         my $addr = Scalar::Util::refaddr $self;
-        if ($cmd eq "pod") {
-            $seen_pod_cmd{$addr}++;
-        }
-        elsif ($cmd eq "encoding") {
-            my ($file, $line) = $pod_para->file_line;
-            $seen_encoding_cmd{$addr} = $paragraph; # for later decoding
-            if ($command_count{$addr} != 1 && $seen_pod_cmd{$addr}) {
-                $self->poderror({ -line => $line, -file => $file,
-                                  -msg => $encoding_first
-                                });
+        if ($in_NAME{$addr}) {
+            if ($running_simple_text{$addr} =~ /^\s*(\S+?)\s*$/) {
+                $self->poderror({ -line => $start_line{$addr},
+                    -msg => $missing_name_description,
+                    parameter => $1});
             }
+            $in_NAME{$addr} = 0;
         }
-        $self->check_encoding($paragraph, $line_num, $pod_para);
-
-        # Pod::Check treats all =items as linkable, but the bullet and
-        # numbered lists really aren't.  So keep our own list.  This has to be
-        # processed before SUPER is called so that the list is started before
-        # the rest of it gets parsed.
-        if ($cmd eq 'item') { # Not linkable if item begins with * or a digit
-            $linkable_item{$addr} = ($paragraph !~ / ^ \s*
-                                                   (?: [*]
-                                                   | \d+ \.? (?: \$ | \s+ )
-                                                   )/x)
-                                  ? 1
-                                  : 0;
+        $self->SUPER::end_Para(@_);
+    }
+
+    sub start_head1 {
+        my $self = shift;
+        check_see_but_not_link($self);
 
+        my $addr = Scalar::Util::refaddr $self;
+        $start_line{$addr} = $_[0]->{start_line};
+        $running_CFL_text{$addr} = "";
+        $running_simple_text{$addr} = "";
+
+        return $self->SUPER::start_head1(@_);
+    }
+
+    sub end_head1 {  # This is called at the end of the =head line.
+        my $self = shift;
+        check_see_but_not_link($self);
+
+        my $addr = Scalar::Util::refaddr $self;
+
+        $in_NAME{$addr} = 1 if $running_simple_text{$addr} eq 'NAME';
+        return $self->SUPER::end_head(@_);
+    }
+
+    sub start_Verbatim {
+        my $self = shift;
+        check_see_but_not_link($self);
+
+        my $addr = Scalar::Util::refaddr $self;
+        $running_simple_text{$addr} = "";
+        $start_line{$addr} = $_[0]->{start_line};
+        return $self->SUPER::start_Verbatim(@_);
+    }
+
+    sub end_Verbatim {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        # Pick up the name if it looks like one, since the parent class
+        # doesn't handle verbatim NAMEs
+        if ($in_NAME{$addr}
+            && $running_simple_text{$addr} =~ /^\s*(\S+?)\s*[,-]/)
+        {
+            $self->name($1);
         }
-        $self->SUPER::command($cmd, $paragraph, $line_num, $pod_para);
-
-        $command_count{$addr}++;
-
-        $in_NAME{$addr} = 0;    # Will change to 1 below if necessary
-        $in_begin{$addr} = 0;   # ibid
-        if ($cmd eq 'over') {
-            my $text = $self->interpolate($paragraph, $line_num);
-            my $indent = 4; # default
-            $indent = $1 if $text && $text =~ /^\s*(\d+)\s*$/;
-            push @{$indents{$addr}}, $indent;
-            $current_indent{$addr} += $indent;
+
+        my $indent = $self->get_current_indent;
+
+        # Look at each line to verify it is short enough
+        my @lines = split /^/, $running_simple_text{$addr};
+        for my $i (0 .. @lines - 1) {
+            $lines[$i] =~ s/\s+$//;
+            my $exceeds = length(Text::Tabs::expand($lines[$i]))
+                        + $indent - $MAX_LINE_LENGTH;
+            next unless $exceeds > 0;
+
+            $self->poderror({ -line => $start_line{$addr} + $i,
+                -msg => $line_length,
+                parameter => "+$exceeds (including " . ($indent - $INDENT) . " from =over's)",
+            });
         }
-        elsif ($cmd eq 'back') {
-            if (@{$indents{$addr}}) {
-                $current_indent{$addr} -= pop @{$indents{$addr}};
+
+        undef $running_simple_text{$addr};
+
+        # Parent class didn't bother to define this
+        #return $self->SUPER::SUPER::end_Verbatim(@_);
+    }
+
+    sub start_C {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $C_text{$addr} = "";
+
+        # If not in a stacked set of C<>, F<> and L<>, initialize the text for
+        # them.
+        $CFL_text{$addr} = "" if ! $in_CFL{$addr};
+        $in_CFL{$addr}++;
+
+        return $self->SUPER::start_C(@_);
+    }
+
+    sub start_F {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $CFL_text{$addr} = "" if ! $in_CFL{$addr};
+        $in_CFL{$addr}++;
+        return $self->SUPER::start_F(@_);
+    }
+
+    sub start_L {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $CFL_text{$addr} = "" if ! $in_CFL{$addr};
+        $in_CFL{$addr}++;
+        return $self->SUPER::start_L(@_);
+    }
+
+    sub end_C {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        # Warn if looks like a file or link enclosed instead by this C<>
+        if ($C_text{$addr} =~ qr/^ $C_path_re $/x) {
+            # Here it does look like it could be be a file path or a link.
+            # But some varieties of regex patterns could also fit with what we
+            # have so far.  Weed those out as best we can.  '/foo/' is almost
+            # certainly meant to be a pattern, as is '/foo/g'.
+            my $is_pattern;
+            if ($C_text{$addr} !~ qr| ^ / [^/]* / ( [msixpodualngcr]* ) $ |x) {
+                $is_pattern = 0;
             }
             else {
-                 # =back without corresponding =over, but should have
-                 # warned already
-                $current_indent{$addr} = 0;
-            }
-        }
-        elsif ($cmd =~ /^head/) {
-            if (! $in_begin{$addr}) {
 
-                # If a particular formatter, then this command doesn't really
-                # apply
-                $current_indent{$addr} = 0;
-                undef @{$indents{$addr}};
+                # Here, it looks like a pattern potentially followed by some
+                # modifiers.  To make doubly sure, don't count as patterns
+                # those constructs which have more occurrences (generally 1)
+                # of a modifier than is legal.
+                my %counts;
+                map { $counts{$_}++ } split "", $1;
+                foreach my $modifier (keys %counts) {
+                    if ($counts{$modifier} > (($modifier eq 'a')
+                                              ? 2
+                                              : 1))
+                    {
+                        $is_pattern = 0;
+                        last;
+                    }
+                }
+                $is_pattern = 1 unless defined $is_pattern;
             }
 
-            my $text = $self->interpolate($paragraph, $line_num);
-            $in_NAME{$addr} = 1 if $cmd eq 'head1'
-                                   && $text && $text =~ /^NAME\b/;
-        }
-        elsif ($cmd eq 'begin') {
-            $in_begin{$addr} = 1;
+            unless ($is_pattern) {
+                $self->poderror({ -line => $start_line{$addr},
+                    -msg => $C_with_slash,
+                    parameter => "C<$C_text{$addr}>"
+                });
+            }
         }
+        undef $C_text{$addr};
+
+        # Add the current text to the running total.  This was not done in
+        # handle_text(), because it just sees the plain text of the innermost
+        # stacked directive.  We want to keep all the directive names
+        # enclosing the text.  Otherwise the fact that C<L<foobar>> is to a
+        # link would be lost, as the L<> would be gone.
+        $CFL_text{$addr} = "C<$CFL_text{$addr}>";
+
+        # Add this text to the the whole running total only if popping this
+        # directive off the stack leaves it empty.  As long as something is on
+        # the stack, it gets added to $CFL_text (just above).  It is only
+        # entirely constructed when the stack is empty.
+        $in_CFL{$addr}--;
+        $running_CFL_text{$addr} .= $CFL_text{$addr} if ! $in_CFL{$addr};
+
+        return $self->SUPER::end_C(@_);
+    }
 
-        return;
+    sub end_F {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $CFL_text{$addr} = "F<$CFL_text{$addr}>";
+        $in_CFL{$addr}--;
+        $running_CFL_text{$addr} .= $CFL_text{$addr} if ! $in_CFL{$addr};
+        return $self->SUPER::end_F(@_);
     }
 
-    sub hyperlink {
+    sub end_L {
         my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
 
-        my $page;
-        if ($_[0] && ($page = $_[0][1]{'-page'})) {
-            my $node = $_[0][1]{'-node'};
-
-            if ($node) {
-                $_[0][1]{'-node'} = $node = do {
-                    my $expand_seq = sub {
-                        my (undef, $seq) = @_;
-                        my $arg = join '', $seq->parse_tree->children;
-                        if ($seq->name eq 'E') {
-                            $arg =
-                                $arg eq 'sol'    ? '/' :
-                                $arg eq 'verbar' ? '|' :
-                                $arg eq 'lt'     ? '<' :
-                                $arg eq 'gt'     ? '>' :
-                                die "Not implemented: E<$arg>";
-                        }
-                        return $arg;
-                    };
-                    my $ptree = $self->parse_text({ -expand_seq => $expand_seq }, $node, $_[0][0]);
-                    join '', $ptree->children
-                };
-
-                # If the hyperlink is to an interior node of another page, save it
-                # so that we can see if we need to parse normally skipped files.
-                $has_referred_to_node{$page} = 1;
-            }
+        $CFL_text{$addr} = "L<$CFL_text{$addr}>";
+        $in_CFL{$addr}--;
+        $running_CFL_text{$addr} .= $CFL_text{$addr} if ! $in_CFL{$addr};
+        return $self->SUPER::end_L(@_);
+    }
+
+    sub start_X {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $in_X{$addr} = 1;
+        return $self->SUPER::start_X(@_);
+    }
+
+    sub end_X {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $in_X{$addr} = 0;
+        return $self->SUPER::end_X(@_);
+    }
+
+    sub start_for {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $in_for{$addr} = 1;
+        return $self->SUPER::start_for(@_);
+    }
+
+    sub end_for {
+        my $self = shift;
+        my $addr = Scalar::Util::refaddr $self;
+
+        $in_for{$addr} = 0;
+        return $self->SUPER::end_for(@_);
+    }
+
+    sub hyperlink {
+        my ($self, $link) = @_;
+
+        if ($link && $link->type eq 'pod') {
+            my $page = $link->page;
+            my $node = $link->node;
+
+            # If the hyperlink is to an interior node of another page, save it
+            # so that we can see if we need to parse normally skipped files.
+            $has_referred_to_node{$page} = 1 if $node;
 
             # Ignore certain placeholder links in perldelta.  Check if the
             # link is page-level, and also check if to a node within the page
-            if ($self->name && $self->name eq "perldelta"
-                && ((grep { $page eq $_ } @perldelta_ignore_links)
-                    || ($node
+            if (   $self->name && $self->name eq "perldelta"
+                && ((  grep { $page eq $_ } @perldelta_ignore_links)
+                    || (   $node
                         && (grep { "$page/$node" eq $_ } @perldelta_ignore_links)
             ))) {
                 return;
             }
         }
-        return $self->SUPER::hyperlink($_[0]);
+
+        return $self->SUPER::hyperlink($link);
     }
 
     sub node {
@@ -1116,7 +1321,7 @@ package My::Pod::Checker {      # Extend Pod::Checker
         # ignores 2nd param, which is output file.  Always uses undef
 
         if (open my $in_fh, '<:bytes', $filename) {
-            $self->SUPER::parse_from_filehandle($in_fh, undef);
+            $self->SUPER::parse_from_file($in_fh, undef);
             close $in_fh;
             return 1;
         }
@@ -1322,6 +1527,7 @@ sub my_safer_print {    # print, with error checking for outputting to db
 sub extract_pod {   # Extracts just the pod from a file; returns undef if file
                     # doesn't exist
     my $filename = shift;
+    use Pod::Parser;
 
     my @pod;
 
@@ -1763,21 +1969,24 @@ foreach my $filename (@files) {
 if (! $has_input_files) {
     foreach my $filename (@files) {
         next if $filename_to_checker{$filename}->get_skip;
+
         my $checker = $filename_to_checker{$filename};
-        foreach my $link ($checker->hyperlink) {
-            my $linked_to_page = $link->[1]->page;
+        foreach my $link ($checker->hyperlinks()) {
+            my $linked_to_page = $link->page;
             next unless $linked_to_page;   # intra-file checks are handled by std
                                            # Pod::Checker
+            # Currently, we assume all external links are valid
+            next if $link->type eq 'url';
 
             # Initialize the potential message.
             my %problem = ( -msg => $broken_link,
-                            -line => $link->[0],
+                            -line => $link->line,
                             parameter => "to \"$linked_to_page\"",
                         );
 
             # See if we have found the linked-to_file in our parse
             if (exists $nodes{$linked_to_page}) {
-                my $node = $link->[1]->node;
+                my $node = $link->node;
 
                 # If link is only to the page-level, already have it
                 next if ! $node;
@@ -1801,7 +2010,7 @@ if (! $has_input_files) {
                 }
 
             } # Linked-to-file not in parse; maybe is in exception list
-            elsif (! exists $valid_modules{$link->[1]->page}) {
+            elsif (! exists $valid_modules{$link->page}) {
 
                 # Here, is a link to a target that we can't find.  Check if
                 # there is an internal link on the page with the target name.
@@ -2008,3 +2217,5 @@ if ($regen) {
     chdir $original_dir || die "Can't change directories to $original_dir";
     close_and_rename($copy_fh);
 }
+
+1;