Import perl-5.18.2

OK espie@ sthen@ deraadt@

38 files changed, 5785 insertions, 5775 deletions

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Find.pm b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Find.pm
index 028a405c79e..884062ff3a5 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Find.pm
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Find.pm
@@ -1,549 +1,549 @@
-#############################################################################  
-# Pod/Find.pm -- finds files containing POD documentation
-#
-# Author: Marek Rouchal <marekr@cpan.org>
-# 
-# Copyright (C) 1999-2000 by Marek Rouchal (and borrowing code
-# from Nick Ing-Simmon's PodToHtml). All rights reserved.
-# This file is part of "PodParser". Pod::Find is free software;
-# you can redistribute it and/or modify it under the same terms
-# as Perl itself.
-#############################################################################
-
-package Pod::Find;
-use strict;
-
-use vars qw($VERSION);
-$VERSION = '1.51';   ## Current version of this package
-require  5.005;   ## requires this Perl version or later
-use Carp;
-
-BEGIN {
-   if ($] < 5.006) {
-      require Symbol;
-      import Symbol;
-   }
-}
-
-#############################################################################
-
-=head1 NAME
-
-Pod::Find - find POD documents in directory trees
-
-=head1 SYNOPSIS
-
-  use Pod::Find qw(pod_find simplify_name);
-  my %pods = pod_find({ -verbose => 1, -inc => 1 });
-  foreach(keys %pods) {
-     print "found library POD `$pods{$_}' in $_\n";
-  }
-
-  print "podname=",simplify_name('a/b/c/mymodule.pod'),"\n";
-
-  $location = pod_where( { -inc => 1 }, "Pod::Find" );
-
-=head1 DESCRIPTION
-
-B<Pod::Find> provides a set of functions to locate POD files.  Note that
-no function is exported by default to avoid pollution of your namespace,
-so be sure to specify them in the B<use> statement if you need them:
-
-  use Pod::Find qw(pod_find);
-
-From this version on the typical SCM (software configuration management)
-files/directories like RCS, CVS, SCCS, .svn are ignored.
-
-=cut
-
-#use diagnostics;
-use Exporter;
-use File::Spec;
-use File::Find;
-use Cwd qw(abs_path cwd);
-
-use vars qw(@ISA @EXPORT_OK $VERSION);
-@ISA = qw(Exporter);
-@EXPORT_OK = qw(&pod_find &simplify_name &pod_where &contains_pod);
-
-# package global variables
-my $SIMPLIFY_RX;
-
-=head2 C<pod_find( { %opts } , @directories )>
-
-The function B<pod_find> searches for POD documents in a given set of
-files and/or directories. It returns a hash with the file names as keys
-and the POD name as value. The POD name is derived from the file name
-and its position in the directory tree.
-
-E.g. when searching in F<$HOME/perl5lib>, the file
-F<$HOME/perl5lib/MyModule.pm> would get the POD name I<MyModule>,
-whereas F<$HOME/perl5lib/Myclass/Subclass.pm> would be
-I<Myclass::Subclass>. The name information can be used for POD
-translators.
-
-Only text files containing at least one valid POD command are found.
-
-A warning is printed if more than one POD file with the same POD name
-is found, e.g. F<CPAN.pm> in different directories. This usually
-indicates duplicate occurrences of modules in the I<@INC> search path.
-
-B<OPTIONS> The first argument for B<pod_find> may be a hash reference
-with options. The rest are either directories that are searched
-recursively or files.  The POD names of files are the plain basenames
-with any Perl-like extension (.pm, .pl, .pod) stripped.
-
-=over 4
-
-=item C<-verbose =E<gt> 1>
-
-Print progress information while scanning.
-
-=item C<-perl =E<gt> 1>
-
-Apply Perl-specific heuristics to find the correct PODs. This includes
-stripping Perl-like extensions, omitting subdirectories that are numeric
-but do I<not> match the current Perl interpreter's version id, suppressing
-F<site_perl> as a module hierarchy name etc.
-
-=item C<-script =E<gt> 1>
-
-Search for PODs in the current Perl interpreter's installation 
-B<scriptdir>. This is taken from the local L<Config|Config> module.
-
-=item C<-inc =E<gt> 1>
-
-Search for PODs in the current Perl interpreter's I<@INC> paths. This
-automatically considers paths specified in the C<PERL5LIB> environment
-as this is included in I<@INC> by the Perl interpreter itself.
-
-=back
-
-=cut
-
-# return a hash of the POD files found
-# first argument may be a hashref (options),
-# rest is a list of directories to search recursively
-sub pod_find
-{
-    my %opts;
-    if(ref $_[0]) {
-        %opts = %{shift()};
-    }
-
-    $opts{-verbose} ||= 0;
-    $opts{-perl}    ||= 0;
-
-    my (@search) = @_;
-
-    if($opts{-script}) {
-        require Config;
-        push(@search, $Config::Config{scriptdir})
-            if -d $Config::Config{scriptdir};
-        $opts{-perl} = 1;
-    }
-
-    if($opts{-inc}) {
-        if ($^O eq 'MacOS') {
-            # tolerate '.', './some_dir' and '(../)+some_dir' on Mac OS
-            my @new_INC = @INC;
-            for (@new_INC) {
-                if ( $_ eq '.' ) {
-                    $_ = ':';
-                } elsif ( $_ =~ s{^((?:\.\./)+)}{':' x (length($1)/3)}e ) {
-                    $_ = ':'. $_;
-                } else {
-                    $_ =~ s{^\./}{:};
-                }
-            }
-            push(@search, grep($_ ne File::Spec->curdir, @new_INC));
-        } else {
-            my %seen;
-            my $curdir = File::Spec->curdir;
-	    foreach(@INC) {
-                next if $_ eq $curdir;
-		my $path = abs_path($_);
-                push(@search, $path) unless $seen{$path}++;
-            }
-        }
-
-        $opts{-perl} = 1;
-    }
-
-    if($opts{-perl}) {
-        require Config;
-        # this code simplifies the POD name for Perl modules:
-        # * remove "site_perl"
-        # * remove e.g. "i586-linux" (from 'archname')
-        # * remove e.g. 5.00503
-        # * remove pod/ if followed by *.pod (e.g. in pod/perlfunc.pod)
-
-        # Mac OS:
-        # * remove ":?site_perl:"
-        # * remove :?pod: if followed by *.pod (e.g. in :pod:perlfunc.pod)
-
-        if ($^O eq 'MacOS') {
-            $SIMPLIFY_RX =
-              qq!^(?i:\:?site_perl\:|\:?pod\:(?=.*?\\.pod\\z))*!;
-        } else {
-            $SIMPLIFY_RX =
-              qq!^(?i:site(_perl)?/|\Q$Config::Config{archname}\E/|\\d+\\.\\d+([_.]?\\d+)?/|pod/(?=.*?\\.pod\\z))*!;
-        }
-    }
-
-    my %dirs_visited;
-    my %pods;
-    my %names;
-    my $pwd = cwd();
-
-    foreach my $try (@search) {
-        unless(File::Spec->file_name_is_absolute($try)) {
-            # make path absolute
-            $try = File::Spec->catfile($pwd,$try);
-        }
-        # simplify path
-        # on VMS canonpath will vmsify:[the.path], but File::Find::find
-        # wants /unixy/paths
-        if ($^O eq 'VMS') {
-            $try = VMS::Filespec::unixify($try);
-        }
-        else {
-            $try = File::Spec->canonpath($try);
-        }
-        my $name;
-        if(-f $try) {
-            if($name = _check_and_extract_name($try, $opts{-verbose})) {
-                _check_for_duplicates($try, $name, \%names, \%pods);
-            }
-            next;
-        }
-        my $root_rx = $^O eq 'MacOS' ? qq!^\Q$try\E! : qq!^\Q$try\E/!;
-        $root_rx=~ s|//$|/|;  # remove trailing double slash
-        File::Find::find( sub {
-            my $item = $File::Find::name;
-            if(-d) {
-                if($item =~ m{/(?:RCS|CVS|SCCS|\.svn)$}) {
-                    $File::Find::prune = 1;
-                    return;
-                }
-                elsif($dirs_visited{$item}) {
-                    warn "Directory '$item' already seen, skipping.\n"
-                        if($opts{-verbose});
-                    $File::Find::prune = 1;
-                    return;
-                }
-                else {
-                    $dirs_visited{$item} = 1;
-                }
-                if($opts{-perl} && /^(\d+\.[\d_]+)\z/s && eval "$1" != $]) {
-                    $File::Find::prune = 1;
-                    warn "Perl $] version mismatch on $_, skipping.\n"
-                        if($opts{-verbose});
-                }
-                return;
-            }
-            if($name = _check_and_extract_name($item, $opts{-verbose}, $root_rx)) {
-                _check_for_duplicates($item, $name, \%names, \%pods);
-            }
-        }, $try); # end of File::Find::find
-    }
-    chdir $pwd;
-    return %pods;
-}
-
-sub _check_for_duplicates {
-    my ($file, $name, $names_ref, $pods_ref) = @_;
-    if($$names_ref{$name}) {
-        warn "Duplicate POD found (shadowing?): $name ($file)\n";
-        warn '    Already seen in ',
-            join(' ', grep($$pods_ref{$_} eq $name, keys %$pods_ref)),"\n";
-    }
-    else {
-        $$names_ref{$name} = 1;
-    }
-    return $$pods_ref{$file} = $name;
-}
-
-sub _check_and_extract_name {
-    my ($file, $verbose, $root_rx) = @_;
-
-    # check extension or executable flag
-    # this involves testing the .bat extension on Win32!
-    unless(-f $file && -T $file && ($file =~ /\.(pod|pm|plx?)\z/i || -x $file )) {
-      return;
-    }
-
-    return unless contains_pod($file,$verbose);
-
-    # strip non-significant path components
-    # TODO what happens on e.g. Win32?
-    my $name = $file;
-    if(defined $root_rx) {
-        $name =~ s/$root_rx//is;
-        $name =~ s/$SIMPLIFY_RX//is if(defined $SIMPLIFY_RX);
-    }
-    else {
-        if ($^O eq 'MacOS') {
-            $name =~ s/^.*://s;
-        } else {
-            $name =~ s{^.*/}{}s;
-        }
-    }
-    _simplify($name);
-    $name =~ s{/+}{::}g;
-    if ($^O eq 'MacOS') {
-        $name =~ s{:+}{::}g; # : -> ::
-    } else {
-        $name =~ s{/+}{::}g; # / -> ::
-    }
-    return $name;
-}
-
-=head2 C<simplify_name( $str )>
-
-The function B<simplify_name> is equivalent to B<basename>, but also
-strips Perl-like extensions (.pm, .pl, .pod) and extensions like
-F<.bat>, F<.cmd> on Win32 and OS/2, or F<.com> on VMS, respectively.
-
-=cut
-
-# basic simplification of the POD name:
-# basename & strip extension
-sub simplify_name {
-    my ($str) = @_;
-    # remove all path components
-    if ($^O eq 'MacOS') {
-        $str =~ s/^.*://s;
-    } else {
-        $str =~ s{^.*/}{}s;
-    }
-    _simplify($str);
-    return $str;
-}
-
-# internal sub only
-sub _simplify {
-    # strip Perl's own extensions
-    $_[0] =~ s/\.(pod|pm|plx?)\z//i;
-    # strip meaningless extensions on Win32 and OS/2
-    $_[0] =~ s/\.(bat|exe|cmd)\z//i if($^O =~ /mswin|os2/i);
-    # strip meaningless extensions on VMS
-    $_[0] =~ s/\.(com)\z//i if($^O eq 'VMS');
-}
-
-# contribution from Tim Jenness <t.jenness@jach.hawaii.edu>
-
-=head2 C<pod_where( { %opts }, $pod )>
-
-Returns the location of a pod document given a search directory
-and a module (e.g. C<File::Find>) or script (e.g. C<perldoc>) name.
-
-Options:
-
-=over 4
-
-=item C<-inc =E<gt> 1>
-
-Search @INC for the pod and also the C<scriptdir> defined in the
-L<Config|Config> module.
-
-=item C<-dirs =E<gt> [ $dir1, $dir2, ... ]>
-
-Reference to an array of search directories. These are searched in order
-before looking in C<@INC> (if B<-inc>). Current directory is used if
-none are specified.
-
-=item C<-verbose =E<gt> 1>
-
-List directories as they are searched
-
-=back
-
-Returns the full path of the first occurrence to the file.
-Package names (eg 'A::B') are automatically converted to directory
-names in the selected directory. (eg on unix 'A::B' is converted to
-'A/B'). Additionally, '.pm', '.pl' and '.pod' are appended to the
-search automatically if required.
-
-A subdirectory F<pod/> is also checked if it exists in any of the given
-search directories. This ensures that e.g. L<perlfunc|perlfunc> is
-found.
-
-It is assumed that if a module name is supplied, that that name
-matches the file name. Pods are not opened to check for the 'NAME'
-entry.
-
-A check is made to make sure that the file that is found does 
-contain some pod documentation.
-
-=cut
-
-sub pod_where {
-
-  # default options
-  my %options = (
-         '-inc' => 0,
-         '-verbose' => 0,
-         '-dirs' => [ File::Spec->curdir ],
-        );
-
-  # Check for an options hash as first argument
-  if (defined $_[0] && ref($_[0]) eq 'HASH') {
-    my $opt = shift;
-
-    # Merge default options with supplied options
-    %options = (%options, %$opt);
-  }
-
-  # Check usage
-  carp 'Usage: pod_where({options}, $pod)' unless (scalar(@_));
-
-  # Read argument
-  my $pod = shift;
-
-  # Split on :: and then join the name together using File::Spec
-  my @parts = split (/::/, $pod);
-
-  # Get full directory list
-  my @search_dirs = @{ $options{'-dirs'} };
-
-  if ($options{'-inc'}) {
-
-    require Config;
-
-    # Add @INC
-    if ($^O eq 'MacOS' && $options{'-inc'}) {
-        # tolerate '.', './some_dir' and '(../)+some_dir' on Mac OS
-        my @new_INC = @INC;
-        for (@new_INC) {
-            if ( $_ eq '.' ) {
-                $_ = ':';
-            } elsif ( $_ =~ s{^((?:\.\./)+)}{':' x (length($1)/3)}e ) {
-                $_ = ':'. $_;
-            } else {
-                $_ =~ s{^\./}{:};
-            }
-        }
-        push (@search_dirs, @new_INC);
-    } elsif ($options{'-inc'}) {
-        push (@search_dirs, @INC);
-    }
-
-    # Add location of pod documentation for perl man pages (eg perlfunc)
-    # This is a pod directory in the private install tree
-    #my $perlpoddir = File::Spec->catdir($Config::Config{'installprivlib'},
-    #					'pod');
-    #push (@search_dirs, $perlpoddir)
-    #  if -d $perlpoddir;
-
-    # Add location of binaries such as pod2text
-    push (@search_dirs, $Config::Config{'scriptdir'})
-      if -d $Config::Config{'scriptdir'};
-  }
-
-  warn 'Search path is: '.join(' ', @search_dirs)."\n"
-        if $options{'-verbose'};
-
-  # Loop over directories
-  Dir: foreach my $dir ( @search_dirs ) {
-
-    # Don't bother if can't find the directory
-    if (-d $dir) {
-      warn "Looking in directory $dir\n"
-        if $options{'-verbose'};
-
-      # Now concatenate this directory with the pod we are searching for
-      my $fullname = File::Spec->catfile($dir, @parts);
-      $fullname = VMS::Filespec::unixify($fullname) if $^O eq 'VMS';
-      warn "Filename is now $fullname\n"
-        if $options{'-verbose'};
-
-      # Loop over possible extensions
-      foreach my $ext ('', '.pod', '.pm', '.pl') {
-        my $fullext = $fullname . $ext;
-        if (-f $fullext &&
-         contains_pod($fullext, $options{'-verbose'}) ) {
-          warn "FOUND: $fullext\n" if $options{'-verbose'};
-          return $fullext;
-        }
-      }
-    } else {
-      warn "Directory $dir does not exist\n"
-        if $options{'-verbose'};
-      next Dir;
-    }
-    # for some strange reason the path on MacOS/darwin/cygwin is
-    # 'pods' not 'pod'
-    # this could be the case also for other systems that
-    # have a case-tolerant file system, but File::Spec
-    # does not recognize 'darwin' yet. And cygwin also has "pods",
-    # but is not case tolerant. Oh well...
-    if((File::Spec->case_tolerant || $^O =~ /macos|darwin|cygwin/i)
-     && -d File::Spec->catdir($dir,'pods')) {
-      $dir = File::Spec->catdir($dir,'pods');
-      redo Dir;
-    }
-    if(-d File::Spec->catdir($dir,'pod')) {
-      $dir = File::Spec->catdir($dir,'pod');
-      redo Dir;
-    }
-  }
-  # No match;
-  return;
-}
-
-=head2 C<contains_pod( $file , $verbose )>
-
-Returns true if the supplied filename (not POD module) contains some pod
-information.
-
-=cut
-
-sub contains_pod {
-  my $file = shift;
-  my $verbose = 0;
-  $verbose = shift if @_;
-
-  # check for one line of POD
-  my $podfh;
-  if ($] < 5.006) {
-    $podfh = gensym();
-  }
-
-  unless(open($podfh,"<$file")) {
-    warn "Error: $file is unreadable: $!\n";
-    return;
-  }
-  
-  local $/ = undef;
-  my $pod = <$podfh>;
-  close($podfh) || die "Error closing $file: $!\n";
-  unless($pod =~ /^=(head\d|pod|over|item|cut)\b/m) {
-    warn "No POD in $file, skipping.\n"
-      if($verbose);
-    return 0;
-  }
-
-  return 1;
-}
-
-=head1 AUTHOR
-
-Please report bugs using L<http://rt.cpan.org>.
-
-Marek Rouchal E<lt>marekr@cpan.orgE<gt>,
-heavily borrowing code from Nick Ing-Simmons' PodToHtml.
-
-Tim Jenness E<lt>t.jenness@jach.hawaii.eduE<gt> provided
-C<pod_where> and C<contains_pod>.
-
-B<Pod::Find> is part of the L<Pod::Parser> distribution.
-
-=head1 SEE ALSO
-
-L<Pod::Parser>, L<Pod::Checker>, L<perldoc>
-
-=cut
-
-1;
-
+#############################################################################  

+# Pod/Find.pm -- finds files containing POD documentation

+#

+# Author: Marek Rouchal <marekr@cpan.org>

+# 

+# Copyright (C) 1999-2000 by Marek Rouchal (and borrowing code

+# from Nick Ing-Simmon's PodToHtml). All rights reserved.

+# This file is part of "PodParser". Pod::Find is free software;

+# you can redistribute it and/or modify it under the same terms

+# as Perl itself.

+#############################################################################

+

+package Pod::Find;

+use strict;

+

+use vars qw($VERSION);

+$VERSION = '1.60';   ## Current version of this package

+require  5.005;   ## requires this Perl version or later

+use Carp;

+

+BEGIN {

+   if ($] < 5.006) {

+      require Symbol;

+      import Symbol;

+   }

+}

+

+#############################################################################

+

+=head1 NAME

+

+Pod::Find - find POD documents in directory trees

+

+=head1 SYNOPSIS

+

+  use Pod::Find qw(pod_find simplify_name);

+  my %pods = pod_find({ -verbose => 1, -inc => 1 });

+  foreach(keys %pods) {

+     print "found library POD `$pods{$_}' in $_\n";

+  }

+

+  print "podname=",simplify_name('a/b/c/mymodule.pod'),"\n";

+

+  $location = pod_where( { -inc => 1 }, "Pod::Find" );

+

+=head1 DESCRIPTION

+

+B<Pod::Find> provides a set of functions to locate POD files.  Note that

+no function is exported by default to avoid pollution of your namespace,

+so be sure to specify them in the B<use> statement if you need them:

+

+  use Pod::Find qw(pod_find);

+

+From this version on the typical SCM (software configuration management)

+files/directories like RCS, CVS, SCCS, .svn are ignored.

+

+=cut

+

+#use diagnostics;

+use Exporter;

+use File::Spec;

+use File::Find;

+use Cwd qw(abs_path cwd);

+

+use vars qw(@ISA @EXPORT_OK $VERSION);

+@ISA = qw(Exporter);

+@EXPORT_OK = qw(&pod_find &simplify_name &pod_where &contains_pod);

+

+# package global variables

+my $SIMPLIFY_RX;

+

+=head2 C<pod_find( { %opts } , @directories )>

+

+The function B<pod_find> searches for POD documents in a given set of

+files and/or directories. It returns a hash with the file names as keys

+and the POD name as value. The POD name is derived from the file name

+and its position in the directory tree.

+

+E.g. when searching in F<$HOME/perl5lib>, the file

+F<$HOME/perl5lib/MyModule.pm> would get the POD name I<MyModule>,

+whereas F<$HOME/perl5lib/Myclass/Subclass.pm> would be

+I<Myclass::Subclass>. The name information can be used for POD

+translators.

+

+Only text files containing at least one valid POD command are found.

+

+A warning is printed if more than one POD file with the same POD name

+is found, e.g. F<CPAN.pm> in different directories. This usually

+indicates duplicate occurrences of modules in the I<@INC> search path.

+

+B<OPTIONS> The first argument for B<pod_find> may be a hash reference

+with options. The rest are either directories that are searched

+recursively or files.  The POD names of files are the plain basenames

+with any Perl-like extension (.pm, .pl, .pod) stripped.

+

+=over 4

+

+=item C<-verbose =E<gt> 1>

+

+Print progress information while scanning.

+

+=item C<-perl =E<gt> 1>

+

+Apply Perl-specific heuristics to find the correct PODs. This includes

+stripping Perl-like extensions, omitting subdirectories that are numeric

+but do I<not> match the current Perl interpreter's version id, suppressing

+F<site_perl> as a module hierarchy name etc.

+

+=item C<-script =E<gt> 1>

+

+Search for PODs in the current Perl interpreter's installation 

+B<scriptdir>. This is taken from the local L<Config|Config> module.

+

+=item C<-inc =E<gt> 1>

+

+Search for PODs in the current Perl interpreter's I<@INC> paths. This

+automatically considers paths specified in the C<PERL5LIB> environment

+as this is included in I<@INC> by the Perl interpreter itself.

+

+=back

+

+=cut

+

+# return a hash of the POD files found

+# first argument may be a hashref (options),

+# rest is a list of directories to search recursively

+sub pod_find

+{

+    my %opts;

+    if(ref $_[0]) {

+        %opts = %{shift()};

+    }

+

+    $opts{-verbose} ||= 0;

+    $opts{-perl}    ||= 0;

+

+    my (@search) = @_;

+

+    if($opts{-script}) {

+        require Config;

+        push(@search, $Config::Config{scriptdir})

+            if -d $Config::Config{scriptdir};

+        $opts{-perl} = 1;

+    }

+

+    if($opts{-inc}) {

+        if ($^O eq 'MacOS') {

+            # tolerate '.', './some_dir' and '(../)+some_dir' on Mac OS

+            my @new_INC = @INC;

+            for (@new_INC) {

+                if ( $_ eq '.' ) {

+                    $_ = ':';

+                } elsif ( $_ =~ s{^((?:\.\./)+)}{':' x (length($1)/3)}e ) {

+                    $_ = ':'. $_;

+                } else {

+                    $_ =~ s{^\./}{:};

+                }

+            }

+            push(@search, grep($_ ne File::Spec->curdir, @new_INC));

+        } else {

+            my %seen;

+            my $curdir = File::Spec->curdir;

+	    foreach(@INC) {

+                next if $_ eq $curdir;

+		my $path = abs_path($_);

+                push(@search, $path) unless $seen{$path}++;

+            }

+        }

+

+        $opts{-perl} = 1;

+    }

+

+    if($opts{-perl}) {

+        require Config;

+        # this code simplifies the POD name for Perl modules:

+        # * remove "site_perl"

+        # * remove e.g. "i586-linux" (from 'archname')

+        # * remove e.g. 5.00503

+        # * remove pod/ if followed by *.pod (e.g. in pod/perlfunc.pod)

+

+        # Mac OS:

+        # * remove ":?site_perl:"

+        # * remove :?pod: if followed by *.pod (e.g. in :pod:perlfunc.pod)

+

+        if ($^O eq 'MacOS') {

+            $SIMPLIFY_RX =

+              qq!^(?i:\:?site_perl\:|\:?pod\:(?=.*?\\.pod\\z))*!;

+        } else {

+            $SIMPLIFY_RX =

+              qq!^(?i:site(_perl)?/|\Q$Config::Config{archname}\E/|\\d+\\.\\d+([_.]?\\d+)?/|pod/(?=.*?\\.pod\\z))*!;

+        }

+    }

+

+    my %dirs_visited;

+    my %pods;

+    my %names;

+    my $pwd = cwd();

+

+    foreach my $try (@search) {

+        unless(File::Spec->file_name_is_absolute($try)) {

+            # make path absolute

+            $try = File::Spec->catfile($pwd,$try);

+        }

+        # simplify path

+        # on VMS canonpath will vmsify:[the.path], but File::Find::find

+        # wants /unixy/paths

+        if ($^O eq 'VMS') {

+            $try = VMS::Filespec::unixify($try);

+        }

+        else {

+            $try = File::Spec->canonpath($try);

+        }

+        my $name;

+        if(-f $try) {

+            if($name = _check_and_extract_name($try, $opts{-verbose})) {

+                _check_for_duplicates($try, $name, \%names, \%pods);

+            }

+            next;

+        }

+        my $root_rx = $^O eq 'MacOS' ? qq!^\Q$try\E! : qq!^\Q$try\E/!;

+        $root_rx=~ s|//$|/|;  # remove trailing double slash

+        File::Find::find( sub {

+            my $item = $File::Find::name;

+            if(-d) {

+                if($item =~ m{/(?:RCS|CVS|SCCS|\.svn)$}) {

+                    $File::Find::prune = 1;

+                    return;

+                }

+                elsif($dirs_visited{$item}) {

+                    warn "Directory '$item' already seen, skipping.\n"

+                        if($opts{-verbose});

+                    $File::Find::prune = 1;

+                    return;

+                }

+                else {

+                    $dirs_visited{$item} = 1;

+                }

+                if($opts{-perl} && /^(\d+\.[\d_]+)\z/s && eval "$1" != $]) {

+                    $File::Find::prune = 1;

+                    warn "Perl $] version mismatch on $_, skipping.\n"

+                        if($opts{-verbose});

+                }

+                return;

+            }

+            if($name = _check_and_extract_name($item, $opts{-verbose}, $root_rx)) {

+                _check_for_duplicates($item, $name, \%names, \%pods);

+            }

+        }, $try); # end of File::Find::find

+    }

+    chdir $pwd;

+    return %pods;

+}

+

+sub _check_for_duplicates {

+    my ($file, $name, $names_ref, $pods_ref) = @_;

+    if($$names_ref{$name}) {

+        warn "Duplicate POD found (shadowing?): $name ($file)\n";

+        warn '    Already seen in ',

+            join(' ', grep($$pods_ref{$_} eq $name, keys %$pods_ref)),"\n";

+    }

+    else {

+        $$names_ref{$name} = 1;

+    }

+    return $$pods_ref{$file} = $name;

+}

+

+sub _check_and_extract_name {

+    my ($file, $verbose, $root_rx) = @_;

+

+    # check extension or executable flag

+    # this involves testing the .bat extension on Win32!

+    unless(-f $file && -T $file && ($file =~ /\.(pod|pm|plx?)\z/i || -x $file )) {

+      return;

+    }

+

+    return unless contains_pod($file,$verbose);

+

+    # strip non-significant path components

+    # TODO what happens on e.g. Win32?

+    my $name = $file;

+    if(defined $root_rx) {

+        $name =~ s/$root_rx//is;

+        $name =~ s/$SIMPLIFY_RX//is if(defined $SIMPLIFY_RX);

+    }

+    else {

+        if ($^O eq 'MacOS') {

+            $name =~ s/^.*://s;

+        } else {

+            $name =~ s{^.*/}{}s;

+        }

+    }

+    _simplify($name);

+    $name =~ s{/+}{::}g;

+    if ($^O eq 'MacOS') {

+        $name =~ s{:+}{::}g; # : -> ::

+    } else {

+        $name =~ s{/+}{::}g; # / -> ::

+    }

+    return $name;

+}

+

+=head2 C<simplify_name( $str )>

+

+The function B<simplify_name> is equivalent to B<basename>, but also

+strips Perl-like extensions (.pm, .pl, .pod) and extensions like

+F<.bat>, F<.cmd> on Win32 and OS/2, or F<.com> on VMS, respectively.

+

+=cut

+

+# basic simplification of the POD name:

+# basename & strip extension

+sub simplify_name {

+    my ($str) = @_;

+    # remove all path components

+    if ($^O eq 'MacOS') {

+        $str =~ s/^.*://s;

+    } else {

+        $str =~ s{^.*/}{}s;

+    }

+    _simplify($str);

+    return $str;

+}

+

+# internal sub only

+sub _simplify {

+    # strip Perl's own extensions

+    $_[0] =~ s/\.(pod|pm|plx?)\z//i;

+    # strip meaningless extensions on Win32 and OS/2

+    $_[0] =~ s/\.(bat|exe|cmd)\z//i if($^O =~ /mswin|os2/i);

+    # strip meaningless extensions on VMS

+    $_[0] =~ s/\.(com)\z//i if($^O eq 'VMS');

+}

+

+# contribution from Tim Jenness <t.jenness@jach.hawaii.edu>

+

+=head2 C<pod_where( { %opts }, $pod )>

+

+Returns the location of a pod document given a search directory

+and a module (e.g. C<File::Find>) or script (e.g. C<perldoc>) name.

+

+Options:

+

+=over 4

+

+=item C<-inc =E<gt> 1>

+

+Search @INC for the pod and also the C<scriptdir> defined in the

+L<Config|Config> module.

+

+=item C<-dirs =E<gt> [ $dir1, $dir2, ... ]>

+

+Reference to an array of search directories. These are searched in order

+before looking in C<@INC> (if B<-inc>). Current directory is used if

+none are specified.

+

+=item C<-verbose =E<gt> 1>

+

+List directories as they are searched

+

+=back

+

+Returns the full path of the first occurrence to the file.

+Package names (eg 'A::B') are automatically converted to directory

+names in the selected directory. (eg on unix 'A::B' is converted to

+'A/B'). Additionally, '.pm', '.pl' and '.pod' are appended to the

+search automatically if required.

+

+A subdirectory F<pod/> is also checked if it exists in any of the given

+search directories. This ensures that e.g. L<perlfunc|perlfunc> is

+found.

+

+It is assumed that if a module name is supplied, that that name

+matches the file name. Pods are not opened to check for the 'NAME'

+entry.

+

+A check is made to make sure that the file that is found does 

+contain some pod documentation.

+

+=cut

+

+sub pod_where {

+

+  # default options

+  my %options = (

+         '-inc' => 0,

+         '-verbose' => 0,

+         '-dirs' => [ File::Spec->curdir ],

+        );

+

+  # Check for an options hash as first argument

+  if (defined $_[0] && ref($_[0]) eq 'HASH') {

+    my $opt = shift;

+

+    # Merge default options with supplied options

+    %options = (%options, %$opt);

+  }

+

+  # Check usage

+  carp 'Usage: pod_where({options}, $pod)' unless (scalar(@_));

+

+  # Read argument

+  my $pod = shift;

+

+  # Split on :: and then join the name together using File::Spec

+  my @parts = split (/::/, $pod);

+

+  # Get full directory list

+  my @search_dirs = @{ $options{'-dirs'} };

+

+  if ($options{'-inc'}) {

+

+    require Config;

+

+    # Add @INC

+    if ($^O eq 'MacOS' && $options{'-inc'}) {

+        # tolerate '.', './some_dir' and '(../)+some_dir' on Mac OS

+        my @new_INC = @INC;

+        for (@new_INC) {

+            if ( $_ eq '.' ) {

+                $_ = ':';

+            } elsif ( $_ =~ s{^((?:\.\./)+)}{':' x (length($1)/3)}e ) {

+                $_ = ':'. $_;

+            } else {

+                $_ =~ s{^\./}{:};

+            }

+        }

+        push (@search_dirs, @new_INC);

+    } elsif ($options{'-inc'}) {

+        push (@search_dirs, @INC);

+    }

+

+    # Add location of pod documentation for perl man pages (eg perlfunc)

+    # This is a pod directory in the private install tree

+    #my $perlpoddir = File::Spec->catdir($Config::Config{'installprivlib'},

+    #					'pod');

+    #push (@search_dirs, $perlpoddir)

+    #  if -d $perlpoddir;

+

+    # Add location of binaries such as pod2text

+    push (@search_dirs, $Config::Config{'scriptdir'})

+      if -d $Config::Config{'scriptdir'};

+  }

+

+  warn 'Search path is: '.join(' ', @search_dirs)."\n"

+        if $options{'-verbose'};

+

+  # Loop over directories

+  Dir: foreach my $dir ( @search_dirs ) {

+

+    # Don't bother if can't find the directory

+    if (-d $dir) {

+      warn "Looking in directory $dir\n"

+        if $options{'-verbose'};

+

+      # Now concatenate this directory with the pod we are searching for

+      my $fullname = File::Spec->catfile($dir, @parts);

+      $fullname = VMS::Filespec::unixify($fullname) if $^O eq 'VMS';

+      warn "Filename is now $fullname\n"

+        if $options{'-verbose'};

+

+      # Loop over possible extensions

+      foreach my $ext ('', '.pod', '.pm', '.pl') {

+        my $fullext = $fullname . $ext;

+        if (-f $fullext &&

+         contains_pod($fullext, $options{'-verbose'}) ) {

+          warn "FOUND: $fullext\n" if $options{'-verbose'};

+          return $fullext;

+        }

+      }

+    } else {

+      warn "Directory $dir does not exist\n"

+        if $options{'-verbose'};

+      next Dir;

+    }

+    # for some strange reason the path on MacOS/darwin/cygwin is

+    # 'pods' not 'pod'

+    # this could be the case also for other systems that

+    # have a case-tolerant file system, but File::Spec

+    # does not recognize 'darwin' yet. And cygwin also has "pods",

+    # but is not case tolerant. Oh well...

+    if((File::Spec->case_tolerant || $^O =~ /macos|darwin|cygwin/i)

+     && -d File::Spec->catdir($dir,'pods')) {

+      $dir = File::Spec->catdir($dir,'pods');

+      redo Dir;

+    }

+    if(-d File::Spec->catdir($dir,'pod')) {

+      $dir = File::Spec->catdir($dir,'pod');

+      redo Dir;

+    }

+  }

+  # No match;

+  return;

+}

+

+=head2 C<contains_pod( $file , $verbose )>

+

+Returns true if the supplied filename (not POD module) contains some pod

+information.

+

+=cut

+

+sub contains_pod {

+  my $file = shift;

+  my $verbose = 0;

+  $verbose = shift if @_;

+

+  # check for one line of POD

+  my $podfh;

+  if ($] < 5.006) {

+    $podfh = gensym();

+  }

+

+  unless(open($podfh,"<$file")) {

+    warn "Error: $file is unreadable: $!\n";

+    return;

+  }

+  

+  local $/ = undef;

+  my $pod = <$podfh>;

+  close($podfh) || die "Error closing $file: $!\n";

+  unless($pod =~ /^=(head\d|pod|over|item|cut)\b/m) {

+    warn "No POD in $file, skipping.\n"

+      if($verbose);

+    return 0;

+  }

+

+  return 1;

+}

+

+=head1 AUTHOR

+

+Please report bugs using L<http://rt.cpan.org>.

+

+Marek Rouchal E<lt>marekr@cpan.orgE<gt>,

+heavily borrowing code from Nick Ing-Simmons' PodToHtml.

+

+Tim Jenness E<lt>t.jenness@jach.hawaii.eduE<gt> provided

+C<pod_where> and C<contains_pod>.

+

+B<Pod::Find> is part of the L<Pod::Parser> distribution.

+

+=head1 SEE ALSO

+

+L<Pod::Parser>, L<Pod::Checker>, L<perldoc>

+

+=cut

+

+1;

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/InputObjects.pm b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/InputObjects.pm
index 2ed71fa2551..c19d4c550bd 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/InputObjects.pm
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/InputObjects.pm
@@ -1,942 +1,942 @@
-#############################################################################
-# Pod/InputObjects.pm -- package which defines objects for input streams
-# and paragraphs and commands when parsing POD docs.
-#
-# Copyright (C) 1996-2000 by Bradford Appleton. All rights reserved.
-# This file is part of "PodParser". PodParser is free software;
-# you can redistribute it and/or modify it under the same terms
-# as Perl itself.
-#############################################################################
-
-package Pod::InputObjects;
-use strict;
-
-use vars qw($VERSION);
-$VERSION = '1.51';  ## Current version of this package
-require  5.005;    ## requires this Perl version or later
-
-#############################################################################
-
-=head1 NAME
-
-Pod::InputObjects - objects representing POD input paragraphs, commands, etc.
-
-=head1 SYNOPSIS
-
-    use Pod::InputObjects;
-
-=head1 REQUIRES
-
-perl5.004, Carp
-
-=head1 EXPORTS
-
-Nothing.
-
-=head1 DESCRIPTION
-
-This module defines some basic input objects used by B<Pod::Parser> when
-reading and parsing POD text from an input source. The following objects
-are defined:
-
-=begin __PRIVATE__
-
-=over 4
-
-=item package B<Pod::InputSource>
-
-An object corresponding to a source of POD input text. It is mostly a
-wrapper around a filehandle or C<IO::Handle>-type object (or anything
-that implements the C<getline()> method) which keeps track of some
-additional information relevant to the parsing of PODs.
-
-=back
-
-=end __PRIVATE__
-
-=over 4
-
-=item package B<Pod::Paragraph>
-
-An object corresponding to a paragraph of POD input text. It may be a
-plain paragraph, a verbatim paragraph, or a command paragraph (see
-L<perlpod>).
-
-=item package B<Pod::InteriorSequence>
-
-An object corresponding to an interior sequence command from the POD
-input text (see L<perlpod>).
-
-=item package B<Pod::ParseTree>
-
-An object corresponding to a tree of parsed POD text. Each "node" in
-a parse-tree (or I<ptree>) is either a text-string or a reference to
-a B<Pod::InteriorSequence> object. The nodes appear in the parse-tree
-in the order in which they were parsed from left-to-right.
-
-=back
-
-Each of these input objects are described in further detail in the
-sections which follow.
-
-=cut
-
-#############################################################################
-
-package Pod::InputSource;
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head1 B<Pod::InputSource>
-
-This object corresponds to an input source or stream of POD
-documentation. When parsing PODs, it is necessary to associate and store
-certain context information with each input source. All of this
-information is kept together with the stream itself in one of these
-C<Pod::InputSource> objects. Each such object is merely a wrapper around
-an C<IO::Handle> object of some kind (or at least something that
-implements the C<getline()> method). They have the following
-methods/attributes:
-
-=end __PRIVATE__
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head2 B<new()>
-
-        my $pod_input1 = Pod::InputSource->new(-handle => $filehandle);
-        my $pod_input2 = new Pod::InputSource(-handle => $filehandle,
-                                              -name   => $name);
-        my $pod_input3 = new Pod::InputSource(-handle => \*STDIN);
-        my $pod_input4 = Pod::InputSource->new(-handle => \*STDIN,
-                                               -name => "(STDIN)");
-
-This is a class method that constructs a C<Pod::InputSource> object and
-returns a reference to the new input source object. It takes one or more
-keyword arguments in the form of a hash. The keyword C<-handle> is
-required and designates the corresponding input handle. The keyword
-C<-name> is optional and specifies the name associated with the input
-handle (typically a file name).
-
-=end __PRIVATE__
-
-=cut
-
-sub new {
-    ## Determine if we were called via an object-ref or a classname
-    my $this = shift;
-    my $class = ref($this) || $this;
-
-    ## Any remaining arguments are treated as initial values for the
-    ## hash that is used to represent this object. Note that we default
-    ## certain values by specifying them *before* the arguments passed.
-    ## If they are in the argument list, they will override the defaults.
-    my $self = { -name        => '(unknown)',
-                 -handle      => undef,
-                 -was_cutting => 0,
-                 @_ };
-
-    ## Bless ourselves into the desired class and perform any initialization
-    bless $self, $class;
-    return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head2 B<name()>
-
-        my $filename = $pod_input->name();
-        $pod_input->name($new_filename_to_use);
-
-This method gets/sets the name of the input source (usually a filename).
-If no argument is given, it returns a string containing the name of
-the input source; otherwise it sets the name of the input source to the
-contents of the given argument.
-
-=end __PRIVATE__
-
-=cut
-
-sub name {
-   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];
-   return $_[0]->{'-name'};
-}
-
-## allow 'filename' as an alias for 'name'
-*filename = \&name;
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head2 B<handle()>
-
-        my $handle = $pod_input->handle();
-
-Returns a reference to the handle object from which input is read (the
-one used to contructed this input source object).
-
-=end __PRIVATE__
-
-=cut
-
-sub handle {
-   return $_[0]->{'-handle'};
-}
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head2 B<was_cutting()>
-
-        print "Yes.\n" if ($pod_input->was_cutting());
-
-The value of the C<cutting> state (that the B<cutting()> method would
-have returned) immediately before any input was read from this input
-stream. After all input from this stream has been read, the C<cutting>
-state is restored to this value.
-
-=end __PRIVATE__
-
-=cut
-
-sub was_cutting {
-   (@_ > 1)  and  $_[0]->{-was_cutting} = $_[1];
-   return $_[0]->{-was_cutting};
-}
-
-##---------------------------------------------------------------------------
-
-#############################################################################
-
-package Pod::Paragraph;
-
-##---------------------------------------------------------------------------
-
-=head1 B<Pod::Paragraph>
-
-An object representing a paragraph of POD input text.
-It has the following methods/attributes:
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head2 Pod::Paragraph-E<gt>B<new()>
-
-        my $pod_para1 = Pod::Paragraph->new(-text => $text);
-        my $pod_para2 = Pod::Paragraph->new(-name => $cmd,
-                                            -text => $text);
-        my $pod_para3 = new Pod::Paragraph(-text => $text);
-        my $pod_para4 = new Pod::Paragraph(-name => $cmd,
-                                           -text => $text);
-        my $pod_para5 = Pod::Paragraph->new(-name => $cmd,
-                                            -text => $text,
-                                            -file => $filename,
-                                            -line => $line_number);
-
-This is a class method that constructs a C<Pod::Paragraph> object and
-returns a reference to the new paragraph object. It may be given one or
-two keyword arguments. The C<-text> keyword indicates the corresponding
-text of the POD paragraph. The C<-name> keyword indicates the name of
-the corresponding POD command, such as C<head1> or C<item> (it should
-I<not> contain the C<=> prefix); this is needed only if the POD
-paragraph corresponds to a command paragraph. The C<-file> and C<-line>
-keywords indicate the filename and line number corresponding to the
-beginning of the paragraph 
-
-=cut
-
-sub new {
-    ## Determine if we were called via an object-ref or a classname
-    my $this = shift;
-    my $class = ref($this) || $this;
-
-    ## Any remaining arguments are treated as initial values for the
-    ## hash that is used to represent this object. Note that we default
-    ## certain values by specifying them *before* the arguments passed.
-    ## If they are in the argument list, they will override the defaults.
-    my $self = {
-          -name       => undef,
-          -text       => (@_ == 1) ? shift : undef,
-          -file       => '<unknown-file>',
-          -line       => 0,
-          -prefix     => '=',
-          -separator  => ' ',
-          -ptree => [],
-          @_
-    };
-
-    ## Bless ourselves into the desired class and perform any initialization
-    bless $self, $class;
-    return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<cmd_name()>
-
-        my $para_cmd = $pod_para->cmd_name();
-
-If this paragraph is a command paragraph, then this method will return 
-the name of the command (I<without> any leading C<=> prefix).
-
-=cut
-
-sub cmd_name {
-   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];
-   return $_[0]->{'-name'};
-}
-
-## let name() be an alias for cmd_name()
-*name = \&cmd_name;
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<text()>
-
-        my $para_text = $pod_para->text();
-
-This method will return the corresponding text of the paragraph.
-
-=cut
-
-sub text {
-   (@_ > 1)  and  $_[0]->{'-text'} = $_[1];
-   return $_[0]->{'-text'};
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<raw_text()>
-
-        my $raw_pod_para = $pod_para->raw_text();
-
-This method will return the I<raw> text of the POD paragraph, exactly
-as it appeared in the input.
-
-=cut
-
-sub raw_text {
-   return $_[0]->{'-text'}  unless (defined $_[0]->{'-name'});
-   return $_[0]->{'-prefix'} . $_[0]->{'-name'} .
-          $_[0]->{'-separator'} . $_[0]->{'-text'};
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<cmd_prefix()>
-
-        my $prefix = $pod_para->cmd_prefix();
-
-If this paragraph is a command paragraph, then this method will return 
-the prefix used to denote the command (which should be the string "="
-or "==").
-
-=cut
-
-sub cmd_prefix {
-   return $_[0]->{'-prefix'};
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<cmd_separator()>
-
-        my $separator = $pod_para->cmd_separator();
-
-If this paragraph is a command paragraph, then this method will return
-the text used to separate the command name from the rest of the
-paragraph (if any).
-
-=cut
-
-sub cmd_separator {
-   return $_[0]->{'-separator'};
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<parse_tree()>
-
-        my $ptree = $pod_parser->parse_text( $pod_para->text() );
-        $pod_para->parse_tree( $ptree );
-        $ptree = $pod_para->parse_tree();
-
-This method will get/set the corresponding parse-tree of the paragraph's text.
-
-=cut
-
-sub parse_tree {
-   (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];
-   return $_[0]->{'-ptree'};
-}
-
-## let ptree() be an alias for parse_tree()
-*ptree = \&parse_tree;
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_para-E<gt>B<file_line()>
-
-        my ($filename, $line_number) = $pod_para->file_line();
-        my $position = $pod_para->file_line();
-
-Returns the current filename and line number for the paragraph
-object.  If called in a list context, it returns a list of two
-elements: first the filename, then the line number. If called in
-a scalar context, it returns a string containing the filename, followed
-by a colon (':'), followed by the line number.
-
-=cut
-
-sub file_line {
-   my @loc = ($_[0]->{'-file'} || '<unknown-file>',
-              $_[0]->{'-line'} || 0);
-   return (wantarray) ? @loc : join(':', @loc);
-}
-
-##---------------------------------------------------------------------------
-
-#############################################################################
-
-package Pod::InteriorSequence;
-
-##---------------------------------------------------------------------------
-
-=head1 B<Pod::InteriorSequence>
-
-An object representing a POD interior sequence command.
-It has the following methods/attributes:
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head2 Pod::InteriorSequence-E<gt>B<new()>
-
-        my $pod_seq1 = Pod::InteriorSequence->new(-name => $cmd
-                                                  -ldelim => $delimiter);
-        my $pod_seq2 = new Pod::InteriorSequence(-name => $cmd,
-                                                 -ldelim => $delimiter);
-        my $pod_seq3 = new Pod::InteriorSequence(-name => $cmd,
-                                                 -ldelim => $delimiter,
-                                                 -file => $filename,
-                                                 -line => $line_number);
-
-        my $pod_seq4 = new Pod::InteriorSequence(-name => $cmd, $ptree);
-        my $pod_seq5 = new Pod::InteriorSequence($cmd, $ptree);
-
-This is a class method that constructs a C<Pod::InteriorSequence> object
-and returns a reference to the new interior sequence object. It should
-be given two keyword arguments.  The C<-ldelim> keyword indicates the
-corresponding left-delimiter of the interior sequence (e.g. 'E<lt>').
-The C<-name> keyword indicates the name of the corresponding interior
-sequence command, such as C<I> or C<B> or C<C>. The C<-file> and
-C<-line> keywords indicate the filename and line number corresponding
-to the beginning of the interior sequence. If the C<$ptree> argument is
-given, it must be the last argument, and it must be either string, or
-else an array-ref suitable for passing to B<Pod::ParseTree::new> (or
-it may be a reference to a Pod::ParseTree object).
-
-=cut
-
-sub new {
-    ## Determine if we were called via an object-ref or a classname
-    my $this = shift;
-    my $class = ref($this) || $this;
-
-    ## See if first argument has no keyword
-    if (((@_ <= 2) or (@_ % 2)) and $_[0] !~ /^-\w/) {
-       ## Yup - need an implicit '-name' before first parameter
-       unshift @_, '-name';
-    }
-
-    ## See if odd number of args
-    if ((@_ % 2) != 0) {
-       ## Yup - need an implicit '-ptree' before the last parameter
-       splice @_, $#_, 0, '-ptree';
-    }
-
-    ## Any remaining arguments are treated as initial values for the
-    ## hash that is used to represent this object. Note that we default
-    ## certain values by specifying them *before* the arguments passed.
-    ## If they are in the argument list, they will override the defaults.
-    my $self = {
-          -name       => (@_ == 1) ? $_[0] : undef,
-          -file       => '<unknown-file>',
-          -line       => 0,
-          -ldelim     => '<',
-          -rdelim     => '>',
-          @_
-    };
-
-    ## Initialize contents if they havent been already
-    my $ptree = $self->{'-ptree'} || new Pod::ParseTree();
-    if ( ref $ptree =~ /^(ARRAY)?$/ ) {
-        ## We have an array-ref, or a normal scalar. Pass it as an
-        ## an argument to the ptree-constructor
-        $ptree = new Pod::ParseTree($1 ? [$ptree] : $ptree);
-    }
-    $self->{'-ptree'} = $ptree;
-
-    ## Bless ourselves into the desired class and perform any initialization
-    bless $self, $class;
-    return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<cmd_name()>
-
-        my $seq_cmd = $pod_seq->cmd_name();
-
-The name of the interior sequence command.
-
-=cut
-
-sub cmd_name {
-   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];
-   return $_[0]->{'-name'};
-}
-
-## let name() be an alias for cmd_name()
-*name = \&cmd_name;
-
-##---------------------------------------------------------------------------
-
-## Private subroutine to set the parent pointer of all the given
-## children that are interior-sequences to be $self
-
-sub _set_child2parent_links {
-   my ($self, @children) = @_;
-   ## Make sure any sequences know who their parent is
-   for (@children) {
-      next  unless (length  and  ref  and  ref ne 'SCALAR');
-      if (UNIVERSAL::isa($_, 'Pod::InteriorSequence') or
-          UNIVERSAL::can($_, 'nested'))
-      {
-          $_->nested($self);
-      }
-   }
-}
-
-## Private subroutine to unset child->parent links
-
-sub _unset_child2parent_links {
-   my $self = shift;
-   $self->{'-parent_sequence'} = undef;
-   my $ptree = $self->{'-ptree'};
-   for (@$ptree) {
-      next  unless (length  and  ref  and  ref ne 'SCALAR');
-      $_->_unset_child2parent_links()
-          if UNIVERSAL::isa($_, 'Pod::InteriorSequence');
-   }
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<prepend()>
-
-        $pod_seq->prepend($text);
-        $pod_seq1->prepend($pod_seq2);
-
-Prepends the given string or parse-tree or sequence object to the parse-tree
-of this interior sequence.
-
-=cut
-
-sub prepend {
-   my $self  = shift;
-   $self->{'-ptree'}->prepend(@_);
-   _set_child2parent_links($self, @_);
-   return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<append()>
-
-        $pod_seq->append($text);
-        $pod_seq1->append($pod_seq2);
-
-Appends the given string or parse-tree or sequence object to the parse-tree
-of this interior sequence.
-
-=cut
-
-sub append {
-   my $self = shift;
-   $self->{'-ptree'}->append(@_);
-   _set_child2parent_links($self, @_);
-   return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<nested()>
-
-        $outer_seq = $pod_seq->nested || print "not nested";
-
-If this interior sequence is nested inside of another interior
-sequence, then the outer/parent sequence that contains it is
-returned. Otherwise C<undef> is returned.
-
-=cut
-
-sub nested {
-   my $self = shift;
-  (@_ == 1)  and  $self->{'-parent_sequence'} = shift;
-   return  $self->{'-parent_sequence'} || undef;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<raw_text()>
-
-        my $seq_raw_text = $pod_seq->raw_text();
-
-This method will return the I<raw> text of the POD interior sequence,
-exactly as it appeared in the input.
-
-=cut
-
-sub raw_text {
-   my $self = shift;
-   my $text = $self->{'-name'} . $self->{'-ldelim'};
-   for ( $self->{'-ptree'}->children ) {
-      $text .= (ref $_) ? $_->raw_text : $_;
-   }
-   $text .= $self->{'-rdelim'};
-   return $text;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<left_delimiter()>
-
-        my $ldelim = $pod_seq->left_delimiter();
-
-The leftmost delimiter beginning the argument text to the interior
-sequence (should be "<").
-
-=cut
-
-sub left_delimiter {
-   (@_ > 1)  and  $_[0]->{'-ldelim'} = $_[1];
-   return $_[0]->{'-ldelim'};
-}
-
-## let ldelim() be an alias for left_delimiter()
-*ldelim = \&left_delimiter;
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<right_delimiter()>
-
-The rightmost delimiter beginning the argument text to the interior
-sequence (should be ">").
-
-=cut
-
-sub right_delimiter {
-   (@_ > 1)  and  $_[0]->{'-rdelim'} = $_[1];
-   return $_[0]->{'-rdelim'};
-}
-
-## let rdelim() be an alias for right_delimiter()
-*rdelim = \&right_delimiter;
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<parse_tree()>
-
-        my $ptree = $pod_parser->parse_text($paragraph_text);
-        $pod_seq->parse_tree( $ptree );
-        $ptree = $pod_seq->parse_tree();
-
-This method will get/set the corresponding parse-tree of the interior
-sequence's text.
-
-=cut
-
-sub parse_tree {
-   (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];
-   return $_[0]->{'-ptree'};
-}
-
-## let ptree() be an alias for parse_tree()
-*ptree = \&parse_tree;
-
-##---------------------------------------------------------------------------
-
-=head2 $pod_seq-E<gt>B<file_line()>
-
-        my ($filename, $line_number) = $pod_seq->file_line();
-        my $position = $pod_seq->file_line();
-
-Returns the current filename and line number for the interior sequence
-object.  If called in a list context, it returns a list of two
-elements: first the filename, then the line number. If called in
-a scalar context, it returns a string containing the filename, followed
-by a colon (':'), followed by the line number.
-
-=cut
-
-sub file_line {
-   my @loc = ($_[0]->{'-file'}  || '<unknown-file>',
-              $_[0]->{'-line'}  || 0);
-   return (wantarray) ? @loc : join(':', @loc);
-}
-
-##---------------------------------------------------------------------------
-
-=head2 Pod::InteriorSequence::B<DESTROY()>
-
-This method performs any necessary cleanup for the interior-sequence.
-If you override this method then it is B<imperative> that you invoke
-the parent method from within your own method, otherwise
-I<interior-sequence storage will not be reclaimed upon destruction!>
-
-=cut
-
-sub DESTROY {
-   ## We need to get rid of all child->parent pointers throughout the
-   ## tree so their reference counts will go to zero and they can be
-   ## garbage-collected
-   _unset_child2parent_links(@_);
-}
-
-##---------------------------------------------------------------------------
-
-#############################################################################
-
-package Pod::ParseTree;
-
-##---------------------------------------------------------------------------
-
-=head1 B<Pod::ParseTree>
-
-This object corresponds to a tree of parsed POD text. As POD text is
-scanned from left to right, it is parsed into an ordered list of
-text-strings and B<Pod::InteriorSequence> objects (in order of
-appearance). A B<Pod::ParseTree> object corresponds to this list of
-strings and sequences. Each interior sequence in the parse-tree may
-itself contain a parse-tree (since interior sequences may be nested).
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head2 Pod::ParseTree-E<gt>B<new()>
-
-        my $ptree1 = Pod::ParseTree->new;
-        my $ptree2 = new Pod::ParseTree;
-        my $ptree4 = Pod::ParseTree->new($array_ref);
-        my $ptree3 = new Pod::ParseTree($array_ref);
-
-This is a class method that constructs a C<Pod::Parse_tree> object and
-returns a reference to the new parse-tree. If a single-argument is given,
-it must be a reference to an array, and is used to initialize the root
-(top) of the parse tree.
-
-=cut
-
-sub new {
-    ## Determine if we were called via an object-ref or a classname
-    my $this = shift;
-    my $class = ref($this) || $this;
-
-    my $self = (@_ == 1  and  ref $_[0]) ? $_[0] : [];
-
-    ## Bless ourselves into the desired class and perform any initialization
-    bless $self, $class;
-    return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $ptree-E<gt>B<top()>
-
-        my $top_node = $ptree->top();
-        $ptree->top( $top_node );
-        $ptree->top( @children );
-
-This method gets/sets the top node of the parse-tree. If no arguments are
-given, it returns the topmost node in the tree (the root), which is also
-a B<Pod::ParseTree>. If it is given a single argument that is a reference,
-then the reference is assumed to a parse-tree and becomes the new top node.
-Otherwise, if arguments are given, they are treated as the new list of
-children for the top node.
-
-=cut
-
-sub top {
-   my $self = shift;
-   if (@_ > 0) {
-      @{ $self } = (@_ == 1  and  ref $_[0]) ? ${ @_ } : @_;
-   }
-   return $self;
-}
-
-## let parse_tree() & ptree() be aliases for the 'top' method
-*parse_tree = *ptree = \&top;
-
-##---------------------------------------------------------------------------
-
-=head2 $ptree-E<gt>B<children()>
-
-This method gets/sets the children of the top node in the parse-tree.
-If no arguments are given, it returns the list (array) of children
-(each of which should be either a string or a B<Pod::InteriorSequence>.
-Otherwise, if arguments are given, they are treated as the new list of
-children for the top node.
-
-=cut
-
-sub children {
-   my $self = shift;
-   if (@_ > 0) {
-      @{ $self } = (@_ == 1  and  ref $_[0]) ? ${ @_ } : @_;
-   }
-   return @{ $self };
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $ptree-E<gt>B<prepend()>
-
-This method prepends the given text or parse-tree to the current parse-tree.
-If the first item on the parse-tree is text and the argument is also text,
-then the text is prepended to the first item (not added as a separate string).
-Otherwise the argument is added as a new string or parse-tree I<before>
-the current one.
-
-=cut
-
-use vars qw(@ptree);  ## an alias used for performance reasons
-
-sub prepend {
-   my $self = shift;
-   local *ptree = $self;
-   for (@_) {
-      next  unless length;
-      if (@ptree && !(ref $ptree[0]) && !(ref $_)) {
-         $ptree[0] = $_ . $ptree[0];
-      }
-      else {
-         unshift @ptree, $_;
-      }
-   }
-}
-
-##---------------------------------------------------------------------------
-
-=head2 $ptree-E<gt>B<append()>
-
-This method appends the given text or parse-tree to the current parse-tree.
-If the last item on the parse-tree is text and the argument is also text,
-then the text is appended to the last item (not added as a separate string).
-Otherwise the argument is added as a new string or parse-tree I<after>
-the current one.
-
-=cut
-
-sub append {
-   my $self = shift;
-   local *ptree = $self;
-   my $can_append = @ptree && !(ref $ptree[-1]);
-   for (@_) {
-      if (ref) {
-         push @ptree, $_;
-      }
-      elsif(!length) {
-         next;
-      }
-      elsif ($can_append) {
-         $ptree[-1] .= $_;
-      }
-      else {
-         push @ptree, $_;
-      }
-   }
-}
-
-=head2 $ptree-E<gt>B<raw_text()>
-
-        my $ptree_raw_text = $ptree->raw_text();
-
-This method will return the I<raw> text of the POD parse-tree
-exactly as it appeared in the input.
-
-=cut
-
-sub raw_text {
-   my $self = shift;
-   my $text = '';
-   for ( @$self ) {
-      $text .= (ref $_) ? $_->raw_text : $_;
-   }
-   return $text;
-}
-
-##---------------------------------------------------------------------------
-
-## Private routines to set/unset child->parent links
-
-sub _unset_child2parent_links {
-   my $self = shift;
-   local *ptree = $self;
-   for (@ptree) {
-       next  unless (defined and length  and  ref  and  ref ne 'SCALAR');
-       $_->_unset_child2parent_links()
-           if UNIVERSAL::isa($_, 'Pod::InteriorSequence');
-   }
-}
-
-sub _set_child2parent_links {
-    ## nothing to do, Pod::ParseTrees cant have parent pointers
-}
-
-=head2 Pod::ParseTree::B<DESTROY()>
-
-This method performs any necessary cleanup for the parse-tree.
-If you override this method then it is B<imperative>
-that you invoke the parent method from within your own method,
-otherwise I<parse-tree storage will not be reclaimed upon destruction!>
-
-=cut
-
-sub DESTROY {
-   ## We need to get rid of all child->parent pointers throughout the
-   ## tree so their reference counts will go to zero and they can be
-   ## garbage-collected
-   _unset_child2parent_links(@_);
-}
-
-#############################################################################
-
-=head1 SEE ALSO
-
-B<Pod::InputObjects> is part of the L<Pod::Parser> distribution.
-
-See L<Pod::Parser>, L<Pod::Select>
-
-=head1 AUTHOR
-
-Please report bugs using L<http://rt.cpan.org>.
-
-Brad Appleton E<lt>bradapp@enteract.comE<gt>
-
-=cut
-
-1;
+#############################################################################

+# Pod/InputObjects.pm -- package which defines objects for input streams

+# and paragraphs and commands when parsing POD docs.

+#

+# Copyright (C) 1996-2000 by Bradford Appleton. All rights reserved.

+# This file is part of "PodParser". PodParser is free software;

+# you can redistribute it and/or modify it under the same terms

+# as Perl itself.

+#############################################################################

+

+package Pod::InputObjects;

+use strict;

+

+use vars qw($VERSION);

+$VERSION = '1.60';  ## Current version of this package

+require  5.005;    ## requires this Perl version or later

+

+#############################################################################

+

+=head1 NAME

+

+Pod::InputObjects - objects representing POD input paragraphs, commands, etc.

+

+=head1 SYNOPSIS

+

+    use Pod::InputObjects;

+

+=head1 REQUIRES

+

+perl5.004, Carp

+

+=head1 EXPORTS

+

+Nothing.

+

+=head1 DESCRIPTION

+

+This module defines some basic input objects used by B<Pod::Parser> when

+reading and parsing POD text from an input source. The following objects

+are defined:

+

+=begin __PRIVATE__

+

+=over 4

+

+=item package B<Pod::InputSource>

+

+An object corresponding to a source of POD input text. It is mostly a

+wrapper around a filehandle or C<IO::Handle>-type object (or anything

+that implements the C<getline()> method) which keeps track of some

+additional information relevant to the parsing of PODs.

+

+=back

+

+=end __PRIVATE__

+

+=over 4

+

+=item package B<Pod::Paragraph>

+

+An object corresponding to a paragraph of POD input text. It may be a

+plain paragraph, a verbatim paragraph, or a command paragraph (see

+L<perlpod>).

+

+=item package B<Pod::InteriorSequence>

+

+An object corresponding to an interior sequence command from the POD

+input text (see L<perlpod>).

+

+=item package B<Pod::ParseTree>

+

+An object corresponding to a tree of parsed POD text. Each "node" in

+a parse-tree (or I<ptree>) is either a text-string or a reference to

+a B<Pod::InteriorSequence> object. The nodes appear in the parse-tree

+in the order in which they were parsed from left-to-right.

+

+=back

+

+Each of these input objects are described in further detail in the

+sections which follow.

+

+=cut

+

+#############################################################################

+

+package Pod::InputSource;

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head1 B<Pod::InputSource>

+

+This object corresponds to an input source or stream of POD

+documentation. When parsing PODs, it is necessary to associate and store

+certain context information with each input source. All of this

+information is kept together with the stream itself in one of these

+C<Pod::InputSource> objects. Each such object is merely a wrapper around

+an C<IO::Handle> object of some kind (or at least something that

+implements the C<getline()> method). They have the following

+methods/attributes:

+

+=end __PRIVATE__

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head2 B<new()>

+

+        my $pod_input1 = Pod::InputSource->new(-handle => $filehandle);

+        my $pod_input2 = new Pod::InputSource(-handle => $filehandle,

+                                              -name   => $name);

+        my $pod_input3 = new Pod::InputSource(-handle => \*STDIN);

+        my $pod_input4 = Pod::InputSource->new(-handle => \*STDIN,

+                                               -name => "(STDIN)");

+

+This is a class method that constructs a C<Pod::InputSource> object and

+returns a reference to the new input source object. It takes one or more

+keyword arguments in the form of a hash. The keyword C<-handle> is

+required and designates the corresponding input handle. The keyword

+C<-name> is optional and specifies the name associated with the input

+handle (typically a file name).

+

+=end __PRIVATE__

+

+=cut

+

+sub new {

+    ## Determine if we were called via an object-ref or a classname

+    my $this = shift;

+    my $class = ref($this) || $this;

+

+    ## Any remaining arguments are treated as initial values for the

+    ## hash that is used to represent this object. Note that we default

+    ## certain values by specifying them *before* the arguments passed.

+    ## If they are in the argument list, they will override the defaults.

+    my $self = { -name        => '(unknown)',

+                 -handle      => undef,

+                 -was_cutting => 0,

+                 @_ };

+

+    ## Bless ourselves into the desired class and perform any initialization

+    bless $self, $class;

+    return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head2 B<name()>

+

+        my $filename = $pod_input->name();

+        $pod_input->name($new_filename_to_use);

+

+This method gets/sets the name of the input source (usually a filename).

+If no argument is given, it returns a string containing the name of

+the input source; otherwise it sets the name of the input source to the

+contents of the given argument.

+

+=end __PRIVATE__

+

+=cut

+

+sub name {

+   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];

+   return $_[0]->{'-name'};

+}

+

+## allow 'filename' as an alias for 'name'

+*filename = \&name;

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head2 B<handle()>

+

+        my $handle = $pod_input->handle();

+

+Returns a reference to the handle object from which input is read (the

+one used to contructed this input source object).

+

+=end __PRIVATE__

+

+=cut

+

+sub handle {

+   return $_[0]->{'-handle'};

+}

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head2 B<was_cutting()>

+

+        print "Yes.\n" if ($pod_input->was_cutting());

+

+The value of the C<cutting> state (that the B<cutting()> method would

+have returned) immediately before any input was read from this input

+stream. After all input from this stream has been read, the C<cutting>

+state is restored to this value.

+

+=end __PRIVATE__

+

+=cut

+

+sub was_cutting {

+   (@_ > 1)  and  $_[0]->{-was_cutting} = $_[1];

+   return $_[0]->{-was_cutting};

+}

+

+##---------------------------------------------------------------------------

+

+#############################################################################

+

+package Pod::Paragraph;

+

+##---------------------------------------------------------------------------

+

+=head1 B<Pod::Paragraph>

+

+An object representing a paragraph of POD input text.

+It has the following methods/attributes:

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head2 Pod::Paragraph-E<gt>B<new()>

+

+        my $pod_para1 = Pod::Paragraph->new(-text => $text);

+        my $pod_para2 = Pod::Paragraph->new(-name => $cmd,

+                                            -text => $text);

+        my $pod_para3 = new Pod::Paragraph(-text => $text);

+        my $pod_para4 = new Pod::Paragraph(-name => $cmd,

+                                           -text => $text);

+        my $pod_para5 = Pod::Paragraph->new(-name => $cmd,

+                                            -text => $text,

+                                            -file => $filename,

+                                            -line => $line_number);

+

+This is a class method that constructs a C<Pod::Paragraph> object and

+returns a reference to the new paragraph object. It may be given one or

+two keyword arguments. The C<-text> keyword indicates the corresponding

+text of the POD paragraph. The C<-name> keyword indicates the name of

+the corresponding POD command, such as C<head1> or C<item> (it should

+I<not> contain the C<=> prefix); this is needed only if the POD

+paragraph corresponds to a command paragraph. The C<-file> and C<-line>

+keywords indicate the filename and line number corresponding to the

+beginning of the paragraph 

+

+=cut

+

+sub new {

+    ## Determine if we were called via an object-ref or a classname

+    my $this = shift;

+    my $class = ref($this) || $this;

+

+    ## Any remaining arguments are treated as initial values for the

+    ## hash that is used to represent this object. Note that we default

+    ## certain values by specifying them *before* the arguments passed.

+    ## If they are in the argument list, they will override the defaults.

+    my $self = {

+          -name       => undef,

+          -text       => (@_ == 1) ? shift : undef,

+          -file       => '<unknown-file>',

+          -line       => 0,

+          -prefix     => '=',

+          -separator  => ' ',

+          -ptree => [],

+          @_

+    };

+

+    ## Bless ourselves into the desired class and perform any initialization

+    bless $self, $class;

+    return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<cmd_name()>

+

+        my $para_cmd = $pod_para->cmd_name();

+

+If this paragraph is a command paragraph, then this method will return 

+the name of the command (I<without> any leading C<=> prefix).

+

+=cut

+

+sub cmd_name {

+   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];

+   return $_[0]->{'-name'};

+}

+

+## let name() be an alias for cmd_name()

+*name = \&cmd_name;

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<text()>

+

+        my $para_text = $pod_para->text();

+

+This method will return the corresponding text of the paragraph.

+

+=cut

+

+sub text {

+   (@_ > 1)  and  $_[0]->{'-text'} = $_[1];

+   return $_[0]->{'-text'};

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<raw_text()>

+

+        my $raw_pod_para = $pod_para->raw_text();

+

+This method will return the I<raw> text of the POD paragraph, exactly

+as it appeared in the input.

+

+=cut

+

+sub raw_text {

+   return $_[0]->{'-text'}  unless (defined $_[0]->{'-name'});

+   return $_[0]->{'-prefix'} . $_[0]->{'-name'} .

+          $_[0]->{'-separator'} . $_[0]->{'-text'};

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<cmd_prefix()>

+

+        my $prefix = $pod_para->cmd_prefix();

+

+If this paragraph is a command paragraph, then this method will return 

+the prefix used to denote the command (which should be the string "="

+or "==").

+

+=cut

+

+sub cmd_prefix {

+   return $_[0]->{'-prefix'};

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<cmd_separator()>

+

+        my $separator = $pod_para->cmd_separator();

+

+If this paragraph is a command paragraph, then this method will return

+the text used to separate the command name from the rest of the

+paragraph (if any).

+

+=cut

+

+sub cmd_separator {

+   return $_[0]->{'-separator'};

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<parse_tree()>

+

+        my $ptree = $pod_parser->parse_text( $pod_para->text() );

+        $pod_para->parse_tree( $ptree );

+        $ptree = $pod_para->parse_tree();

+

+This method will get/set the corresponding parse-tree of the paragraph's text.

+

+=cut

+

+sub parse_tree {

+   (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];

+   return $_[0]->{'-ptree'};

+}

+

+## let ptree() be an alias for parse_tree()

+*ptree = \&parse_tree;

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_para-E<gt>B<file_line()>

+

+        my ($filename, $line_number) = $pod_para->file_line();

+        my $position = $pod_para->file_line();

+

+Returns the current filename and line number for the paragraph

+object.  If called in a list context, it returns a list of two

+elements: first the filename, then the line number. If called in

+a scalar context, it returns a string containing the filename, followed

+by a colon (':'), followed by the line number.

+

+=cut

+

+sub file_line {

+   my @loc = ($_[0]->{'-file'} || '<unknown-file>',

+              $_[0]->{'-line'} || 0);

+   return (wantarray) ? @loc : join(':', @loc);

+}

+

+##---------------------------------------------------------------------------

+

+#############################################################################

+

+package Pod::InteriorSequence;

+

+##---------------------------------------------------------------------------

+

+=head1 B<Pod::InteriorSequence>

+

+An object representing a POD interior sequence command.

+It has the following methods/attributes:

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head2 Pod::InteriorSequence-E<gt>B<new()>

+

+        my $pod_seq1 = Pod::InteriorSequence->new(-name => $cmd

+                                                  -ldelim => $delimiter);

+        my $pod_seq2 = new Pod::InteriorSequence(-name => $cmd,

+                                                 -ldelim => $delimiter);

+        my $pod_seq3 = new Pod::InteriorSequence(-name => $cmd,

+                                                 -ldelim => $delimiter,

+                                                 -file => $filename,

+                                                 -line => $line_number);

+

+        my $pod_seq4 = new Pod::InteriorSequence(-name => $cmd, $ptree);

+        my $pod_seq5 = new Pod::InteriorSequence($cmd, $ptree);

+

+This is a class method that constructs a C<Pod::InteriorSequence> object

+and returns a reference to the new interior sequence object. It should

+be given two keyword arguments.  The C<-ldelim> keyword indicates the

+corresponding left-delimiter of the interior sequence (e.g. 'E<lt>').

+The C<-name> keyword indicates the name of the corresponding interior

+sequence command, such as C<I> or C<B> or C<C>. The C<-file> and

+C<-line> keywords indicate the filename and line number corresponding

+to the beginning of the interior sequence. If the C<$ptree> argument is

+given, it must be the last argument, and it must be either string, or

+else an array-ref suitable for passing to B<Pod::ParseTree::new> (or

+it may be a reference to a Pod::ParseTree object).

+

+=cut

+

+sub new {

+    ## Determine if we were called via an object-ref or a classname

+    my $this = shift;

+    my $class = ref($this) || $this;

+

+    ## See if first argument has no keyword

+    if (((@_ <= 2) or (@_ % 2)) and $_[0] !~ /^-\w/) {

+       ## Yup - need an implicit '-name' before first parameter

+       unshift @_, '-name';

+    }

+

+    ## See if odd number of args

+    if ((@_ % 2) != 0) {

+       ## Yup - need an implicit '-ptree' before the last parameter

+       splice @_, $#_, 0, '-ptree';

+    }

+

+    ## Any remaining arguments are treated as initial values for the

+    ## hash that is used to represent this object. Note that we default

+    ## certain values by specifying them *before* the arguments passed.

+    ## If they are in the argument list, they will override the defaults.

+    my $self = {

+          -name       => (@_ == 1) ? $_[0] : undef,

+          -file       => '<unknown-file>',

+          -line       => 0,

+          -ldelim     => '<',

+          -rdelim     => '>',

+          @_

+    };

+

+    ## Initialize contents if they havent been already

+    my $ptree = $self->{'-ptree'} || new Pod::ParseTree();

+    if ( ref $ptree =~ /^(ARRAY)?$/ ) {

+        ## We have an array-ref, or a normal scalar. Pass it as an

+        ## an argument to the ptree-constructor

+        $ptree = new Pod::ParseTree($1 ? [$ptree] : $ptree);

+    }

+    $self->{'-ptree'} = $ptree;

+

+    ## Bless ourselves into the desired class and perform any initialization

+    bless $self, $class;

+    return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<cmd_name()>

+

+        my $seq_cmd = $pod_seq->cmd_name();

+

+The name of the interior sequence command.

+

+=cut

+

+sub cmd_name {

+   (@_ > 1)  and  $_[0]->{'-name'} = $_[1];

+   return $_[0]->{'-name'};

+}

+

+## let name() be an alias for cmd_name()

+*name = \&cmd_name;

+

+##---------------------------------------------------------------------------

+

+## Private subroutine to set the parent pointer of all the given

+## children that are interior-sequences to be $self

+

+sub _set_child2parent_links {

+   my ($self, @children) = @_;

+   ## Make sure any sequences know who their parent is

+   for (@children) {

+      next  unless (length  and  ref  and  ref ne 'SCALAR');

+      if (UNIVERSAL::isa($_, 'Pod::InteriorSequence') or

+          UNIVERSAL::can($_, 'nested'))

+      {

+          $_->nested($self);

+      }

+   }

+}

+

+## Private subroutine to unset child->parent links

+

+sub _unset_child2parent_links {

+   my $self = shift;

+   $self->{'-parent_sequence'} = undef;

+   my $ptree = $self->{'-ptree'};

+   for (@$ptree) {

+      next  unless (length  and  ref  and  ref ne 'SCALAR');

+      $_->_unset_child2parent_links()

+          if UNIVERSAL::isa($_, 'Pod::InteriorSequence');

+   }

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<prepend()>

+

+        $pod_seq->prepend($text);

+        $pod_seq1->prepend($pod_seq2);

+

+Prepends the given string or parse-tree or sequence object to the parse-tree

+of this interior sequence.

+

+=cut

+

+sub prepend {

+   my $self  = shift;

+   $self->{'-ptree'}->prepend(@_);

+   _set_child2parent_links($self, @_);

+   return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<append()>

+

+        $pod_seq->append($text);

+        $pod_seq1->append($pod_seq2);

+

+Appends the given string or parse-tree or sequence object to the parse-tree

+of this interior sequence.

+

+=cut

+

+sub append {

+   my $self = shift;

+   $self->{'-ptree'}->append(@_);

+   _set_child2parent_links($self, @_);

+   return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<nested()>

+

+        $outer_seq = $pod_seq->nested || print "not nested";

+

+If this interior sequence is nested inside of another interior

+sequence, then the outer/parent sequence that contains it is

+returned. Otherwise C<undef> is returned.

+

+=cut

+

+sub nested {

+   my $self = shift;

+  (@_ == 1)  and  $self->{'-parent_sequence'} = shift;

+   return  $self->{'-parent_sequence'} || undef;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<raw_text()>

+

+        my $seq_raw_text = $pod_seq->raw_text();

+

+This method will return the I<raw> text of the POD interior sequence,

+exactly as it appeared in the input.

+

+=cut

+

+sub raw_text {

+   my $self = shift;

+   my $text = $self->{'-name'} . $self->{'-ldelim'};

+   for ( $self->{'-ptree'}->children ) {

+      $text .= (ref $_) ? $_->raw_text : $_;

+   }

+   $text .= $self->{'-rdelim'};

+   return $text;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<left_delimiter()>

+

+        my $ldelim = $pod_seq->left_delimiter();

+

+The leftmost delimiter beginning the argument text to the interior

+sequence (should be "<").

+

+=cut

+

+sub left_delimiter {

+   (@_ > 1)  and  $_[0]->{'-ldelim'} = $_[1];

+   return $_[0]->{'-ldelim'};

+}

+

+## let ldelim() be an alias for left_delimiter()

+*ldelim = \&left_delimiter;

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<right_delimiter()>

+

+The rightmost delimiter beginning the argument text to the interior

+sequence (should be ">").

+

+=cut

+

+sub right_delimiter {

+   (@_ > 1)  and  $_[0]->{'-rdelim'} = $_[1];

+   return $_[0]->{'-rdelim'};

+}

+

+## let rdelim() be an alias for right_delimiter()

+*rdelim = \&right_delimiter;

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<parse_tree()>

+

+        my $ptree = $pod_parser->parse_text($paragraph_text);

+        $pod_seq->parse_tree( $ptree );

+        $ptree = $pod_seq->parse_tree();

+

+This method will get/set the corresponding parse-tree of the interior

+sequence's text.

+

+=cut

+

+sub parse_tree {

+   (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];

+   return $_[0]->{'-ptree'};

+}

+

+## let ptree() be an alias for parse_tree()

+*ptree = \&parse_tree;

+

+##---------------------------------------------------------------------------

+

+=head2 $pod_seq-E<gt>B<file_line()>

+

+        my ($filename, $line_number) = $pod_seq->file_line();

+        my $position = $pod_seq->file_line();

+

+Returns the current filename and line number for the interior sequence

+object.  If called in a list context, it returns a list of two

+elements: first the filename, then the line number. If called in

+a scalar context, it returns a string containing the filename, followed

+by a colon (':'), followed by the line number.

+

+=cut

+

+sub file_line {

+   my @loc = ($_[0]->{'-file'}  || '<unknown-file>',

+              $_[0]->{'-line'}  || 0);

+   return (wantarray) ? @loc : join(':', @loc);

+}

+

+##---------------------------------------------------------------------------

+

+=head2 Pod::InteriorSequence::B<DESTROY()>

+

+This method performs any necessary cleanup for the interior-sequence.

+If you override this method then it is B<imperative> that you invoke

+the parent method from within your own method, otherwise

+I<interior-sequence storage will not be reclaimed upon destruction!>

+

+=cut

+

+sub DESTROY {

+   ## We need to get rid of all child->parent pointers throughout the

+   ## tree so their reference counts will go to zero and they can be

+   ## garbage-collected

+   _unset_child2parent_links(@_);

+}

+

+##---------------------------------------------------------------------------

+

+#############################################################################

+

+package Pod::ParseTree;

+

+##---------------------------------------------------------------------------

+

+=head1 B<Pod::ParseTree>

+

+This object corresponds to a tree of parsed POD text. As POD text is

+scanned from left to right, it is parsed into an ordered list of

+text-strings and B<Pod::InteriorSequence> objects (in order of

+appearance). A B<Pod::ParseTree> object corresponds to this list of

+strings and sequences. Each interior sequence in the parse-tree may

+itself contain a parse-tree (since interior sequences may be nested).

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head2 Pod::ParseTree-E<gt>B<new()>

+

+        my $ptree1 = Pod::ParseTree->new;

+        my $ptree2 = new Pod::ParseTree;

+        my $ptree4 = Pod::ParseTree->new($array_ref);

+        my $ptree3 = new Pod::ParseTree($array_ref);

+

+This is a class method that constructs a C<Pod::Parse_tree> object and

+returns a reference to the new parse-tree. If a single-argument is given,

+it must be a reference to an array, and is used to initialize the root

+(top) of the parse tree.

+

+=cut

+

+sub new {

+    ## Determine if we were called via an object-ref or a classname

+    my $this = shift;

+    my $class = ref($this) || $this;

+

+    my $self = (@_ == 1  and  ref $_[0]) ? $_[0] : [];

+

+    ## Bless ourselves into the desired class and perform any initialization

+    bless $self, $class;

+    return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $ptree-E<gt>B<top()>

+

+        my $top_node = $ptree->top();

+        $ptree->top( $top_node );

+        $ptree->top( @children );

+

+This method gets/sets the top node of the parse-tree. If no arguments are

+given, it returns the topmost node in the tree (the root), which is also

+a B<Pod::ParseTree>. If it is given a single argument that is a reference,

+then the reference is assumed to a parse-tree and becomes the new top node.

+Otherwise, if arguments are given, they are treated as the new list of

+children for the top node.

+

+=cut

+

+sub top {

+   my $self = shift;

+   if (@_ > 0) {

+      @{ $self } = (@_ == 1  and  ref $_[0]) ? ${ @_ } : @_;

+   }

+   return $self;

+}

+

+## let parse_tree() & ptree() be aliases for the 'top' method

+*parse_tree = *ptree = \&top;

+

+##---------------------------------------------------------------------------

+

+=head2 $ptree-E<gt>B<children()>

+

+This method gets/sets the children of the top node in the parse-tree.

+If no arguments are given, it returns the list (array) of children

+(each of which should be either a string or a B<Pod::InteriorSequence>.

+Otherwise, if arguments are given, they are treated as the new list of

+children for the top node.

+

+=cut

+

+sub children {

+   my $self = shift;

+   if (@_ > 0) {

+      @{ $self } = (@_ == 1  and  ref $_[0]) ? ${ @_ } : @_;

+   }

+   return @{ $self };

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $ptree-E<gt>B<prepend()>

+

+This method prepends the given text or parse-tree to the current parse-tree.

+If the first item on the parse-tree is text and the argument is also text,

+then the text is prepended to the first item (not added as a separate string).

+Otherwise the argument is added as a new string or parse-tree I<before>

+the current one.

+

+=cut

+

+use vars qw(@ptree);  ## an alias used for performance reasons

+

+sub prepend {

+   my $self = shift;

+   local *ptree = $self;

+   for (@_) {

+      next  unless length;

+      if (@ptree && !(ref $ptree[0]) && !(ref $_)) {

+         $ptree[0] = $_ . $ptree[0];

+      }

+      else {

+         unshift @ptree, $_;

+      }

+   }

+}

+

+##---------------------------------------------------------------------------

+

+=head2 $ptree-E<gt>B<append()>

+

+This method appends the given text or parse-tree to the current parse-tree.

+If the last item on the parse-tree is text and the argument is also text,

+then the text is appended to the last item (not added as a separate string).

+Otherwise the argument is added as a new string or parse-tree I<after>

+the current one.

+

+=cut

+

+sub append {

+   my $self = shift;

+   local *ptree = $self;

+   my $can_append = @ptree && !(ref $ptree[-1]);

+   for (@_) {

+      if (ref) {

+         push @ptree, $_;

+      }

+      elsif(!length) {

+         next;

+      }

+      elsif ($can_append) {

+         $ptree[-1] .= $_;

+      }

+      else {

+         push @ptree, $_;

+      }

+   }

+}

+

+=head2 $ptree-E<gt>B<raw_text()>

+

+        my $ptree_raw_text = $ptree->raw_text();

+

+This method will return the I<raw> text of the POD parse-tree

+exactly as it appeared in the input.

+

+=cut

+

+sub raw_text {

+   my $self = shift;

+   my $text = '';

+   for ( @$self ) {

+      $text .= (ref $_) ? $_->raw_text : $_;

+   }

+   return $text;

+}

+

+##---------------------------------------------------------------------------

+

+## Private routines to set/unset child->parent links

+

+sub _unset_child2parent_links {

+   my $self = shift;

+   local *ptree = $self;

+   for (@ptree) {

+       next  unless (defined and length  and  ref  and  ref ne 'SCALAR');

+       $_->_unset_child2parent_links()

+           if UNIVERSAL::isa($_, 'Pod::InteriorSequence');

+   }

+}

+

+sub _set_child2parent_links {

+    ## nothing to do, Pod::ParseTrees cant have parent pointers

+}

+

+=head2 Pod::ParseTree::B<DESTROY()>

+

+This method performs any necessary cleanup for the parse-tree.

+If you override this method then it is B<imperative>

+that you invoke the parent method from within your own method,

+otherwise I<parse-tree storage will not be reclaimed upon destruction!>

+

+=cut

+

+sub DESTROY {

+   ## We need to get rid of all child->parent pointers throughout the

+   ## tree so their reference counts will go to zero and they can be

+   ## garbage-collected

+   _unset_child2parent_links(@_);

+}

+

+#############################################################################

+

+=head1 SEE ALSO

+

+B<Pod::InputObjects> is part of the L<Pod::Parser> distribution.

+

+See L<Pod::Parser>, L<Pod::Select>

+

+=head1 AUTHOR

+

+Please report bugs using L<http://rt.cpan.org>.

+

+Brad Appleton E<lt>bradapp@enteract.comE<gt>

+

+=cut

+

+1;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/ParseUtils.pm b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/ParseUtils.pm
index 3c74d786801..fc9f3a73f21 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/ParseUtils.pm
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/ParseUtils.pm
@@ -1,857 +1,857 @@
-#############################################################################
-# Pod/ParseUtils.pm -- helpers for POD parsing and conversion
-#
-# Copyright (C) 1999-2000 by Marek Rouchal. All rights reserved.
-# This file is part of "PodParser". PodParser is free software;
-# you can redistribute it and/or modify it under the same terms
-# as Perl itself.
-#############################################################################
-
-package Pod::ParseUtils;
-use strict;
-
-use vars qw($VERSION);
-$VERSION = '1.51'; ## Current version of this package
-require  5.005;    ## requires this Perl version or later
-
-=head1 NAME
-
-Pod::ParseUtils - helpers for POD parsing and conversion
-
-=head1 SYNOPSIS
-
-  use Pod::ParseUtils;
-
-  my $list = new Pod::List;
-  my $link = Pod::Hyperlink->new('Pod::Parser');
-
-=head1 DESCRIPTION
-
-B<Pod::ParseUtils> contains a few object-oriented helper packages for
-POD parsing and processing (i.e. in POD formatters and translators).
-
-=cut
-
-#-----------------------------------------------------------------------------
-# Pod::List
-#
-# class to hold POD list info (=over, =item, =back)
-#-----------------------------------------------------------------------------
-
-package Pod::List;
-
-use Carp;
-
-=head2 Pod::List
-
-B<Pod::List> can be used to hold information about POD lists
-(written as =over ... =item ... =back) for further processing.
-The following methods are available:
-
-=over 4
-
-=item Pod::List-E<gt>new()
-
-Create a new list object. Properties may be specified through a hash
-reference like this:
-
-  my $list = Pod::List->new({ -start => $., -indent => 4 });
-
-See the individual methods/properties for details.
-
-=cut
-
-sub new {
-    my $this = shift;
-    my $class = ref($this) || $this;
-    my %params = @_;
-    my $self = {%params};
-    bless $self, $class;
-    $self->initialize();
-    return $self;
-}
-
-sub initialize {
-    my $self = shift;
-    $self->{-file} ||= 'unknown';
-    $self->{-start} ||= 'unknown';
-    $self->{-indent} ||= 4; # perlpod: "should be the default"
-    $self->{_items} = [];
-    $self->{-type} ||= '';
-}
-
-=item $list-E<gt>file()
-
-Without argument, retrieves the file name the list is in. This must
-have been set before by either specifying B<-file> in the B<new()>
-method or by calling the B<file()> method with a scalar argument.
-
-=cut
-
-# The POD file name the list appears in
-sub file {
-   return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};
-}
-
-=item $list-E<gt>start()
-
-Without argument, retrieves the line number where the list started.
-This must have been set before by either specifying B<-start> in the
-B<new()> method or by calling the B<start()> method with a scalar
-argument.
-
-=cut
-
-# The line in the file the node appears
-sub start {
-   return (@_ > 1) ? ($_[0]->{-start} = $_[1]) : $_[0]->{-start};
-}
-
-=item $list-E<gt>indent()
-
-Without argument, retrieves the indent level of the list as specified
-in C<=over n>. This must have been set before by either specifying
-B<-indent> in the B<new()> method or by calling the B<indent()> method
-with a scalar argument.
-
-=cut
-
-# indent level
-sub indent {
-   return (@_ > 1) ? ($_[0]->{-indent} = $_[1]) : $_[0]->{-indent};
-}
-
-=item $list-E<gt>type()
-
-Without argument, retrieves the list type, which can be an arbitrary value,
-e.g. C<OL>, C<UL>, ... when thinking the HTML way.
-This must have been set before by either specifying
-B<-type> in the B<new()> method or by calling the B<type()> method
-with a scalar argument.
-
-=cut
-
-# The type of the list (UL, OL, ...)
-sub type {
-   return (@_ > 1) ? ($_[0]->{-type} = $_[1]) : $_[0]->{-type};
-}
-
-=item $list-E<gt>rx()
-
-Without argument, retrieves a regular expression for simplifying the 
-individual item strings once the list type has been determined. Usage:
-E.g. when converting to HTML, one might strip the leading number in
-an ordered list as C<E<lt>OLE<gt>> already prints numbers itself.
-This must have been set before by either specifying
-B<-rx> in the B<new()> method or by calling the B<rx()> method
-with a scalar argument.
-
-=cut
-
-# The regular expression to simplify the items
-sub rx {
-   return (@_ > 1) ? ($_[0]->{-rx} = $_[1]) : $_[0]->{-rx};
-}
-
-=item $list-E<gt>item()
-
-Without argument, retrieves the array of the items in this list.
-The items may be represented by any scalar.
-If an argument has been given, it is pushed on the list of items.
-
-=cut
-
-# The individual =items of this list
-sub item {
-    my ($self,$item) = @_;
-    if(defined $item) {
-        push(@{$self->{_items}}, $item);
-        return $item;
-    }
-    else {
-        return @{$self->{_items}};
-    }
-}
-
-=item $list-E<gt>parent()
-
-Without argument, retrieves information about the parent holding this
-list, which is represented as an arbitrary scalar.
-This must have been set before by either specifying
-B<-parent> in the B<new()> method or by calling the B<parent()> method
-with a scalar argument.
-
-=cut
-
-# possibility for parsers/translators to store information about the
-# lists's parent object
-sub parent {
-   return (@_ > 1) ? ($_[0]->{-parent} = $_[1]) : $_[0]->{-parent};
-}
-
-=item $list-E<gt>tag()
-
-Without argument, retrieves information about the list tag, which can be
-any scalar.
-This must have been set before by either specifying
-B<-tag> in the B<new()> method or by calling the B<tag()> method
-with a scalar argument.
-
-=back
-
-=cut
-
-# possibility for parsers/translators to store information about the
-# list's object
-sub tag {
-   return (@_ > 1) ? ($_[0]->{-tag} = $_[1]) : $_[0]->{-tag};
-}
-
-#-----------------------------------------------------------------------------
-# Pod::Hyperlink
-#
-# class to manipulate POD hyperlinks (L<>)
-#-----------------------------------------------------------------------------
-
-package Pod::Hyperlink;
-
-=head2 Pod::Hyperlink
-
-B<Pod::Hyperlink> is a class for manipulation of POD hyperlinks. Usage:
-
-  my $link = Pod::Hyperlink->new('alternative text|page/"section in page"');
-
-The B<Pod::Hyperlink> class is mainly designed to parse the contents of the
-C<LE<lt>...E<gt>> sequence, providing a simple interface for accessing the
-different parts of a POD hyperlink for further processing. It can also be
-used to construct hyperlinks.
-
-=over 4
-
-=item Pod::Hyperlink-E<gt>new()
-
-The B<new()> method can either be passed a set of key/value pairs or a single
-scalar value, namely the contents of a C<LE<lt>...E<gt>> sequence. An object
-of the class C<Pod::Hyperlink> is returned. The value C<undef> indicates a
-failure, the error message is stored in C<$@>.
-
-=cut
-
-use Carp;
-
-sub new {
-    my $this = shift;
-    my $class = ref($this) || $this;
-    my $self = +{};
-    bless $self, $class;
-    $self->initialize();
-    if(defined $_[0]) {
-        if(ref($_[0])) {
-            # called with a list of parameters
-            %$self = %{$_[0]};
-            $self->_construct_text();
-        }
-        else {
-            # called with L<> contents
-            return unless($self->parse($_[0]));
-        }
-    }
-    return $self;
-}
-
-sub initialize {
-    my $self = shift;
-    $self->{-line} ||= 'undef';
-    $self->{-file} ||= 'undef';
-    $self->{-page} ||= '';
-    $self->{-node} ||= '';
-    $self->{-alttext} ||= '';
-    $self->{-type} ||= 'undef';
-    $self->{_warnings} = [];
-}
-
-=item $link-E<gt>parse($string)
-
-This method can be used to (re)parse a (new) hyperlink, i.e. the contents
-of a C<LE<lt>...E<gt>> sequence. The result is stored in the current object.
-Warnings are stored in the B<warnings> property.
-E.g. sections like C<LE<lt>open(2)E<gt>> are deprecated, as they do not point
-to Perl documents. C<LE<lt>DBI::foo(3p)E<gt>> is wrong as well, the manpage
-section can simply be dropped.
-
-=cut
-
-sub parse {
-    my $self = shift;
-    local($_) = $_[0];
-    # syntax check the link and extract destination
-    my ($alttext,$page,$node,$type,$quoted) = (undef,'','','',0);
-
-    $self->{_warnings} = [];
-
-    # collapse newlines with whitespace
-    s/\s*\n+\s*/ /g;
-
-    # strip leading/trailing whitespace
-    if(s/^[\s\n]+//) {
-        $self->warning('ignoring leading whitespace in link');
-    }
-    if(s/[\s\n]+$//) {
-        $self->warning('ignoring trailing whitespace in link');
-    }
-    unless(length($_)) {
-        _invalid_link('empty link');
-        return;
-    }
-
-    ## Check for different possibilities. This is tedious and error-prone
-    # we match all possibilities (alttext, page, section/item)
-    #warn "DEBUG: link=$_\n";
-
-    # only page
-    # problem: a lot of people use (), or (1) or the like to indicate
-    # man page sections. But this collides with L<func()> that is supposed
-    # to point to an internal funtion...
-    my $page_rx = '[\w.-]+(?:::[\w.-]+)*(?:[(](?:\d\w*|)[)]|)';
-    # page name only
-    if(/^($page_rx)$/o) {
-        $page = $1;
-        $type = 'page';
-    }
-    # alttext, page and "section"
-    elsif(m{^(.*?)\s*[|]\s*($page_rx)\s*/\s*"(.+)"$}o) {
-        ($alttext, $page, $node) = ($1, $2, $3);
-        $type = 'section';
-        $quoted = 1; #... therefore | and / are allowed
-    }
-    # alttext and page
-    elsif(/^(.*?)\s*[|]\s*($page_rx)$/o) {
-        ($alttext, $page) = ($1, $2);
-        $type = 'page';
-    }
-    # alttext and "section"
-    elsif(m{^(.*?)\s*[|]\s*(?:/\s*|)"(.+)"$}) {
-        ($alttext, $node) = ($1,$2);
-        $type = 'section';
-        $quoted = 1;
-    }
-    # page and "section"
-    elsif(m{^($page_rx)\s*/\s*"(.+)"$}o) {
-        ($page, $node) = ($1, $2);
-        $type = 'section';
-        $quoted = 1;
-    }
-    # page and item
-    elsif(m{^($page_rx)\s*/\s*(.+)$}o) {
-        ($page, $node) = ($1, $2);
-        $type = 'item';
-    }
-    # only "section"
-    elsif(m{^/?"(.+)"$}) {
-        $node = $1;
-        $type = 'section';
-        $quoted = 1;
-    }
-    # only item
-    elsif(m{^\s*/(.+)$}) {
-        $node = $1;
-        $type = 'item';
-    }
-
-    # non-standard: Hyperlink with alt-text - doesn't remove protocol prefix, maybe it should?
-    elsif(/^ \s* (.*?) \s* [|] \s* (\w+:[^:\s] [^\s|]*?) \s* $/ix) {
-      ($alttext,$node) = ($1,$2);
-      $type = 'hyperlink';
-    }
-
-    # non-standard: Hyperlink
-    elsif(/^(\w+:[^:\s]\S*)$/i) {
-        $node = $1;
-        $type = 'hyperlink';
-    }
-    # alttext, page and item
-    elsif(m{^(.*?)\s*[|]\s*($page_rx)\s*/\s*(.+)$}o) {
-        ($alttext, $page, $node) = ($1, $2, $3);
-        $type = 'item';
-    }
-    # alttext and item
-    elsif(m{^(.*?)\s*[|]\s*/(.+)$}) {
-        ($alttext, $node) = ($1,$2);
-    }
-    # must be an item or a "malformed" section (without "")
-    else {
-        $node = $_;
-        $type = 'item';
-    }
-    # collapse whitespace in nodes
-    $node =~ s/\s+/ /gs;
-
-    # empty alternative text expands to node name
-    if(defined $alttext) {
-        if(!length($alttext)) {
-          $alttext = $node || $page;
-        }
-    }
-    else {
-        $alttext = '';
-    }
-
-    if($page =~ /[(]\w*[)]$/) {
-        $self->warning("(section) in '$page' deprecated");
-    }
-    if(!$quoted && $node =~ m{[|/]} && $type ne 'hyperlink') {
-        $self->warning("node '$node' contains non-escaped | or /");
-    }
-    if($alttext =~ m{[|/]}) {
-        $self->warning("alternative text '$node' contains non-escaped | or /");
-    }
-    $self->{-page} = $page;
-    $self->{-node} = $node;
-    $self->{-alttext} = $alttext;
-    #warn "DEBUG: page=$page section=$section item=$item alttext=$alttext\n";
-    $self->{-type} = $type;
-    $self->_construct_text();
-    1;
-}
-
-sub _construct_text {
-    my $self = shift;
-    my $alttext = $self->alttext();
-    my $type = $self->type();
-    my $section = $self->node();
-    my $page = $self->page();
-    my $page_ext = '';
-    $page =~ s/([(]\w*[)])$// && ($page_ext = $1);
-    if($alttext) {
-        $self->{_text} = $alttext;
-    }
-    elsif($type eq 'hyperlink') {
-        $self->{_text} = $section;
-    }
-    else {
-        $self->{_text} = ($section || '') .
-            (($page && $section) ? ' in ' : '') .
-            "$page$page_ext";
-    }
-    # for being marked up later
-    # use the non-standard markers P<> and Q<>, so that the resulting
-    # text can be parsed by the translators. It's their job to put
-    # the correct hypertext around the linktext
-    if($alttext) {
-        $self->{_markup} = "Q<$alttext>";
-    }
-    elsif($type eq 'hyperlink') {
-        $self->{_markup} = "Q<$section>";
-    }
-    else {
-        $self->{_markup} = (!$section ? '' : "Q<$section>") .
-            ($page ? ($section ? ' in ':'') . "P<$page>$page_ext" : '');
-    }
-}
-
-=item $link-E<gt>markup($string)
-
-Set/retrieve the textual value of the link. This string contains special
-markers C<PE<lt>E<gt>> and C<QE<lt>E<gt>> that should be expanded by the
-translator's interior sequence expansion engine to the
-formatter-specific code to highlight/activate the hyperlink. The details
-have to be implemented in the translator.
-
-=cut
-
-#' retrieve/set markuped text
-sub markup {
-    return (@_ > 1) ? ($_[0]->{_markup} = $_[1]) : $_[0]->{_markup};
-}
-
-=item $link-E<gt>text()
-
-This method returns the textual representation of the hyperlink as above,
-but without markers (read only). Depending on the link type this is one of
-the following alternatives (the + and * denote the portions of the text
-that are marked up):
-
-  +perl+                    L<perl>
-  *$|* in +perlvar+         L<perlvar/$|>
-  *OPTIONS* in +perldoc+    L<perldoc/"OPTIONS">
-  *DESCRIPTION*             L<"DESCRIPTION">
-
-=cut
-
-# The complete link's text
-sub text {
-    return $_[0]->{_text};
-}
-
-=item $link-E<gt>warning()
-
-After parsing, this method returns any warnings encountered during the
-parsing process.
-
-=cut
-
-# Set/retrieve warnings
-sub warning {
-    my $self = shift;
-    if(@_) {
-        push(@{$self->{_warnings}}, @_);
-        return @_;
-    }
-    return @{$self->{_warnings}};
-}
-
-=item $link-E<gt>file()
-
-=item $link-E<gt>line()
-
-Just simple slots for storing information about the line and the file
-the link was encountered in. Has to be filled in manually.
-
-=cut
-
-# The line in the file the link appears
-sub line {
-    return (@_ > 1) ? ($_[0]->{-line} = $_[1]) : $_[0]->{-line};
-}
-
-# The POD file name the link appears in
-sub file {
-    return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};
-}
-
-=item $link-E<gt>page()
-
-This method sets or returns the POD page this link points to.
-
-=cut
-
-# The POD page the link appears on
-sub page {
-    if (@_ > 1) {
-        $_[0]->{-page} = $_[1];
-        $_[0]->_construct_text();
-    }
-    return $_[0]->{-page};
-}
-
-=item $link-E<gt>node()
-
-As above, but the destination node text of the link.
-
-=cut
-
-# The link destination
-sub node {
-    if (@_ > 1) {
-        $_[0]->{-node} = $_[1];
-        $_[0]->_construct_text();
-    }
-    return $_[0]->{-node};
-}
-
-=item $link-E<gt>alttext()
-
-Sets or returns an alternative text specified in the link.
-
-=cut
-
-# Potential alternative text
-sub alttext {
-    if (@_ > 1) {
-        $_[0]->{-alttext} = $_[1];
-        $_[0]->_construct_text();
-    }
-    return $_[0]->{-alttext};
-}
-
-=item $link-E<gt>type()
-
-The node type, either C<section> or C<item>. As an unofficial type,
-there is also C<hyperlink>, derived from e.g. C<LE<lt>http://perl.comE<gt>>
-
-=cut
-
-# The type: item or headn
-sub type {
-    return (@_ > 1) ? ($_[0]->{-type} = $_[1]) : $_[0]->{-type};
-}
-
-=item $link-E<gt>link()
-
-Returns the link as contents of C<LE<lt>E<gt>>. Reciprocal to B<parse()>.
-
-=back
-
-=cut
-
-# The link itself
-sub link {
-    my $self = shift;
-    my $link = $self->page() || '';
-    if($self->node()) {
-        my $node = $self->node();
-        $node =~ s/\|/E<verbar>/g;
-        $node =~ s{/}{E<sol>}g;
-        if($self->type() eq 'section') {
-            $link .= ($link ? '/' : '') . '"' . $node . '"';
-        }
-        elsif($self->type() eq 'hyperlink') {
-            $link = $self->node();
-        }
-        else { # item
-            $link .= '/' . $node;
-        }
-    }
-    if($self->alttext()) {
-        my $text = $self->alttext();
-        $text =~ s/\|/E<verbar>/g;
-        $text =~ s{/}{E<sol>}g;
-        $link = "$text|$link";
-    }
-    return $link;
-}
-
-sub _invalid_link {
-    my ($msg) = @_;
-    # this sets @_
-    #eval { die "$msg\n" };
-    #chomp $@;
-    $@ = $msg; # this seems to work, too!
-    return;
-}
-
-#-----------------------------------------------------------------------------
-# Pod::Cache
-#
-# class to hold POD page details
-#-----------------------------------------------------------------------------
-
-package Pod::Cache;
-
-=head2 Pod::Cache
-
-B<Pod::Cache> holds information about a set of POD documents,
-especially the nodes for hyperlinks.
-The following methods are available:
-
-=over 4
-
-=item Pod::Cache-E<gt>new()
-
-Create a new cache object. This object can hold an arbitrary number of
-POD documents of class Pod::Cache::Item.
-
-=cut
-
-sub new {
-    my $this = shift;
-    my $class = ref($this) || $this;
-    my $self = [];
-    bless $self, $class;
-    return $self;
-}
-
-=item $cache-E<gt>item()
-
-Add a new item to the cache. Without arguments, this method returns a
-list of all cache elements.
-
-=cut
-
-sub item {
-    my ($self,%param) = @_;
-    if(%param) {
-        my $item = Pod::Cache::Item->new(%param);
-        push(@$self, $item);
-        return $item;
-    }
-    else {
-        return @{$self};
-    }
-}
-
-=item $cache-E<gt>find_page($name)
-
-Look for a POD document named C<$name> in the cache. Returns the
-reference to the corresponding Pod::Cache::Item object or undef if
-not found.
-
-=back
-
-=cut
-
-sub find_page {
-    my ($self,$page) = @_;
-    foreach(@$self) {
-        if($_->page() eq $page) {
-            return $_;
-        }
-    }
-    return;
-}
-
-package Pod::Cache::Item;
-
-=head2 Pod::Cache::Item
-
-B<Pod::Cache::Item> holds information about individual POD documents,
-that can be grouped in a Pod::Cache object.
-It is intended to hold information about the hyperlink nodes of POD
-documents.
-The following methods are available:
-
-=over 4
-
-=item Pod::Cache::Item-E<gt>new()
-
-Create a new object.
-
-=cut
-
-sub new {
-    my $this = shift;
-    my $class = ref($this) || $this;
-    my %params = @_;
-    my $self = {%params};
-    bless $self, $class;
-    $self->initialize();
-    return $self;
-}
-
-sub initialize {
-    my $self = shift;
-    $self->{-nodes} = [] unless(defined $self->{-nodes});
-}
-
-=item $cacheitem-E<gt>page()
-
-Set/retrieve the POD document name (e.g. "Pod::Parser").
-
-=cut
-
-# The POD page
-sub page {
-   return (@_ > 1) ? ($_[0]->{-page} = $_[1]) : $_[0]->{-page};
-}
-
-=item $cacheitem-E<gt>description()
-
-Set/retrieve the POD short description as found in the C<=head1 NAME>
-section.
-
-=cut
-
-# The POD description, taken out of NAME if present
-sub description {
-   return (@_ > 1) ? ($_[0]->{-description} = $_[1]) : $_[0]->{-description};
-}
-
-=item $cacheitem-E<gt>path()
-
-Set/retrieve the POD file storage path.
-
-=cut
-
-# The file path
-sub path {
-   return (@_ > 1) ? ($_[0]->{-path} = $_[1]) : $_[0]->{-path};
-}
-
-=item $cacheitem-E<gt>file()
-
-Set/retrieve the POD file name.
-
-=cut
-
-# The POD file name
-sub file {
-   return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};
-}
-
-=item $cacheitem-E<gt>nodes()
-
-Add a node (or a list of nodes) to the document's node list. Note that
-the order is kept, i.e. start with the first node and end with the last.
-If no argument is given, the current list of nodes is returned in the
-same order the nodes have been added.
-A node can be any scalar, but usually is a pair of node string and
-unique id for the C<find_node> method to work correctly.
-
-=cut
-
-# The POD nodes
-sub nodes {
-    my ($self,@nodes) = @_;
-    if(@nodes) {
-        push(@{$self->{-nodes}}, @nodes);
-        return @nodes;
-    }
-    else {
-        return @{$self->{-nodes}};
-    }
-}
-
-=item $cacheitem-E<gt>find_node($name)
-
-Look for a node or index entry named C<$name> in the object.
-Returns the unique id of the node (i.e. the second element of the array
-stored in the node array) or undef if not found.
-
-=cut
-
-sub find_node {
-    my ($self,$node) = @_;
-    my @search;
-    push(@search, @{$self->{-nodes}}) if($self->{-nodes});
-    push(@search, @{$self->{-idx}}) if($self->{-idx});
-    foreach(@search) {
-        if($_->[0] eq $node) {
-            return $_->[1]; # id
-        }
-    }
-    return;
-}
-
-=item $cacheitem-E<gt>idx()
-
-Add an index entry (or a list of them) to the document's index list. Note that
-the order is kept, i.e. start with the first node and end with the last.
-If no argument is given, the current list of index entries is returned in the
-same order the entries have been added.
-An index entry can be any scalar, but usually is a pair of string and
-unique id.
-
-=back
-
-=cut
-
-# The POD index entries
-sub idx {
-    my ($self,@idx) = @_;
-    if(@idx) {
-        push(@{$self->{-idx}}, @idx);
-        return @idx;
-    }
-    else {
-        return @{$self->{-idx}};
-    }
-}
-
-=head1 AUTHOR
-
-Please report bugs using L<http://rt.cpan.org>.
-
-Marek Rouchal E<lt>marekr@cpan.orgE<gt>, borrowing
-a lot of things from L<pod2man> and L<pod2roff> as well as other POD
-processing tools by Tom Christiansen, Brad Appleton and Russ Allbery.
-
-B<Pod::ParseUtils> is part of the L<Pod::Parser> distribution.
-
-=head1 SEE ALSO
-
-L<pod2man>, L<pod2roff>, L<Pod::Parser>, L<Pod::Checker>,
-L<pod2html>
-
-=cut
-
-1;
+#############################################################################

+# Pod/ParseUtils.pm -- helpers for POD parsing and conversion

+#

+# Copyright (C) 1999-2000 by Marek Rouchal. All rights reserved.

+# This file is part of "PodParser". PodParser is free software;

+# you can redistribute it and/or modify it under the same terms

+# as Perl itself.

+#############################################################################

+

+package Pod::ParseUtils;

+use strict;

+

+use vars qw($VERSION);

+$VERSION = '1.60'; ## Current version of this package

+require  5.005;    ## requires this Perl version or later

+

+=head1 NAME

+

+Pod::ParseUtils - helpers for POD parsing and conversion

+

+=head1 SYNOPSIS

+

+  use Pod::ParseUtils;

+

+  my $list = new Pod::List;

+  my $link = Pod::Hyperlink->new('Pod::Parser');

+

+=head1 DESCRIPTION

+

+B<Pod::ParseUtils> contains a few object-oriented helper packages for

+POD parsing and processing (i.e. in POD formatters and translators).

+

+=cut

+

+#-----------------------------------------------------------------------------

+# Pod::List

+#

+# class to hold POD list info (=over, =item, =back)

+#-----------------------------------------------------------------------------

+

+package Pod::List;

+

+use Carp;

+

+=head2 Pod::List

+

+B<Pod::List> can be used to hold information about POD lists

+(written as =over ... =item ... =back) for further processing.

+The following methods are available:

+

+=over 4

+

+=item Pod::List-E<gt>new()

+

+Create a new list object. Properties may be specified through a hash

+reference like this:

+

+  my $list = Pod::List->new({ -start => $., -indent => 4 });

+

+See the individual methods/properties for details.

+

+=cut

+

+sub new {

+    my $this = shift;

+    my $class = ref($this) || $this;

+    my %params = @_;

+    my $self = {%params};

+    bless $self, $class;

+    $self->initialize();

+    return $self;

+}

+

+sub initialize {

+    my $self = shift;

+    $self->{-file} ||= 'unknown';

+    $self->{-start} ||= 'unknown';

+    $self->{-indent} ||= 4; # perlpod: "should be the default"

+    $self->{_items} = [];

+    $self->{-type} ||= '';

+}

+

+=item $list-E<gt>file()

+

+Without argument, retrieves the file name the list is in. This must

+have been set before by either specifying B<-file> in the B<new()>

+method or by calling the B<file()> method with a scalar argument.

+

+=cut

+

+# The POD file name the list appears in

+sub file {

+   return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};

+}

+

+=item $list-E<gt>start()

+

+Without argument, retrieves the line number where the list started.

+This must have been set before by either specifying B<-start> in the

+B<new()> method or by calling the B<start()> method with a scalar

+argument.

+

+=cut

+

+# The line in the file the node appears

+sub start {

+   return (@_ > 1) ? ($_[0]->{-start} = $_[1]) : $_[0]->{-start};

+}

+

+=item $list-E<gt>indent()

+

+Without argument, retrieves the indent level of the list as specified

+in C<=over n>. This must have been set before by either specifying

+B<-indent> in the B<new()> method or by calling the B<indent()> method

+with a scalar argument.

+

+=cut

+

+# indent level

+sub indent {

+   return (@_ > 1) ? ($_[0]->{-indent} = $_[1]) : $_[0]->{-indent};

+}

+

+=item $list-E<gt>type()

+

+Without argument, retrieves the list type, which can be an arbitrary value,

+e.g. C<OL>, C<UL>, ... when thinking the HTML way.

+This must have been set before by either specifying

+B<-type> in the B<new()> method or by calling the B<type()> method

+with a scalar argument.

+

+=cut

+

+# The type of the list (UL, OL, ...)

+sub type {

+   return (@_ > 1) ? ($_[0]->{-type} = $_[1]) : $_[0]->{-type};

+}

+

+=item $list-E<gt>rx()

+

+Without argument, retrieves a regular expression for simplifying the 

+individual item strings once the list type has been determined. Usage:

+E.g. when converting to HTML, one might strip the leading number in

+an ordered list as C<E<lt>OLE<gt>> already prints numbers itself.

+This must have been set before by either specifying

+B<-rx> in the B<new()> method or by calling the B<rx()> method

+with a scalar argument.

+

+=cut

+

+# The regular expression to simplify the items

+sub rx {

+   return (@_ > 1) ? ($_[0]->{-rx} = $_[1]) : $_[0]->{-rx};

+}

+

+=item $list-E<gt>item()

+

+Without argument, retrieves the array of the items in this list.

+The items may be represented by any scalar.

+If an argument has been given, it is pushed on the list of items.

+

+=cut

+

+# The individual =items of this list

+sub item {

+    my ($self,$item) = @_;

+    if(defined $item) {

+        push(@{$self->{_items}}, $item);

+        return $item;

+    }

+    else {

+        return @{$self->{_items}};

+    }

+}

+

+=item $list-E<gt>parent()

+

+Without argument, retrieves information about the parent holding this

+list, which is represented as an arbitrary scalar.

+This must have been set before by either specifying

+B<-parent> in the B<new()> method or by calling the B<parent()> method

+with a scalar argument.

+

+=cut

+

+# possibility for parsers/translators to store information about the

+# lists's parent object

+sub parent {

+   return (@_ > 1) ? ($_[0]->{-parent} = $_[1]) : $_[0]->{-parent};

+}

+

+=item $list-E<gt>tag()

+

+Without argument, retrieves information about the list tag, which can be

+any scalar.

+This must have been set before by either specifying

+B<-tag> in the B<new()> method or by calling the B<tag()> method

+with a scalar argument.

+

+=back

+

+=cut

+

+# possibility for parsers/translators to store information about the

+# list's object

+sub tag {

+   return (@_ > 1) ? ($_[0]->{-tag} = $_[1]) : $_[0]->{-tag};

+}

+

+#-----------------------------------------------------------------------------

+# Pod::Hyperlink

+#

+# class to manipulate POD hyperlinks (L<>)

+#-----------------------------------------------------------------------------

+

+package Pod::Hyperlink;

+

+=head2 Pod::Hyperlink

+

+B<Pod::Hyperlink> is a class for manipulation of POD hyperlinks. Usage:

+

+  my $link = Pod::Hyperlink->new('alternative text|page/"section in page"');

+

+The B<Pod::Hyperlink> class is mainly designed to parse the contents of the

+C<LE<lt>...E<gt>> sequence, providing a simple interface for accessing the

+different parts of a POD hyperlink for further processing. It can also be

+used to construct hyperlinks.

+

+=over 4

+

+=item Pod::Hyperlink-E<gt>new()

+

+The B<new()> method can either be passed a set of key/value pairs or a single

+scalar value, namely the contents of a C<LE<lt>...E<gt>> sequence. An object

+of the class C<Pod::Hyperlink> is returned. The value C<undef> indicates a

+failure, the error message is stored in C<$@>.

+

+=cut

+

+use Carp;

+

+sub new {

+    my $this = shift;

+    my $class = ref($this) || $this;

+    my $self = +{};

+    bless $self, $class;

+    $self->initialize();

+    if(defined $_[0]) {

+        if(ref($_[0])) {

+            # called with a list of parameters

+            %$self = %{$_[0]};

+            $self->_construct_text();

+        }

+        else {

+            # called with L<> contents

+            return unless($self->parse($_[0]));

+        }

+    }

+    return $self;

+}

+

+sub initialize {

+    my $self = shift;

+    $self->{-line} ||= 'undef';

+    $self->{-file} ||= 'undef';

+    $self->{-page} ||= '';

+    $self->{-node} ||= '';

+    $self->{-alttext} ||= '';

+    $self->{-type} ||= 'undef';

+    $self->{_warnings} = [];

+}

+

+=item $link-E<gt>parse($string)

+

+This method can be used to (re)parse a (new) hyperlink, i.e. the contents

+of a C<LE<lt>...E<gt>> sequence. The result is stored in the current object.

+Warnings are stored in the B<warnings> property.

+E.g. sections like C<LE<lt>open(2)E<gt>> are deprecated, as they do not point

+to Perl documents. C<LE<lt>DBI::foo(3p)E<gt>> is wrong as well, the manpage

+section can simply be dropped.

+

+=cut

+

+sub parse {

+    my $self = shift;

+    local($_) = $_[0];

+    # syntax check the link and extract destination

+    my ($alttext,$page,$node,$type,$quoted) = (undef,'','','',0);

+

+    $self->{_warnings} = [];

+

+    # collapse newlines with whitespace

+    s/\s*\n+\s*/ /g;

+

+    # strip leading/trailing whitespace

+    if(s/^[\s\n]+//) {

+        $self->warning('ignoring leading whitespace in link');

+    }

+    if(s/[\s\n]+$//) {

+        $self->warning('ignoring trailing whitespace in link');

+    }

+    unless(length($_)) {

+        _invalid_link('empty link');

+        return;

+    }

+

+    ## Check for different possibilities. This is tedious and error-prone

+    # we match all possibilities (alttext, page, section/item)

+    #warn "DEBUG: link=$_\n";

+

+    # only page

+    # problem: a lot of people use (), or (1) or the like to indicate

+    # man page sections. But this collides with L<func()> that is supposed

+    # to point to an internal funtion...

+    my $page_rx = '[\w.-]+(?:::[\w.-]+)*(?:[(](?:\d\w*|)[)]|)';

+    # page name only

+    if(/^($page_rx)$/o) {

+        $page = $1;

+        $type = 'page';

+    }

+    # alttext, page and "section"

+    elsif(m{^(.*?)\s*[|]\s*($page_rx)\s*/\s*"(.+)"$}o) {

+        ($alttext, $page, $node) = ($1, $2, $3);

+        $type = 'section';

+        $quoted = 1; #... therefore | and / are allowed

+    }

+    # alttext and page

+    elsif(/^(.*?)\s*[|]\s*($page_rx)$/o) {

+        ($alttext, $page) = ($1, $2);

+        $type = 'page';

+    }

+    # alttext and "section"

+    elsif(m{^(.*?)\s*[|]\s*(?:/\s*|)"(.+)"$}) {

+        ($alttext, $node) = ($1,$2);

+        $type = 'section';

+        $quoted = 1;

+    }

+    # page and "section"

+    elsif(m{^($page_rx)\s*/\s*"(.+)"$}o) {

+        ($page, $node) = ($1, $2);

+        $type = 'section';

+        $quoted = 1;

+    }

+    # page and item

+    elsif(m{^($page_rx)\s*/\s*(.+)$}o) {

+        ($page, $node) = ($1, $2);

+        $type = 'item';

+    }

+    # only "section"

+    elsif(m{^/?"(.+)"$}) {

+        $node = $1;

+        $type = 'section';

+        $quoted = 1;

+    }

+    # only item

+    elsif(m{^\s*/(.+)$}) {

+        $node = $1;

+        $type = 'item';

+    }

+

+    # non-standard: Hyperlink with alt-text - doesn't remove protocol prefix, maybe it should?

+    elsif(/^ \s* (.*?) \s* [|] \s* (\w+:[^:\s] [^\s|]*?) \s* $/ix) {

+      ($alttext,$node) = ($1,$2);

+      $type = 'hyperlink';

+    }

+

+    # non-standard: Hyperlink

+    elsif(/^(\w+:[^:\s]\S*)$/i) {

+        $node = $1;

+        $type = 'hyperlink';

+    }

+    # alttext, page and item

+    elsif(m{^(.*?)\s*[|]\s*($page_rx)\s*/\s*(.+)$}o) {

+        ($alttext, $page, $node) = ($1, $2, $3);

+        $type = 'item';

+    }

+    # alttext and item

+    elsif(m{^(.*?)\s*[|]\s*/(.+)$}) {

+        ($alttext, $node) = ($1,$2);

+    }

+    # must be an item or a "malformed" section (without "")

+    else {

+        $node = $_;

+        $type = 'item';

+    }

+    # collapse whitespace in nodes

+    $node =~ s/\s+/ /gs;

+

+    # empty alternative text expands to node name

+    if(defined $alttext) {

+        if(!length($alttext)) {

+          $alttext = $node || $page;

+        }

+    }

+    else {

+        $alttext = '';

+    }

+

+    if($page =~ /[(]\w*[)]$/) {

+        $self->warning("(section) in '$page' deprecated");

+    }

+    if(!$quoted && $node =~ m{[|/]} && $type ne 'hyperlink') {

+        $self->warning("node '$node' contains non-escaped | or /");

+    }

+    if($alttext =~ m{[|/]}) {

+        $self->warning("alternative text '$node' contains non-escaped | or /");

+    }

+    $self->{-page} = $page;

+    $self->{-node} = $node;

+    $self->{-alttext} = $alttext;

+    #warn "DEBUG: page=$page section=$section item=$item alttext=$alttext\n";

+    $self->{-type} = $type;

+    $self->_construct_text();

+    1;

+}

+

+sub _construct_text {

+    my $self = shift;

+    my $alttext = $self->alttext();

+    my $type = $self->type();

+    my $section = $self->node();

+    my $page = $self->page();

+    my $page_ext = '';

+    $page =~ s/([(]\w*[)])$// && ($page_ext = $1);

+    if($alttext) {

+        $self->{_text} = $alttext;

+    }

+    elsif($type eq 'hyperlink') {

+        $self->{_text} = $section;

+    }

+    else {

+        $self->{_text} = ($section || '') .

+            (($page && $section) ? ' in ' : '') .

+            "$page$page_ext";

+    }

+    # for being marked up later

+    # use the non-standard markers P<> and Q<>, so that the resulting

+    # text can be parsed by the translators. It's their job to put

+    # the correct hypertext around the linktext

+    if($alttext) {

+        $self->{_markup} = "Q<$alttext>";

+    }

+    elsif($type eq 'hyperlink') {

+        $self->{_markup} = "Q<$section>";

+    }

+    else {

+        $self->{_markup} = (!$section ? '' : "Q<$section>") .

+            ($page ? ($section ? ' in ':'') . "P<$page>$page_ext" : '');

+    }

+}

+

+=item $link-E<gt>markup($string)

+

+Set/retrieve the textual value of the link. This string contains special

+markers C<PE<lt>E<gt>> and C<QE<lt>E<gt>> that should be expanded by the

+translator's interior sequence expansion engine to the

+formatter-specific code to highlight/activate the hyperlink. The details

+have to be implemented in the translator.

+

+=cut

+

+#' retrieve/set markuped text

+sub markup {

+    return (@_ > 1) ? ($_[0]->{_markup} = $_[1]) : $_[0]->{_markup};

+}

+

+=item $link-E<gt>text()

+

+This method returns the textual representation of the hyperlink as above,

+but without markers (read only). Depending on the link type this is one of

+the following alternatives (the + and * denote the portions of the text

+that are marked up):

+

+  +perl+                    L<perl>

+  *$|* in +perlvar+         L<perlvar/$|>

+  *OPTIONS* in +perldoc+    L<perldoc/"OPTIONS">

+  *DESCRIPTION*             L<"DESCRIPTION">

+

+=cut

+

+# The complete link's text

+sub text {

+    return $_[0]->{_text};

+}

+

+=item $link-E<gt>warning()

+

+After parsing, this method returns any warnings encountered during the

+parsing process.

+

+=cut

+

+# Set/retrieve warnings

+sub warning {

+    my $self = shift;

+    if(@_) {

+        push(@{$self->{_warnings}}, @_);

+        return @_;

+    }

+    return @{$self->{_warnings}};

+}

+

+=item $link-E<gt>file()

+

+=item $link-E<gt>line()

+

+Just simple slots for storing information about the line and the file

+the link was encountered in. Has to be filled in manually.

+

+=cut

+

+# The line in the file the link appears

+sub line {

+    return (@_ > 1) ? ($_[0]->{-line} = $_[1]) : $_[0]->{-line};

+}

+

+# The POD file name the link appears in

+sub file {

+    return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};

+}

+

+=item $link-E<gt>page()

+

+This method sets or returns the POD page this link points to.

+

+=cut

+

+# The POD page the link appears on

+sub page {

+    if (@_ > 1) {

+        $_[0]->{-page} = $_[1];

+        $_[0]->_construct_text();

+    }

+    return $_[0]->{-page};

+}

+

+=item $link-E<gt>node()

+

+As above, but the destination node text of the link.

+

+=cut

+

+# The link destination

+sub node {

+    if (@_ > 1) {

+        $_[0]->{-node} = $_[1];

+        $_[0]->_construct_text();

+    }

+    return $_[0]->{-node};

+}

+

+=item $link-E<gt>alttext()

+

+Sets or returns an alternative text specified in the link.

+

+=cut

+

+# Potential alternative text

+sub alttext {

+    if (@_ > 1) {

+        $_[0]->{-alttext} = $_[1];

+        $_[0]->_construct_text();

+    }

+    return $_[0]->{-alttext};

+}

+

+=item $link-E<gt>type()

+

+The node type, either C<section> or C<item>. As an unofficial type,

+there is also C<hyperlink>, derived from e.g. C<LE<lt>http://perl.comE<gt>>

+

+=cut

+

+# The type: item or headn

+sub type {

+    return (@_ > 1) ? ($_[0]->{-type} = $_[1]) : $_[0]->{-type};

+}

+

+=item $link-E<gt>link()

+

+Returns the link as contents of C<LE<lt>E<gt>>. Reciprocal to B<parse()>.

+

+=back

+

+=cut

+

+# The link itself

+sub link {

+    my $self = shift;

+    my $link = $self->page() || '';

+    if($self->node()) {

+        my $node = $self->node();

+        $node =~ s/\|/E<verbar>/g;

+        $node =~ s{/}{E<sol>}g;

+        if($self->type() eq 'section') {

+            $link .= ($link ? '/' : '') . '"' . $node . '"';

+        }

+        elsif($self->type() eq 'hyperlink') {

+            $link = $self->node();

+        }

+        else { # item

+            $link .= '/' . $node;

+        }

+    }

+    if($self->alttext()) {

+        my $text = $self->alttext();

+        $text =~ s/\|/E<verbar>/g;

+        $text =~ s{/}{E<sol>}g;

+        $link = "$text|$link";

+    }

+    return $link;

+}

+

+sub _invalid_link {

+    my ($msg) = @_;

+    # this sets @_

+    #eval { die "$msg\n" };

+    #chomp $@;

+    $@ = $msg; # this seems to work, too!

+    return;

+}

+

+#-----------------------------------------------------------------------------

+# Pod::Cache

+#

+# class to hold POD page details

+#-----------------------------------------------------------------------------

+

+package Pod::Cache;

+

+=head2 Pod::Cache

+

+B<Pod::Cache> holds information about a set of POD documents,

+especially the nodes for hyperlinks.

+The following methods are available:

+

+=over 4

+

+=item Pod::Cache-E<gt>new()

+

+Create a new cache object. This object can hold an arbitrary number of

+POD documents of class Pod::Cache::Item.

+

+=cut

+

+sub new {

+    my $this = shift;

+    my $class = ref($this) || $this;

+    my $self = [];

+    bless $self, $class;

+    return $self;

+}

+

+=item $cache-E<gt>item()

+

+Add a new item to the cache. Without arguments, this method returns a

+list of all cache elements.

+

+=cut

+

+sub item {

+    my ($self,%param) = @_;

+    if(%param) {

+        my $item = Pod::Cache::Item->new(%param);

+        push(@$self, $item);

+        return $item;

+    }

+    else {

+        return @{$self};

+    }

+}

+

+=item $cache-E<gt>find_page($name)

+

+Look for a POD document named C<$name> in the cache. Returns the

+reference to the corresponding Pod::Cache::Item object or undef if

+not found.

+

+=back

+

+=cut

+

+sub find_page {

+    my ($self,$page) = @_;

+    foreach(@$self) {

+        if($_->page() eq $page) {

+            return $_;

+        }

+    }

+    return;

+}

+

+package Pod::Cache::Item;

+

+=head2 Pod::Cache::Item

+

+B<Pod::Cache::Item> holds information about individual POD documents,

+that can be grouped in a Pod::Cache object.

+It is intended to hold information about the hyperlink nodes of POD

+documents.

+The following methods are available:

+

+=over 4

+

+=item Pod::Cache::Item-E<gt>new()

+

+Create a new object.

+

+=cut

+

+sub new {

+    my $this = shift;

+    my $class = ref($this) || $this;

+    my %params = @_;

+    my $self = {%params};

+    bless $self, $class;

+    $self->initialize();

+    return $self;

+}

+

+sub initialize {

+    my $self = shift;

+    $self->{-nodes} = [] unless(defined $self->{-nodes});

+}

+

+=item $cacheitem-E<gt>page()

+

+Set/retrieve the POD document name (e.g. "Pod::Parser").

+

+=cut

+

+# The POD page

+sub page {

+   return (@_ > 1) ? ($_[0]->{-page} = $_[1]) : $_[0]->{-page};

+}

+

+=item $cacheitem-E<gt>description()

+

+Set/retrieve the POD short description as found in the C<=head1 NAME>

+section.

+

+=cut

+

+# The POD description, taken out of NAME if present

+sub description {

+   return (@_ > 1) ? ($_[0]->{-description} = $_[1]) : $_[0]->{-description};

+}

+

+=item $cacheitem-E<gt>path()

+

+Set/retrieve the POD file storage path.

+

+=cut

+

+# The file path

+sub path {

+   return (@_ > 1) ? ($_[0]->{-path} = $_[1]) : $_[0]->{-path};

+}

+

+=item $cacheitem-E<gt>file()

+

+Set/retrieve the POD file name.

+

+=cut

+

+# The POD file name

+sub file {

+   return (@_ > 1) ? ($_[0]->{-file} = $_[1]) : $_[0]->{-file};

+}

+

+=item $cacheitem-E<gt>nodes()

+

+Add a node (or a list of nodes) to the document's node list. Note that

+the order is kept, i.e. start with the first node and end with the last.

+If no argument is given, the current list of nodes is returned in the

+same order the nodes have been added.

+A node can be any scalar, but usually is a pair of node string and

+unique id for the C<find_node> method to work correctly.

+

+=cut

+

+# The POD nodes

+sub nodes {

+    my ($self,@nodes) = @_;

+    if(@nodes) {

+        push(@{$self->{-nodes}}, @nodes);

+        return @nodes;

+    }

+    else {

+        return @{$self->{-nodes}};

+    }

+}

+

+=item $cacheitem-E<gt>find_node($name)

+

+Look for a node or index entry named C<$name> in the object.

+Returns the unique id of the node (i.e. the second element of the array

+stored in the node array) or undef if not found.

+

+=cut

+

+sub find_node {

+    my ($self,$node) = @_;

+    my @search;

+    push(@search, @{$self->{-nodes}}) if($self->{-nodes});

+    push(@search, @{$self->{-idx}}) if($self->{-idx});

+    foreach(@search) {

+        if($_->[0] eq $node) {

+            return $_->[1]; # id

+        }

+    }

+    return;

+}

+

+=item $cacheitem-E<gt>idx()

+

+Add an index entry (or a list of them) to the document's index list. Note that

+the order is kept, i.e. start with the first node and end with the last.

+If no argument is given, the current list of index entries is returned in the

+same order the entries have been added.

+An index entry can be any scalar, but usually is a pair of string and

+unique id.

+

+=back

+

+=cut

+

+# The POD index entries

+sub idx {

+    my ($self,@idx) = @_;

+    if(@idx) {

+        push(@{$self->{-idx}}, @idx);

+        return @idx;

+    }

+    else {

+        return @{$self->{-idx}};

+    }

+}

+

+=head1 AUTHOR

+

+Please report bugs using L<http://rt.cpan.org>.

+

+Marek Rouchal E<lt>marekr@cpan.orgE<gt>, borrowing

+a lot of things from L<pod2man> and L<pod2roff> as well as other POD

+processing tools by Tom Christiansen, Brad Appleton and Russ Allbery.

+

+B<Pod::ParseUtils> is part of the L<Pod::Parser> distribution.

+

+=head1 SEE ALSO

+

+L<pod2man>, L<pod2roff>, L<Pod::Parser>, L<Pod::Checker>,

+L<pod2html>

+

+=cut

+

+1;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Parser.pm b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Parser.pm
index 9a6acd62f18..4b4fecfbdd0 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Parser.pm
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/lib/Pod/Parser.pm
@@ -1,1832 +1,1836 @@
-#############################################################################
-# Pod/Parser.pm -- package which defines a base class for parsing POD docs.
-#
-# Copyright (C) 1996-2000 by Bradford Appleton. All rights reserved.
-# This file is part of "PodParser". PodParser is free software;
-# you can redistribute it and/or modify it under the same terms
-# as Perl itself.
-#############################################################################
-
-package Pod::Parser;
-use strict;
-
-## These "variables" are used as local "glob aliases" for performance
-use vars qw($VERSION @ISA %myData %myOpts @input_stack);
-$VERSION = '1.51';  ## Current version of this package
-require  5.005;    ## requires this Perl version or later
-
-#############################################################################
-
-=head1 NAME
-
-Pod::Parser - base class for creating POD filters and translators
-
-=head1 SYNOPSIS
-
-    use Pod::Parser;
-
-    package MyParser;
-    @ISA = qw(Pod::Parser);
-
-    sub command { 
-        my ($parser, $command, $paragraph, $line_num) = @_;
-        ## Interpret the command and its text; sample actions might be:
-        if ($command eq 'head1') { ... }
-        elsif ($command eq 'head2') { ... }
-        ## ... other commands and their actions
-        my $out_fh = $parser->output_handle();
-        my $expansion = $parser->interpolate($paragraph, $line_num);
-        print $out_fh $expansion;
-    }
-
-    sub verbatim { 
-        my ($parser, $paragraph, $line_num) = @_;
-        ## Format verbatim paragraph; sample actions might be:
-        my $out_fh = $parser->output_handle();
-        print $out_fh $paragraph;
-    }
-
-    sub textblock { 
-        my ($parser, $paragraph, $line_num) = @_;
-        ## Translate/Format this block of text; sample actions might be:
-        my $out_fh = $parser->output_handle();
-        my $expansion = $parser->interpolate($paragraph, $line_num);
-        print $out_fh $expansion;
-    }
-
-    sub interior_sequence { 
-        my ($parser, $seq_command, $seq_argument) = @_;
-        ## Expand an interior sequence; sample actions might be:
-        return "*$seq_argument*"     if ($seq_command eq 'B');
-        return "`$seq_argument'"     if ($seq_command eq 'C');
-        return "_${seq_argument}_'"  if ($seq_command eq 'I');
-        ## ... other sequence commands and their resulting text
-    }
-
-    package main;
-
-    ## Create a parser object and have it parse file whose name was
-    ## given on the command-line (use STDIN if no files were given).
-    $parser = new MyParser();
-    $parser->parse_from_filehandle(\*STDIN)  if (@ARGV == 0);
-    for (@ARGV) { $parser->parse_from_file($_); }
-
-=head1 REQUIRES
-
-perl5.005, Pod::InputObjects, Exporter, Symbol, Carp
-
-=head1 EXPORTS
-
-Nothing.
-
-=head1 DESCRIPTION
-
-B<Pod::Parser> is a base class for creating POD filters and translators.
-It handles most of the effort involved with parsing the POD sections
-from an input stream, leaving subclasses free to be concerned only with
-performing the actual translation of text.
-
-B<Pod::Parser> parses PODs, and makes method calls to handle the various
-components of the POD. Subclasses of B<Pod::Parser> override these methods
-to translate the POD into whatever output format they desire.
-
-=head1 QUICK OVERVIEW
-
-To create a POD filter for translating POD documentation into some other
-format, you create a subclass of B<Pod::Parser> which typically overrides
-just the base class implementation for the following methods:
-
-=over 2
-
-=item *
-
-B<command()>
-
-=item *
-
-B<verbatim()>
-
-=item *
-
-B<textblock()>
-
-=item *
-
-B<interior_sequence()>
-
-=back
-
-You may also want to override the B<begin_input()> and B<end_input()>
-methods for your subclass (to perform any needed per-file and/or
-per-document initialization or cleanup).
-
-If you need to perform any preprocessing of input before it is parsed
-you may want to override one or more of B<preprocess_line()> and/or
-B<preprocess_paragraph()>.
-
-Sometimes it may be necessary to make more than one pass over the input
-files. If this is the case you have several options. You can make the
-first pass using B<Pod::Parser> and override your methods to store the
-intermediate results in memory somewhere for the B<end_pod()> method to
-process. You could use B<Pod::Parser> for several passes with an
-appropriate state variable to control the operation for each pass. If
-your input source can't be reset to start at the beginning, you can
-store it in some other structure as a string or an array and have that
-structure implement a B<getline()> method (which is all that
-B<parse_from_filehandle()> uses to read input).
-
-Feel free to add any member data fields you need to keep track of things
-like current font, indentation, horizontal or vertical position, or
-whatever else you like. Be sure to read L<"PRIVATE METHODS AND DATA">
-to avoid name collisions.
-
-For the most part, the B<Pod::Parser> base class should be able to
-do most of the input parsing for you and leave you free to worry about
-how to interpret the commands and translate the result.
-
-Note that all we have described here in this quick overview is the
-simplest most straightforward use of B<Pod::Parser> to do stream-based
-parsing. It is also possible to use the B<Pod::Parser::parse_text> function
-to do more sophisticated tree-based parsing. See L<"TREE-BASED PARSING">.
-
-=head1 PARSING OPTIONS
-
-A I<parse-option> is simply a named option of B<Pod::Parser> with a
-value that corresponds to a certain specified behavior. These various
-behaviors of B<Pod::Parser> may be enabled/disabled by setting
-or unsetting one or more I<parse-options> using the B<parseopts()> method.
-The set of currently accepted parse-options is as follows:
-
-=over 3
-
-=item B<-want_nonPODs> (default: unset)
-
-Normally (by default) B<Pod::Parser> will only provide access to
-the POD sections of the input. Input paragraphs that are not part
-of the POD-format documentation are not made available to the caller
-(not even using B<preprocess_paragraph()>). Setting this option to a
-non-empty, non-zero value will allow B<preprocess_paragraph()> to see
-non-POD sections of the input as well as POD sections. The B<cutting()>
-method can be used to determine if the corresponding paragraph is a POD
-paragraph, or some other input paragraph.
-
-=item B<-process_cut_cmd> (default: unset)
-
-Normally (by default) B<Pod::Parser> handles the C<=cut> POD directive
-by itself and does not pass it on to the caller for processing. Setting
-this option to a non-empty, non-zero value will cause B<Pod::Parser> to
-pass the C<=cut> directive to the caller just like any other POD command
-(and hence it may be processed by the B<command()> method).
-
-B<Pod::Parser> will still interpret the C<=cut> directive to mean that
-"cutting mode" has been (re)entered, but the caller will get a chance
-to capture the actual C<=cut> paragraph itself for whatever purpose
-it desires.
-
-=item B<-warnings> (default: unset)
-
-Normally (by default) B<Pod::Parser> recognizes a bare minimum of
-pod syntax errors and warnings and issues diagnostic messages
-for errors, but not for warnings. (Use B<Pod::Checker> to do more
-thorough checking of POD syntax.) Setting this option to a non-empty,
-non-zero value will cause B<Pod::Parser> to issue diagnostics for
-the few warnings it recognizes as well as the errors.
-
-=back
-
-Please see L<"parseopts()"> for a complete description of the interface
-for the setting and unsetting of parse-options.
-
-=cut
-
-#############################################################################
-
-#use diagnostics;
-use Pod::InputObjects;
-use Carp;
-use Exporter;
-BEGIN {
-   if ($] < 5.006) {
-      require Symbol;
-      import Symbol;
-   }
-}
-@ISA = qw(Exporter);
-
-#############################################################################
-
-=head1 RECOMMENDED SUBROUTINE/METHOD OVERRIDES
-
-B<Pod::Parser> provides several methods which most subclasses will probably
-want to override. These methods are as follows:
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head1 B<command()>
-
-            $parser->command($cmd,$text,$line_num,$pod_para);
-
-This method should be overridden by subclasses to take the appropriate
-action when a POD command paragraph (denoted by a line beginning with
-"=") is encountered. When such a POD directive is seen in the input,
-this method is called and is passed:
-
-=over 3
-
-=item C<$cmd>
-
-the name of the command for this POD paragraph
-
-=item C<$text>
-
-the paragraph text for the given POD paragraph command.
-
-=item C<$line_num>
-
-the line-number of the beginning of the paragraph
-
-=item C<$pod_para>
-
-a reference to a C<Pod::Paragraph> object which contains further
-information about the paragraph command (see L<Pod::InputObjects>
-for details).
-
-=back
-
-B<Note> that this method I<is> called for C<=pod> paragraphs.
-
-The base class implementation of this method simply treats the raw POD
-command as normal block of paragraph text (invoking the B<textblock()>
-method with the command paragraph).
-
-=cut
-
-sub command {
-    my ($self, $cmd, $text, $line_num, $pod_para)  = @_;
-    ## Just treat this like a textblock
-    $self->textblock($pod_para->raw_text(), $line_num, $pod_para);
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<verbatim()>
-
-            $parser->verbatim($text,$line_num,$pod_para);
-
-This method may be overridden by subclasses to take the appropriate
-action when a block of verbatim text is encountered. It is passed the
-following parameters:
-
-=over 3
-
-=item C<$text>
-
-the block of text for the verbatim paragraph
-
-=item C<$line_num>
-
-the line-number of the beginning of the paragraph
-
-=item C<$pod_para>
-
-a reference to a C<Pod::Paragraph> object which contains further
-information about the paragraph (see L<Pod::InputObjects>
-for details).
-
-=back
-
-The base class implementation of this method simply prints the textblock
-(unmodified) to the output filehandle.
-
-=cut
-
-sub verbatim {
-    my ($self, $text, $line_num, $pod_para) = @_;
-    my $out_fh = $self->{_OUTPUT};
-    print $out_fh $text;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<textblock()>
-
-            $parser->textblock($text,$line_num,$pod_para);
-
-This method may be overridden by subclasses to take the appropriate
-action when a normal block of POD text is encountered (although the base
-class method will usually do what you want). It is passed the following
-parameters:
-
-=over 3
-
-=item C<$text>
-
-the block of text for the a POD paragraph
-
-=item C<$line_num>
-
-the line-number of the beginning of the paragraph
-
-=item C<$pod_para>
-
-a reference to a C<Pod::Paragraph> object which contains further
-information about the paragraph (see L<Pod::InputObjects>
-for details).
-
-=back
-
-In order to process interior sequences, subclasses implementations of
-this method will probably want to invoke either B<interpolate()> or
-B<parse_text()>, passing it the text block C<$text>, and the corresponding
-line number in C<$line_num>, and then perform any desired processing upon
-the returned result.
-
-The base class implementation of this method simply prints the text block
-as it occurred in the input stream).
-
-=cut
-
-sub textblock {
-    my ($self, $text, $line_num, $pod_para) = @_;
-    my $out_fh = $self->{_OUTPUT};
-    print $out_fh $self->interpolate($text, $line_num);
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<interior_sequence()>
-
-            $parser->interior_sequence($seq_cmd,$seq_arg,$pod_seq);
-
-This method should be overridden by subclasses to take the appropriate
-action when an interior sequence is encountered. An interior sequence is
-an embedded command within a block of text which appears as a command
-name (usually a single uppercase character) followed immediately by a
-string of text which is enclosed in angle brackets. This method is
-passed the sequence command C<$seq_cmd> and the corresponding text
-C<$seq_arg>. It is invoked by the B<interpolate()> method for each interior
-sequence that occurs in the string that it is passed. It should return
-the desired text string to be used in place of the interior sequence.
-The C<$pod_seq> argument is a reference to a C<Pod::InteriorSequence>
-object which contains further information about the interior sequence.
-Please see L<Pod::InputObjects> for details if you need to access this
-additional information.
-
-Subclass implementations of this method may wish to invoke the 
-B<nested()> method of C<$pod_seq> to see if it is nested inside
-some other interior-sequence (and if so, which kind).
-
-The base class implementation of the B<interior_sequence()> method
-simply returns the raw text of the interior sequence (as it occurred
-in the input) to the caller.
-
-=cut
-
-sub interior_sequence {
-    my ($self, $seq_cmd, $seq_arg, $pod_seq) = @_;
-    ## Just return the raw text of the interior sequence
-    return  $pod_seq->raw_text();
-}
-
-#############################################################################
-
-=head1 OPTIONAL SUBROUTINE/METHOD OVERRIDES
-
-B<Pod::Parser> provides several methods which subclasses may want to override
-to perform any special pre/post-processing. These methods do I<not> have to
-be overridden, but it may be useful for subclasses to take advantage of them.
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head1 B<new()>
-
-            my $parser = Pod::Parser->new();
-
-This is the constructor for B<Pod::Parser> and its subclasses. You
-I<do not> need to override this method! It is capable of constructing
-subclass objects as well as base class objects, provided you use
-any of the following constructor invocation styles:
-
-    my $parser1 = MyParser->new();
-    my $parser2 = new MyParser();
-    my $parser3 = $parser2->new();
-
-where C<MyParser> is some subclass of B<Pod::Parser>.
-
-Using the syntax C<MyParser::new()> to invoke the constructor is I<not>
-recommended, but if you insist on being able to do this, then the
-subclass I<will> need to override the B<new()> constructor method. If
-you do override the constructor, you I<must> be sure to invoke the
-B<initialize()> method of the newly blessed object.
-
-Using any of the above invocations, the first argument to the
-constructor is always the corresponding package name (or object
-reference). No other arguments are required, but if desired, an
-associative array (or hash-table) my be passed to the B<new()>
-constructor, as in:
-
-    my $parser1 = MyParser->new( MYDATA => $value1, MOREDATA => $value2 );
-    my $parser2 = new MyParser( -myflag => 1 );
-
-All arguments passed to the B<new()> constructor will be treated as
-key/value pairs in a hash-table. The newly constructed object will be
-initialized by copying the contents of the given hash-table (which may
-have been empty). The B<new()> constructor for this class and all of its
-subclasses returns a blessed reference to the initialized object (hash-table).
-
-=cut
-
-sub new {
-    ## Determine if we were called via an object-ref or a classname
-    my ($this,%params) = @_;
-    my $class = ref($this) || $this;
-    ## Any remaining arguments are treated as initial values for the
-    ## hash that is used to represent this object.
-    my $self = { %params };
-    ## Bless ourselves into the desired class and perform any initialization
-    bless $self, $class;
-    $self->initialize();
-    return $self;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<initialize()>
-
-            $parser->initialize();
-
-This method performs any necessary object initialization. It takes no
-arguments (other than the object instance of course, which is typically
-copied to a local variable named C<$self>). If subclasses override this
-method then they I<must> be sure to invoke C<$self-E<gt>SUPER::initialize()>.
-
-=cut
-
-sub initialize {
-    #my $self = shift;
-    #return;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<begin_pod()>
-
-            $parser->begin_pod();
-
-This method is invoked at the beginning of processing for each POD
-document that is encountered in the input. Subclasses should override
-this method to perform any per-document initialization.
-
-=cut
-
-sub begin_pod {
-    #my $self = shift;
-    #return;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<begin_input()>
-
-            $parser->begin_input();
-
-This method is invoked by B<parse_from_filehandle()> immediately I<before>
-processing input from a filehandle. The base class implementation does
-nothing, however, subclasses may override it to perform any per-file
-initializations.
-
-Note that if multiple files are parsed for a single POD document
-(perhaps the result of some future C<=include> directive) this method
-is invoked for every file that is parsed. If you wish to perform certain
-initializations once per document, then you should use B<begin_pod()>.
-
-=cut
-
-sub begin_input {
-    #my $self = shift;
-    #return;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<end_input()>
-
-            $parser->end_input();
-
-This method is invoked by B<parse_from_filehandle()> immediately I<after>
-processing input from a filehandle. The base class implementation does
-nothing, however, subclasses may override it to perform any per-file
-cleanup actions.
-
-Please note that if multiple files are parsed for a single POD document
-(perhaps the result of some kind of C<=include> directive) this method
-is invoked for every file that is parsed. If you wish to perform certain
-cleanup actions once per document, then you should use B<end_pod()>.
-
-=cut
-
-sub end_input {
-    #my $self = shift;
-    #return;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<end_pod()>
-
-            $parser->end_pod();
-
-This method is invoked at the end of processing for each POD document
-that is encountered in the input. Subclasses should override this method
-to perform any per-document finalization.
-
-=cut
-
-sub end_pod {
-    #my $self = shift;
-    #return;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<preprocess_line()>
-
-          $textline = $parser->preprocess_line($text, $line_num);
-
-This method should be overridden by subclasses that wish to perform
-any kind of preprocessing for each I<line> of input (I<before> it has
-been determined whether or not it is part of a POD paragraph). The
-parameter C<$text> is the input line; and the parameter C<$line_num> is
-the line number of the corresponding text line.
-
-The value returned should correspond to the new text to use in its
-place.  If the empty string or an undefined value is returned then no
-further processing will be performed for this line.
-
-Please note that the B<preprocess_line()> method is invoked I<before>
-the B<preprocess_paragraph()> method. After all (possibly preprocessed)
-lines in a paragraph have been assembled together and it has been
-determined that the paragraph is part of the POD documentation from one
-of the selected sections, then B<preprocess_paragraph()> is invoked.
-
-The base class implementation of this method returns the given text.
-
-=cut
-
-sub preprocess_line {
-    my ($self, $text, $line_num) = @_;
-    return  $text;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<preprocess_paragraph()>
-
-            $textblock = $parser->preprocess_paragraph($text, $line_num);
-
-This method should be overridden by subclasses that wish to perform any
-kind of preprocessing for each block (paragraph) of POD documentation
-that appears in the input stream. The parameter C<$text> is the POD
-paragraph from the input file; and the parameter C<$line_num> is the
-line number for the beginning of the corresponding paragraph.
-
-The value returned should correspond to the new text to use in its
-place If the empty string is returned or an undefined value is
-returned, then the given C<$text> is ignored (not processed).
-
-This method is invoked after gathering up all the lines in a paragraph
-and after determining the cutting state of the paragraph,
-but before trying to further parse or interpret them. After
-B<preprocess_paragraph()> returns, the current cutting state (which
-is returned by C<$self-E<gt>cutting()>) is examined. If it evaluates
-to true then input text (including the given C<$text>) is cut (not
-processed) until the next POD directive is encountered.
-
-Please note that the B<preprocess_line()> method is invoked I<before>
-the B<preprocess_paragraph()> method. After all (possibly preprocessed)
-lines in a paragraph have been assembled together and either it has been
-determined that the paragraph is part of the POD documentation from one
-of the selected sections or the C<-want_nonPODs> option is true,
-then B<preprocess_paragraph()> is invoked.
-
-The base class implementation of this method returns the given text.
-
-=cut
-
-sub preprocess_paragraph {
-    my ($self, $text, $line_num) = @_;
-    return  $text;
-}
-
-#############################################################################
-
-=head1 METHODS FOR PARSING AND PROCESSING
-
-B<Pod::Parser> provides several methods to process input text. These
-methods typically won't need to be overridden (and in some cases they
-can't be overridden), but subclasses may want to invoke them to exploit
-their functionality.
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head1 B<parse_text()>
-
-            $ptree1 = $parser->parse_text($text, $line_num);
-            $ptree2 = $parser->parse_text({%opts}, $text, $line_num);
-            $ptree3 = $parser->parse_text(\%opts, $text, $line_num);
-
-This method is useful if you need to perform your own interpolation 
-of interior sequences and can't rely upon B<interpolate> to expand
-them in simple bottom-up order.
-
-The parameter C<$text> is a string or block of text to be parsed
-for interior sequences; and the parameter C<$line_num> is the
-line number corresponding to the beginning of C<$text>.
-
-B<parse_text()> will parse the given text into a parse-tree of "nodes."
-and interior-sequences.  Each "node" in the parse tree is either a
-text-string, or a B<Pod::InteriorSequence>.  The result returned is a
-parse-tree of type B<Pod::ParseTree>. Please see L<Pod::InputObjects>
-for more information about B<Pod::InteriorSequence> and B<Pod::ParseTree>.
-
-If desired, an optional hash-ref may be specified as the first argument
-to customize certain aspects of the parse-tree that is created and
-returned. The set of recognized option keywords are:
-
-=over 3
-
-=item B<-expand_seq> =E<gt> I<code-ref>|I<method-name>
-
-Normally, the parse-tree returned by B<parse_text()> will contain an
-unexpanded C<Pod::InteriorSequence> object for each interior-sequence
-encountered. Specifying B<-expand_seq> tells B<parse_text()> to "expand"
-every interior-sequence it sees by invoking the referenced function
-(or named method of the parser object) and using the return value as the
-expanded result.
-
-If a subroutine reference was given, it is invoked as:
-
-  &$code_ref( $parser, $sequence )
-
-and if a method-name was given, it is invoked as:
-
-  $parser->method_name( $sequence )
-
-where C<$parser> is a reference to the parser object, and C<$sequence>
-is a reference to the interior-sequence object.
-[I<NOTE>: If the B<interior_sequence()> method is specified, then it is
-invoked according to the interface specified in L<"interior_sequence()">].
-
-=item B<-expand_text> =E<gt> I<code-ref>|I<method-name>
-
-Normally, the parse-tree returned by B<parse_text()> will contain a
-text-string for each contiguous sequence of characters outside of an
-interior-sequence. Specifying B<-expand_text> tells B<parse_text()> to
-"preprocess" every such text-string it sees by invoking the referenced
-function (or named method of the parser object) and using the return value
-as the preprocessed (or "expanded") result. [Note that if the result is
-an interior-sequence, then it will I<not> be expanded as specified by the
-B<-expand_seq> option; Any such recursive expansion needs to be handled by
-the specified callback routine.]
-
-If a subroutine reference was given, it is invoked as:
-
-  &$code_ref( $parser, $text, $ptree_node )
-
-and if a method-name was given, it is invoked as:
-
-  $parser->method_name( $text, $ptree_node )
-
-where C<$parser> is a reference to the parser object, C<$text> is the
-text-string encountered, and C<$ptree_node> is a reference to the current
-node in the parse-tree (usually an interior-sequence object or else the
-top-level node of the parse-tree).
-
-=item B<-expand_ptree> =E<gt> I<code-ref>|I<method-name>
-
-Rather than returning a C<Pod::ParseTree>, pass the parse-tree as an
-argument to the referenced subroutine (or named method of the parser
-object) and return the result instead of the parse-tree object.
-
-If a subroutine reference was given, it is invoked as:
-
-  &$code_ref( $parser, $ptree )
-
-and if a method-name was given, it is invoked as:
-
-  $parser->method_name( $ptree )
-
-where C<$parser> is a reference to the parser object, and C<$ptree>
-is a reference to the parse-tree object.
-
-=back
-
-=cut
-
-sub parse_text {
-    my $self = shift;
-    local $_ = '';
-
-    ## Get options and set any defaults
-    my %opts = (ref $_[0]) ? %{ shift() } : ();
-    my $expand_seq   = $opts{'-expand_seq'}   || undef;
-    my $expand_text  = $opts{'-expand_text'}  || undef;
-    my $expand_ptree = $opts{'-expand_ptree'} || undef;
-
-    my $text = shift;
-    my $line = shift;
-    my $file = $self->input_file();
-    my $cmd  = "";
-
-    ## Convert method calls into closures, for our convenience
-    my $xseq_sub   = $expand_seq;
-    my $xtext_sub  = $expand_text;
-    my $xptree_sub = $expand_ptree;
-    if (defined $expand_seq  and  $expand_seq eq 'interior_sequence') {
-        ## If 'interior_sequence' is the method to use, we have to pass
-        ## more than just the sequence object, we also need to pass the
-        ## sequence name and text.
-        $xseq_sub = sub {
-            my ($sself, $iseq) = @_;
-            my $args = join('', $iseq->parse_tree->children);
-            return  $sself->interior_sequence($iseq->name, $args, $iseq);
-        };
-    }
-    ref $xseq_sub    or  $xseq_sub   = sub { shift()->$expand_seq(@_) };
-    ref $xtext_sub   or  $xtext_sub  = sub { shift()->$expand_text(@_) };
-    ref $xptree_sub  or  $xptree_sub = sub { shift()->$expand_ptree(@_) };
-
-    ## Keep track of the "current" interior sequence, and maintain a stack
-    ## of "in progress" sequences.
-    ##
-    ## NOTE that we push our own "accumulator" at the very beginning of the
-    ## stack. It's really a parse-tree, not a sequence; but it implements
-    ## the methods we need so we can use it to gather-up all the sequences
-    ## and strings we parse. Thus, by the end of our parsing, it should be
-    ## the only thing left on our stack and all we have to do is return it!
-    ##
-    my $seq       = Pod::ParseTree->new();
-    my @seq_stack = ($seq);
-    my ($ldelim, $rdelim) = ('', '');
-
-    ## Iterate over all sequence starts text (NOTE: split with
-    ## capturing parens keeps the delimiters)
-    $_ = $text;
-    my @tokens = split /([A-Z]<(?:<+(?:\r?\n|[ \t]))?)/;
-    while ( @tokens ) {
-        $_ = shift @tokens;
-        ## Look for the beginning of a sequence
-        if ( /^([A-Z])(<(?:<+(?:\r?\n|[ \t]))?)$/ ) {
-            ## Push a new sequence onto the stack of those "in-progress"
-            my $ldelim_orig;
-            ($cmd, $ldelim_orig) = ($1, $2);
-            ($ldelim = $ldelim_orig) =~ s/\s+$//;
-            ($rdelim = $ldelim) =~ tr/</>/;
-            $seq = Pod::InteriorSequence->new(
-                       -name   => $cmd,
-                       -ldelim => $ldelim_orig,  -rdelim => $rdelim,
-                       -file   => $file,    -line   => $line
-                   );
-            (@seq_stack > 1)  and  $seq->nested($seq_stack[-1]);
-            push @seq_stack, $seq;
-        }
-        ## Look for sequence ending
-        elsif ( @seq_stack > 1 ) {
-            ## Make sure we match the right kind of closing delimiter
-            my ($seq_end, $post_seq) = ('', '');
-            if ( ($ldelim eq '<'   and  /\A(.*?)(>)/s)
-                 or  /\A(.*?)(\s+$rdelim)/s )
-            {
-                ## Found end-of-sequence, capture the interior and the
-                ## closing the delimiter, and put the rest back on the
-                ## token-list
-                $post_seq = substr($_, length($1) + length($2));
-                ($_, $seq_end) = ($1, $2);
-                (length $post_seq)  and  unshift @tokens, $post_seq;
-            }
-            if (length) {
-                ## In the middle of a sequence, append this text to it, and
-                ## dont forget to "expand" it if that's what the caller wanted
-                $seq->append($expand_text ? &$xtext_sub($self,$_,$seq) : $_);
-                $_ .= $seq_end;
-            }
-            if (length $seq_end) {
-                ## End of current sequence, record terminating delimiter
-                $seq->rdelim($seq_end);
-                ## Pop it off the stack of "in progress" sequences
-                pop @seq_stack;
-                ## Append result to its parent in current parse tree
-                $seq_stack[-1]->append($expand_seq ? &$xseq_sub($self,$seq)
-                                                   : $seq);
-                ## Remember the current cmd-name and left-delimiter
-                if(@seq_stack > 1) {
-                    $cmd = $seq_stack[-1]->name;
-                    $ldelim = $seq_stack[-1]->ldelim;
-                    $rdelim = $seq_stack[-1]->rdelim;
-                } else {
-                    $cmd = $ldelim = $rdelim = '';
-                }
-            }
-        }
-        elsif (length) {
-            ## In the middle of a sequence, append this text to it, and
-            ## dont forget to "expand" it if that's what the caller wanted
-            $seq->append($expand_text ? &$xtext_sub($self,$_,$seq) : $_);
-        }
-        ## Keep track of line count
-        $line += /\n/;
-        ## Remember the "current" sequence
-        $seq = $seq_stack[-1];
-    }
-
-    ## Handle unterminated sequences
-    my $errorsub = (@seq_stack > 1) ? $self->errorsub() : undef;
-    while (@seq_stack > 1) {
-       ($cmd, $file, $line) = ($seq->name, $seq->file_line);
-       $ldelim  = $seq->ldelim;
-       ($rdelim = $ldelim) =~ tr/</>/;
-       $rdelim  =~ s/^(\S+)(\s*)$/$2$1/;
-       pop @seq_stack;
-       my $errmsg = "*** ERROR: unterminated ${cmd}${ldelim}...${rdelim}".
-                    " at line $line in file $file\n";
-       (ref $errorsub) and &{$errorsub}($errmsg)
-           or (defined $errorsub) and $self->$errorsub($errmsg)
-               or  carp($errmsg);
-       $seq_stack[-1]->append($expand_seq ? &$xseq_sub($self,$seq) : $seq);
-       $seq = $seq_stack[-1];
-    }
-
-    ## Return the resulting parse-tree
-    my $ptree = (pop @seq_stack)->parse_tree;
-    return  $expand_ptree ? &$xptree_sub($self, $ptree) : $ptree;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<interpolate()>
-
-            $textblock = $parser->interpolate($text, $line_num);
-
-This method translates all text (including any embedded interior sequences)
-in the given text string C<$text> and returns the interpolated result. The
-parameter C<$line_num> is the line number corresponding to the beginning
-of C<$text>.
-
-B<interpolate()> merely invokes a private method to recursively expand
-nested interior sequences in bottom-up order (innermost sequences are
-expanded first). If there is a need to expand nested sequences in
-some alternate order, use B<parse_text> instead.
-
-=cut
-
-sub interpolate {
-    my($self, $text, $line_num) = @_;
-    my %parse_opts = ( -expand_seq => 'interior_sequence' );
-    my $ptree = $self->parse_text( \%parse_opts, $text, $line_num );
-    return  join '', $ptree->children();
-}
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head1 B<parse_paragraph()>
-
-            $parser->parse_paragraph($text, $line_num);
-
-This method takes the text of a POD paragraph to be processed, along
-with its corresponding line number, and invokes the appropriate method
-(one of B<command()>, B<verbatim()>, or B<textblock()>).
-
-For performance reasons, this method is invoked directly without any
-dynamic lookup; Hence subclasses may I<not> override it!
-
-=end __PRIVATE__
-
-=cut
-
-sub parse_paragraph {
-    my ($self, $text, $line_num) = @_;
-    local *myData = $self;  ## alias to avoid deref-ing overhead
-    local *myOpts = ($myData{_PARSEOPTS} ||= {});  ## get parse-options
-    local $_;
-
-    ## See if we want to preprocess nonPOD paragraphs as well as POD ones.
-    my $wantNonPods = $myOpts{'-want_nonPODs'};
-
-    ## Update cutting status
-    $myData{_CUTTING} = 0 if $text =~ /^={1,2}\S/;
-
-    ## Perform any desired preprocessing if we wanted it this early
-    $wantNonPods  and  $text = $self->preprocess_paragraph($text, $line_num);
-
-    ## Ignore up until next POD directive if we are cutting
-    return if $myData{_CUTTING};
-
-    ## Now we know this is block of text in a POD section!
-
-    ##-----------------------------------------------------------------
-    ## This is a hook (hack ;-) for Pod::Select to do its thing without
-    ## having to override methods, but also without Pod::Parser assuming
-    ## $self is an instance of Pod::Select (if the _SELECTED_SECTIONS
-    ## field exists then we assume there is an is_selected() method for
-    ## us to invoke (calling $self->can('is_selected') could verify this
-    ## but that is more overhead than I want to incur)
-    ##-----------------------------------------------------------------
-
-    ## Ignore this block if it isnt in one of the selected sections
-    if (exists $myData{_SELECTED_SECTIONS}) {
-        $self->is_selected($text)  or  return ($myData{_CUTTING} = 1);
-    }
-
-    ## If we havent already, perform any desired preprocessing and
-    ## then re-check the "cutting" state
-    unless ($wantNonPods) {
-       $text = $self->preprocess_paragraph($text, $line_num);
-       return 1  unless ((defined $text) and (length $text));
-       return 1  if ($myData{_CUTTING});
-    }
-
-    ## Look for one of the three types of paragraphs
-    my ($pfx, $cmd, $arg, $sep) = ('', '', '', '');
-    my $pod_para = undef;
-    if ($text =~ /^(={1,2})(?=\S)/) {
-        ## Looks like a command paragraph. Capture the command prefix used
-        ## ("=" or "=="), as well as the command-name, its paragraph text,
-        ## and whatever sequence of characters was used to separate them
-        $pfx = $1;
-        $_ = substr($text, length $pfx);
-        ($cmd, $sep, $text) = split /(\s+)/, $_, 2;
-        $sep = '' unless defined $sep;
-        $text = '' unless defined $text;
-        ## If this is a "cut" directive then we dont need to do anything
-        ## except return to "cutting" mode.
-        if ($cmd eq 'cut') {
-           $myData{_CUTTING} = 1;
-           return  unless $myOpts{'-process_cut_cmd'};
-        }
-    }
-    ## Save the attributes indicating how the command was specified.
-    $pod_para = new Pod::Paragraph(
-          -name      => $cmd,
-          -text      => $text,
-          -prefix    => $pfx,
-          -separator => $sep,
-          -file      => $myData{_INFILE},
-          -line      => $line_num
-    );
-    # ## Invoke appropriate callbacks
-    # if (exists $myData{_CALLBACKS}) {
-    #    ## Look through the callback list, invoke callbacks,
-    #    ## then see if we need to do the default actions
-    #    ## (invoke_callbacks will return true if we do).
-    #    return  1  unless $self->invoke_callbacks($cmd, $text, $line_num, $pod_para);
-    # }
-
-    # If the last paragraph ended in whitespace, and we're not between verbatim blocks, carp
-    if ($myData{_WHITESPACE} and $myOpts{'-warnings'}
-            and not ($text =~ /^\s+/ and ($myData{_PREVIOUS}||"") eq "verbatim")) {
-        my $errorsub = $self->errorsub();
-        my $line = $line_num - 1;
-        my $errmsg = "*** WARNING: line containing nothing but whitespace".
-                     " in paragraph at line $line in file $myData{_INFILE}\n";
-        (ref $errorsub) and &{$errorsub}($errmsg)
-            or (defined $errorsub) and $self->$errorsub($errmsg)
-                or  carp($errmsg);
-    }
-
-    if (length $cmd) {
-        ## A command paragraph
-        $self->command($cmd, $text, $line_num, $pod_para);
-        $myData{_PREVIOUS} = $cmd;
-    }
-    elsif ($text =~ /^\s+/) {
-        ## Indented text - must be a verbatim paragraph
-        $self->verbatim($text, $line_num, $pod_para);
-        $myData{_PREVIOUS} = "verbatim";
-    }
-    else {
-        ## Looks like an ordinary block of text
-        $self->textblock($text, $line_num, $pod_para);
-        $myData{_PREVIOUS} = "textblock";
-    }
-
-    # Update the whitespace for the next time around
-    #$myData{_WHITESPACE} = $text =~ /^[^\S\r\n]+\Z/m ? 1 : 0;
-    $myData{_WHITESPACE} = $text =~ /^[^\S\r\n]+\r*\Z/m ? 1 : 0;
-
-    return  1;
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<parse_from_filehandle()>
-
-            $parser->parse_from_filehandle($in_fh,$out_fh);
-
-This method takes an input filehandle (which is assumed to already be
-opened for reading) and reads the entire input stream looking for blocks
-(paragraphs) of POD documentation to be processed. If no first argument
-is given the default input filehandle C<STDIN> is used.
-
-The C<$in_fh> parameter may be any object that provides a B<getline()>
-method to retrieve a single line of input text (hence, an appropriate
-wrapper object could be used to parse PODs from a single string or an
-array of strings).
-
-Using C<$in_fh-E<gt>getline()>, input is read line-by-line and assembled
-into paragraphs or "blocks" (which are separated by lines containing
-nothing but whitespace). For each block of POD documentation
-encountered it will invoke a method to parse the given paragraph.
-
-If a second argument is given then it should correspond to a filehandle where
-output should be sent (otherwise the default output filehandle is
-C<STDOUT> if no output filehandle is currently in use).
-
-B<NOTE:> For performance reasons, this method caches the input stream at
-the top of the stack in a local variable. Any attempts by clients to
-change the stack contents during processing when in the midst executing
-of this method I<will not affect> the input stream used by the current
-invocation of this method.
-
-This method does I<not> usually need to be overridden by subclasses.
-
-=cut
-
-sub parse_from_filehandle {
-    my $self = shift;
-    my %opts = (ref $_[0] eq 'HASH') ? %{ shift() } : ();
-    my ($in_fh, $out_fh) = @_;
-    $in_fh = \*STDIN  unless ($in_fh);
-    local *myData = $self;  ## alias to avoid deref-ing overhead
-    local *myOpts = ($myData{_PARSEOPTS} ||= {});  ## get parse-options
-    local $_;
-
-    ## Put this stream at the top of the stack and do beginning-of-input
-    ## processing. NOTE that $in_fh might be reset during this process.
-    my $topstream = $self->_push_input_stream($in_fh, $out_fh);
-    (exists $opts{-cutting})  and  $self->cutting( $opts{-cutting} );
-
-    ## Initialize line/paragraph
-    my ($textline, $paragraph) = ('', '');
-    my ($nlines, $plines) = (0, 0);
-
-    ## Use <$fh> instead of $fh->getline where possible (for speed)
-    $_ = ref $in_fh;
-    my $tied_fh = (/^(?:GLOB|FileHandle|IO::\w+)$/  or  tied $in_fh);
-
-    ## Read paragraphs line-by-line
-    while (defined ($textline = $tied_fh ? <$in_fh> : $in_fh->getline)) {
-        $textline = $self->preprocess_line($textline, ++$nlines);
-        next  unless ((defined $textline)  &&  (length $textline));
-
-        if ((! length $paragraph) && ($textline =~ /^==/)) {
-            ## '==' denotes a one-line command paragraph
-            $paragraph = $textline;
-            $plines    = 1;
-            $textline  = '';
-        } else {
-            ## Append this line to the current paragraph
-            $paragraph .= $textline;
-            ++$plines;
-        }
-
-        ## See if this line is blank and ends the current paragraph.
-        ## If it isnt, then keep iterating until it is.
-        next unless (($textline =~ /^[^\S\r\n]*[\r\n]*$/)
-                                     && (length $paragraph));
-
-        ## Now process the paragraph
-        parse_paragraph($self, $paragraph, ($nlines - $plines) + 1);
-        $paragraph = '';
-        $plines = 0;
-    }
-    ## Dont forget about the last paragraph in the file
-    if (length $paragraph) {
-       parse_paragraph($self, $paragraph, ($nlines - $plines) + 1)
-    }
-
-    ## Now pop the input stream off the top of the input stack.
-    $self->_pop_input_stream();
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<parse_from_file()>
-
-            $parser->parse_from_file($filename,$outfile);
-
-This method takes a filename and does the following:
-
-=over 2
-
-=item *
-
-opens the input and output files for reading
-(creating the appropriate filehandles)
-
-=item *
-
-invokes the B<parse_from_filehandle()> method passing it the
-corresponding input and output filehandles.
-
-=item *
-
-closes the input and output files.
-
-=back
-
-If the special input filename "-" or "<&STDIN" is given then the STDIN
-filehandle is used for input (and no open or close is performed). If no
-input filename is specified then "-" is implied. Filehandle references,
-or objects that support the regular IO operations (like C<E<lt>$fhE<gt>>
-or C<$fh-<Egt>getline>) are also accepted; the handles must already be 
-opened.
-
-If a second argument is given then it should be the name of the desired
-output file. If the special output filename "-" or ">&STDOUT" is given
-then the STDOUT filehandle is used for output (and no open or close is
-performed). If the special output filename ">&STDERR" is given then the
-STDERR filehandle is used for output (and no open or close is
-performed). If no output filehandle is currently in use and no output
-filename is specified, then "-" is implied.
-Alternatively, filehandle references or objects that support the regular
-IO operations (like C<print>, e.g. L<IO::String>) are also accepted;
-the object must already be opened.
-
-This method does I<not> usually need to be overridden by subclasses.
-
-=cut
-
-sub parse_from_file {
-    my $self = shift;
-    my %opts = (ref $_[0] eq 'HASH') ? %{ shift() } : ();
-    my ($infile, $outfile) = @_;
-    my ($in_fh,  $out_fh);
-    if ($] < 5.006) {
-      ($in_fh,  $out_fh) = (gensym(), gensym());
-    }
-    my ($close_input, $close_output) = (0, 0);
-    local *myData = $self;
-    local *_;
-
-    ## Is $infile a filename or a (possibly implied) filehandle
-    if (defined $infile && ref $infile) {
-        if (ref($infile) =~ /^(SCALAR|ARRAY|HASH|CODE|REF)$/) {
-            croak "Input from $1 reference not supported!\n";
-        }
-        ## Must be a filehandle-ref (or else assume its a ref to an object
-        ## that supports the common IO read operations).
-        $myData{_INFILE} = ${$infile};
-        $in_fh = $infile;
-    }
-    elsif (!defined($infile) || !length($infile) || ($infile eq '-')
-        || ($infile =~ /^<&(?:STDIN|0)$/i))
-    {
-        ## Not a filename, just a string implying STDIN
-        $infile ||= '-';
-        $myData{_INFILE} = '<standard input>';
-        $in_fh = \*STDIN;
-    }
-    else {
-        ## We have a filename, open it for reading
-        $myData{_INFILE} = $infile;
-        open($in_fh, "< $infile")  or
-             croak "Can't open $infile for reading: $!\n";
-        $close_input = 1;
-    }
-
-    ## NOTE: we need to be *very* careful when "defaulting" the output
-    ## file. We only want to use a default if this is the beginning of
-    ## the entire document (but *not* if this is an included file). We
-    ## determine this by seeing if the input stream stack has been set-up
-    ## already
-
-    ## Is $outfile a filename, a (possibly implied) filehandle, maybe a ref?
-    if (ref $outfile) {
-        ## we need to check for ref() first, as other checks involve reading
-        if (ref($outfile) =~ /^(ARRAY|HASH|CODE)$/) {
-            croak "Output to $1 reference not supported!\n";
-        }
-        elsif (ref($outfile) eq 'SCALAR') {
-#           # NOTE: IO::String isn't a part of the perl distribution,
-#           #       so probably we shouldn't support this case...
-#           require IO::String;
-#           $myData{_OUTFILE} = "$outfile";
-#           $out_fh = IO::String->new($outfile);
-            croak "Output to SCALAR reference not supported!\n";
-        }
-        else {
-            ## Must be a filehandle-ref (or else assume its a ref to an
-            ## object that supports the common IO write operations).
-            $myData{_OUTFILE} = ${$outfile};
-            $out_fh = $outfile;
-        }
-    }
-    elsif (!defined($outfile) || !length($outfile) || ($outfile eq '-')
-        || ($outfile =~ /^>&?(?:STDOUT|1)$/i))
-    {
-        if (defined $myData{_TOP_STREAM}) {
-            $out_fh = $myData{_OUTPUT};
-        }
-        else {
-            ## Not a filename, just a string implying STDOUT
-            $outfile ||= '-';
-            $myData{_OUTFILE} = '<standard output>';
-            $out_fh  = \*STDOUT;
-        }
-    }
-    elsif ($outfile =~ /^>&(STDERR|2)$/i) {
-        ## Not a filename, just a string implying STDERR
-        $myData{_OUTFILE} = '<standard error>';
-        $out_fh  = \*STDERR;
-    }
-    else {
-        ## We have a filename, open it for writing
-        $myData{_OUTFILE} = $outfile;
-        (-d $outfile) and croak "$outfile is a directory, not POD input!\n";
-        open($out_fh, "> $outfile")  or
-             croak "Can't open $outfile for writing: $!\n";
-        $close_output = 1;
-    }
-
-    ## Whew! That was a lot of work to set up reasonably/robust behavior
-    ## in the case of a non-filename for reading and writing. Now we just
-    ## have to parse the input and close the handles when we're finished.
-    $self->parse_from_filehandle(\%opts, $in_fh, $out_fh);
-
-    $close_input  and
-        close($in_fh) || croak "Can't close $infile after reading: $!\n";
-    $close_output  and
-        close($out_fh) || croak "Can't close $outfile after writing: $!\n";
-}
-
-#############################################################################
-
-=head1 ACCESSOR METHODS
-
-Clients of B<Pod::Parser> should use the following methods to access
-instance data fields:
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=head1 B<errorsub()>
-
-            $parser->errorsub("method_name");
-            $parser->errorsub(\&warn_user);
-            $parser->errorsub(sub { print STDERR, @_ });
-
-Specifies the method or subroutine to use when printing error messages
-about POD syntax. The supplied method/subroutine I<must> return TRUE upon
-successful printing of the message. If C<undef> is given, then the B<carp>
-builtin is used to issue error messages (this is the default behavior).
-
-            my $errorsub = $parser->errorsub()
-            my $errmsg = "This is an error message!\n"
-            (ref $errorsub) and &{$errorsub}($errmsg)
-                or (defined $errorsub) and $parser->$errorsub($errmsg)
-                    or  carp($errmsg);
-
-Returns a method name, or else a reference to the user-supplied subroutine
-used to print error messages. Returns C<undef> if the B<carp> builtin
-is used to issue error messages (this is the default behavior).
-
-=cut
-
-sub errorsub {
-   return (@_ > 1) ? ($_[0]->{_ERRORSUB} = $_[1]) : $_[0]->{_ERRORSUB};
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<cutting()>
-
-            $boolean = $parser->cutting();
-
-Returns the current C<cutting> state: a boolean-valued scalar which
-evaluates to true if text from the input file is currently being "cut"
-(meaning it is I<not> considered part of the POD document).
-
-            $parser->cutting($boolean);
-
-Sets the current C<cutting> state to the given value and returns the
-result.
-
-=cut
-
-sub cutting {
-   return (@_ > 1) ? ($_[0]->{_CUTTING} = $_[1]) : $_[0]->{_CUTTING};
-}
-
-##---------------------------------------------------------------------------
-
-##---------------------------------------------------------------------------
-
-=head1 B<parseopts()>
-
-When invoked with no additional arguments, B<parseopts> returns a hashtable
-of all the current parsing options.
-
-            ## See if we are parsing non-POD sections as well as POD ones
-            my %opts = $parser->parseopts();
-            $opts{'-want_nonPODs}' and print "-want_nonPODs\n";
-
-When invoked using a single string, B<parseopts> treats the string as the
-name of a parse-option and returns its corresponding value if it exists
-(returns C<undef> if it doesn't).
-
-            ## Did we ask to see '=cut' paragraphs?
-            my $want_cut = $parser->parseopts('-process_cut_cmd');
-            $want_cut and print "-process_cut_cmd\n";
-
-When invoked with multiple arguments, B<parseopts> treats them as
-key/value pairs and the specified parse-option names are set to the
-given values. Any unspecified parse-options are unaffected.
-
-            ## Set them back to the default
-            $parser->parseopts(-warnings => 0);
-
-When passed a single hash-ref, B<parseopts> uses that hash to completely
-reset the existing parse-options, all previous parse-option values
-are lost.
-
-            ## Reset all options to default 
-            $parser->parseopts( { } );
-
-See L<"PARSING OPTIONS"> for more information on the name and meaning of each
-parse-option currently recognized.
-
-=cut
-
-sub parseopts {
-   local *myData = shift;
-   local *myOpts = ($myData{_PARSEOPTS} ||= {});
-   return %myOpts  if (@_ == 0);
-   if (@_ == 1) {
-      local $_ = shift;
-      return  ref($_)  ?  $myData{_PARSEOPTS} = $_  :  $myOpts{$_};
-   }
-   my @newOpts = (%myOpts, @_);
-   $myData{_PARSEOPTS} = { @newOpts };
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<output_file()>
-
-            $fname = $parser->output_file();
-
-Returns the name of the output file being written.
-
-=cut
-
-sub output_file {
-   return $_[0]->{_OUTFILE};
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<output_handle()>
-
-            $fhandle = $parser->output_handle();
-
-Returns the output filehandle object.
-
-=cut
-
-sub output_handle {
-   return $_[0]->{_OUTPUT};
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<input_file()>
-
-            $fname = $parser->input_file();
-
-Returns the name of the input file being read.
-
-=cut
-
-sub input_file {
-   return $_[0]->{_INFILE};
-}
-
-##---------------------------------------------------------------------------
-
-=head1 B<input_handle()>
-
-            $fhandle = $parser->input_handle();
-
-Returns the current input filehandle object.
-
-=cut
-
-sub input_handle {
-   return $_[0]->{_INPUT};
-}
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head1 B<input_streams()>
-
-            $listref = $parser->input_streams();
-
-Returns a reference to an array which corresponds to the stack of all
-the input streams that are currently in the middle of being parsed.
-
-While parsing an input stream, it is possible to invoke
-B<parse_from_file()> or B<parse_from_filehandle()> to parse a new input
-stream and then return to parsing the previous input stream. Each input
-stream to be parsed is pushed onto the end of this input stack
-before any of its input is read. The input stream that is currently
-being parsed is always at the end (or top) of the input stack. When an
-input stream has been exhausted, it is popped off the end of the
-input stack.
-
-Each element on this input stack is a reference to C<Pod::InputSource>
-object. Please see L<Pod::InputObjects> for more details.
-
-This method might be invoked when printing diagnostic messages, for example,
-to obtain the name and line number of the all input files that are currently
-being processed.
-
-=end __PRIVATE__
-
-=cut
-
-sub input_streams {
-   return $_[0]->{_INPUT_STREAMS};
-}
-
-##---------------------------------------------------------------------------
-
-=begin __PRIVATE__
-
-=head1 B<top_stream()>
-
-            $hashref = $parser->top_stream();
-
-Returns a reference to the hash-table that represents the element
-that is currently at the top (end) of the input stream stack
-(see L<"input_streams()">). The return value will be the C<undef>
-if the input stack is empty.
-
-This method might be used when printing diagnostic messages, for example,
-to obtain the name and line number of the current input file.
-
-=end __PRIVATE__
-
-=cut
-
-sub top_stream {
-   return $_[0]->{_TOP_STREAM} || undef;
-}
-
-#############################################################################
-
-=head1 PRIVATE METHODS AND DATA
-
-B<Pod::Parser> makes use of several internal methods and data fields
-which clients should not need to see or use. For the sake of avoiding
-name collisions for client data and methods, these methods and fields
-are briefly discussed here. Determined hackers may obtain further
-information about them by reading the B<Pod::Parser> source code.
-
-Private data fields are stored in the hash-object whose reference is
-returned by the B<new()> constructor for this class. The names of all
-private methods and data-fields used by B<Pod::Parser> begin with a
-prefix of "_" and match the regular expression C</^_\w+$/>.
-
-=cut
-
-##---------------------------------------------------------------------------
-
-=begin _PRIVATE_
-
-=head1 B<_push_input_stream()>
-
-            $hashref = $parser->_push_input_stream($in_fh,$out_fh);
-
-This method will push the given input stream on the input stack and
-perform any necessary beginning-of-document or beginning-of-file
-processing. The argument C<$in_fh> is the input stream filehandle to
-push, and C<$out_fh> is the corresponding output filehandle to use (if
-it is not given or is undefined, then the current output stream is used,
-which defaults to standard output if it doesnt exist yet).
-
-The value returned will be reference to the hash-table that represents
-the new top of the input stream stack. I<Please Note> that it is
-possible for this method to use default values for the input and output
-file handles. If this happens, you will need to look at the C<INPUT>
-and C<OUTPUT> instance data members to determine their new values.
-
-=end _PRIVATE_
-
-=cut
-
-sub _push_input_stream {
-    my ($self, $in_fh, $out_fh) = @_;
-    local *myData = $self;
-
-    ## Initialize stuff for the entire document if this is *not*
-    ## an included file.
-    ##
-    ## NOTE: we need to be *very* careful when "defaulting" the output
-    ## filehandle. We only want to use a default value if this is the
-    ## beginning of the entire document (but *not* if this is an included
-    ## file).
-    unless (defined  $myData{_TOP_STREAM}) {
-        $out_fh  = \*STDOUT  unless (defined $out_fh);
-        $myData{_CUTTING}       = 1;   ## current "cutting" state
-        $myData{_INPUT_STREAMS} = [];  ## stack of all input streams
-    }
-
-    ## Initialize input indicators
-    $myData{_OUTFILE} = '(unknown)'  unless (defined  $myData{_OUTFILE});
-    $myData{_OUTPUT}  = $out_fh      if (defined  $out_fh);
-    $in_fh            = \*STDIN      unless (defined  $in_fh);
-    $myData{_INFILE}  = '(unknown)'  unless (defined  $myData{_INFILE});
-    $myData{_INPUT}   = $in_fh;
-    my $input_top     = $myData{_TOP_STREAM}
-                      = new Pod::InputSource(
-                            -name        => $myData{_INFILE},
-                            -handle      => $in_fh,
-                            -was_cutting => $myData{_CUTTING}
-                        );
-    local *input_stack = $myData{_INPUT_STREAMS};
-    push(@input_stack, $input_top);
-
-    ## Perform beginning-of-document and/or beginning-of-input processing
-    $self->begin_pod()  if (@input_stack == 1);
-    $self->begin_input();
-
-    return  $input_top;
-}
-
-##---------------------------------------------------------------------------
-
-=begin _PRIVATE_
-
-=head1 B<_pop_input_stream()>
-
-            $hashref = $parser->_pop_input_stream();
-
-This takes no arguments. It will perform any necessary end-of-file or
-end-of-document processing and then pop the current input stream from
-the top of the input stack.
-
-The value returned will be reference to the hash-table that represents
-the new top of the input stream stack.
-
-=end _PRIVATE_
-
-=cut
-
-sub _pop_input_stream {
-    my ($self) = @_;
-    local *myData = $self;
-    local *input_stack = $myData{_INPUT_STREAMS};
-
-    ## Perform end-of-input and/or end-of-document processing
-    $self->end_input()  if (@input_stack > 0);
-    $self->end_pod()    if (@input_stack == 1);
-
-    ## Restore cutting state to whatever it was before we started
-    ## parsing this file.
-    my $old_top = pop(@input_stack);
-    $myData{_CUTTING} = $old_top->was_cutting();
-
-    ## Dont forget to reset the input indicators
-    my $input_top = undef;
-    if (@input_stack > 0) {
-       $input_top = $myData{_TOP_STREAM} = $input_stack[-1];
-       $myData{_INFILE}  = $input_top->name();
-       $myData{_INPUT}   = $input_top->handle();
-    } else {
-       delete $myData{_TOP_STREAM};
-       delete $myData{_INPUT_STREAMS};
-    }
-
-    return  $input_top;
-}
-
-#############################################################################
-
-=head1 TREE-BASED PARSING
-
-If straightforward stream-based parsing wont meet your needs (as is
-likely the case for tasks such as translating PODs into structured
-markup languages like HTML and XML) then you may need to take the
-tree-based approach. Rather than doing everything in one pass and
-calling the B<interpolate()> method to expand sequences into text, it
-may be desirable to instead create a parse-tree using the B<parse_text()>
-method to return a tree-like structure which may contain an ordered
-list of children (each of which may be a text-string, or a similar
-tree-like structure).
-
-Pay special attention to L<"METHODS FOR PARSING AND PROCESSING"> and
-to the objects described in L<Pod::InputObjects>. The former describes
-the gory details and parameters for how to customize and extend the
-parsing behavior of B<Pod::Parser>. B<Pod::InputObjects> provides
-several objects that may all be used interchangeably as parse-trees. The
-most obvious one is the B<Pod::ParseTree> object. It defines the basic
-interface and functionality that all things trying to be a POD parse-tree
-should do. A B<Pod::ParseTree> is defined such that each "node" may be a
-text-string, or a reference to another parse-tree.  Each B<Pod::Paragraph>
-object and each B<Pod::InteriorSequence> object also supports the basic
-parse-tree interface.
-
-The B<parse_text()> method takes a given paragraph of text, and
-returns a parse-tree that contains one or more children, each of which
-may be a text-string, or an InteriorSequence object. There are also
-callback-options that may be passed to B<parse_text()> to customize
-the way it expands or transforms interior-sequences, as well as the
-returned result. These callbacks can be used to create a parse-tree
-with custom-made objects (which may or may not support the parse-tree
-interface, depending on how you choose to do it).
-
-If you wish to turn an entire POD document into a parse-tree, that process
-is fairly straightforward. The B<parse_text()> method is the key to doing
-this successfully. Every paragraph-callback (i.e. the polymorphic methods
-for B<command()>, B<verbatim()>, and B<textblock()> paragraphs) takes
-a B<Pod::Paragraph> object as an argument. Each paragraph object has a
-B<parse_tree()> method that can be used to get or set a corresponding
-parse-tree. So for each of those paragraph-callback methods, simply call
-B<parse_text()> with the options you desire, and then use the returned
-parse-tree to assign to the given paragraph object.
-
-That gives you a parse-tree for each paragraph - so now all you need is
-an ordered list of paragraphs. You can maintain that yourself as a data
-element in the object/hash. The most straightforward way would be simply
-to use an array-ref, with the desired set of custom "options" for each
-invocation of B<parse_text>. Let's assume the desired option-set is
-given by the hash C<%options>. Then we might do something like the
-following:
-
-    package MyPodParserTree;
-
-    @ISA = qw( Pod::Parser );
-
-    ...
-
-    sub begin_pod {
-        my $self = shift;
-        $self->{'-paragraphs'} = [];  ## initialize paragraph list
-    }
-
-    sub command { 
-        my ($parser, $command, $paragraph, $line_num, $pod_para) = @_;
-        my $ptree = $parser->parse_text({%options}, $paragraph, ...);
-        $pod_para->parse_tree( $ptree );
-        push @{ $self->{'-paragraphs'} }, $pod_para;
-    }
-
-    sub verbatim { 
-        my ($parser, $paragraph, $line_num, $pod_para) = @_;
-        push @{ $self->{'-paragraphs'} }, $pod_para;
-    }
-
-    sub textblock { 
-        my ($parser, $paragraph, $line_num, $pod_para) = @_;
-        my $ptree = $parser->parse_text({%options}, $paragraph, ...);
-        $pod_para->parse_tree( $ptree );
-        push @{ $self->{'-paragraphs'} }, $pod_para;
-    }
-
-    ...
-
-    package main;
-    ...
-    my $parser = new MyPodParserTree(...);
-    $parser->parse_from_file(...);
-    my $paragraphs_ref = $parser->{'-paragraphs'};
-
-Of course, in this module-author's humble opinion, I'd be more inclined to
-use the existing B<Pod::ParseTree> object than a simple array. That way
-everything in it, paragraphs and sequences, all respond to the same core
-interface for all parse-tree nodes. The result would look something like:
-
-    package MyPodParserTree2;
-
-    ...
-
-    sub begin_pod {
-        my $self = shift;
-        $self->{'-ptree'} = new Pod::ParseTree;  ## initialize parse-tree
-    }
-
-    sub parse_tree {
-        ## convenience method to get/set the parse-tree for the entire POD
-        (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];
-        return $_[0]->{'-ptree'};
-    }
-
-    sub command { 
-        my ($parser, $command, $paragraph, $line_num, $pod_para) = @_;
-        my $ptree = $parser->parse_text({<<options>>}, $paragraph, ...);
-        $pod_para->parse_tree( $ptree );
-        $parser->parse_tree()->append( $pod_para );
-    }
-
-    sub verbatim { 
-        my ($parser, $paragraph, $line_num, $pod_para) = @_;
-        $parser->parse_tree()->append( $pod_para );
-    }
-
-    sub textblock { 
-        my ($parser, $paragraph, $line_num, $pod_para) = @_;
-        my $ptree = $parser->parse_text({<<options>>}, $paragraph, ...);
-        $pod_para->parse_tree( $ptree );
-        $parser->parse_tree()->append( $pod_para );
-    }
-
-    ...
-
-    package main;
-    ...
-    my $parser = new MyPodParserTree2(...);
-    $parser->parse_from_file(...);
-    my $ptree = $parser->parse_tree;
-    ...
-
-Now you have the entire POD document as one great big parse-tree. You
-can even use the B<-expand_seq> option to B<parse_text> to insert
-whole different kinds of objects. Just don't expect B<Pod::Parser>
-to know what to do with them after that. That will need to be in your
-code. Or, alternatively, you can insert any object you like so long as
-it conforms to the B<Pod::ParseTree> interface.
-
-One could use this to create subclasses of B<Pod::Paragraphs> and
-B<Pod::InteriorSequences> for specific commands (or to create your own
-custom node-types in the parse-tree) and add some kind of B<emit()>
-method to each custom node/subclass object in the tree. Then all you'd
-need to do is recursively walk the tree in the desired order, processing
-the children (most likely from left to right) by formatting them if
-they are text-strings, or by calling their B<emit()> method if they
-are objects/references.
-
-=head1 CAVEATS
-
-Please note that POD has the notion of "paragraphs": this is something
-starting I<after> a blank (read: empty) line, with the single exception
-of the file start, which is also starting a paragraph. That means that
-especially a command (e.g. C<=head1>) I<must> be preceded with a blank
-line; C<__END__> is I<not> a blank line.
-
-=head1 SEE ALSO
-
-L<Pod::InputObjects>, L<Pod::Select>
-
-B<Pod::InputObjects> defines POD input objects corresponding to
-command paragraphs, parse-trees, and interior-sequences.
-
-B<Pod::Select> is a subclass of B<Pod::Parser> which provides the ability
-to selectively include and/or exclude sections of a POD document from being
-translated based upon the current heading, subheading, subsubheading, etc.
-
-=for __PRIVATE__
-B<Pod::Callbacks> is a subclass of B<Pod::Parser> which gives its users
-the ability the employ I<callback functions> instead of, or in addition
-to, overriding methods of the base class.
-
-=for __PRIVATE__
-B<Pod::Select> and B<Pod::Callbacks> do not override any
-methods nor do they define any new methods with the same name. Because
-of this, they may I<both> be used (in combination) as a base class of
-the same subclass in order to combine their functionality without
-causing any namespace clashes due to multiple inheritance.
-
-=head1 AUTHOR
-
-Please report bugs using L<http://rt.cpan.org>.
-
-Brad Appleton E<lt>bradapp@enteract.comE<gt>
-
-Based on code for B<Pod::Text> written by
-Tom Christiansen E<lt>tchrist@mox.perl.comE<gt>
-
-=head1 LICENSE
-
-Pod-Parser is free software; you can redistribute it and/or modify it
-under the terms of the Artistic License distributed with Perl version
-5.000 or (at your option) any later version. Please refer to the
-Artistic License that came with your Perl distribution for more
-details. If your version of Perl was not distributed under the
-terms of the Artistic License, than you may distribute PodParser
-under the same terms as Perl itself.
-
-=cut
-
-1;
-# vim: ts=4 sw=4 et
+#############################################################################

+# Pod/Parser.pm -- package which defines a base class for parsing POD docs.

+#

+# Copyright (C) 1996-2000 by Bradford Appleton. All rights reserved.

+# This file is part of "PodParser". PodParser is free software;

+# you can redistribute it and/or modify it under the same terms

+# as Perl itself.

+#############################################################################

+

+package Pod::Parser;

+use strict;

+

+## These "variables" are used as local "glob aliases" for performance

+use vars qw($VERSION @ISA %myData %myOpts @input_stack);

+$VERSION = '1.60';  ## Current version of this package

+require  5.005;    ## requires this Perl version or later

+

+#############################################################################

+

+=head1 NAME

+

+Pod::Parser - base class for creating POD filters and translators

+

+=head1 SYNOPSIS

+

+    use Pod::Parser;

+

+    package MyParser;

+    @ISA = qw(Pod::Parser);

+

+    sub command { 

+        my ($parser, $command, $paragraph, $line_num) = @_;

+        ## Interpret the command and its text; sample actions might be:

+        if ($command eq 'head1') { ... }

+        elsif ($command eq 'head2') { ... }

+        ## ... other commands and their actions

+        my $out_fh = $parser->output_handle();

+        my $expansion = $parser->interpolate($paragraph, $line_num);

+        print $out_fh $expansion;

+    }

+

+    sub verbatim { 

+        my ($parser, $paragraph, $line_num) = @_;

+        ## Format verbatim paragraph; sample actions might be:

+        my $out_fh = $parser->output_handle();

+        print $out_fh $paragraph;

+    }

+

+    sub textblock { 

+        my ($parser, $paragraph, $line_num) = @_;

+        ## Translate/Format this block of text; sample actions might be:

+        my $out_fh = $parser->output_handle();

+        my $expansion = $parser->interpolate($paragraph, $line_num);

+        print $out_fh $expansion;

+    }

+

+    sub interior_sequence { 

+        my ($parser, $seq_command, $seq_argument) = @_;

+        ## Expand an interior sequence; sample actions might be:

+        return "*$seq_argument*"     if ($seq_command eq 'B');

+        return "`$seq_argument'"     if ($seq_command eq 'C');

+        return "_${seq_argument}_'"  if ($seq_command eq 'I');

+        ## ... other sequence commands and their resulting text

+    }

+

+    package main;

+

+    ## Create a parser object and have it parse file whose name was

+    ## given on the command-line (use STDIN if no files were given).

+    $parser = new MyParser();

+    $parser->parse_from_filehandle(\*STDIN)  if (@ARGV == 0);

+    for (@ARGV) { $parser->parse_from_file($_); }

+

+=head1 REQUIRES

+

+perl5.005, Pod::InputObjects, Exporter, Symbol, Carp

+

+=head1 EXPORTS

+

+Nothing.

+

+=head1 DESCRIPTION

+

+B<Pod::Parser> is a base class for creating POD filters and translators.

+It handles most of the effort involved with parsing the POD sections

+from an input stream, leaving subclasses free to be concerned only with

+performing the actual translation of text.

+

+B<Pod::Parser> parses PODs, and makes method calls to handle the various

+components of the POD. Subclasses of B<Pod::Parser> override these methods

+to translate the POD into whatever output format they desire.

+

+Note: This module is considered as legacy; modern Perl releases (5.18 and

+higher) are going to remove Pod::Parser from core and use L<Pod::Simple>

+for all things POD.

+

+=head1 QUICK OVERVIEW

+

+To create a POD filter for translating POD documentation into some other

+format, you create a subclass of B<Pod::Parser> which typically overrides

+just the base class implementation for the following methods:

+

+=over 2

+

+=item *

+

+B<command()>

+

+=item *

+

+B<verbatim()>

+

+=item *

+

+B<textblock()>

+

+=item *

+

+B<interior_sequence()>

+

+=back

+

+You may also want to override the B<begin_input()> and B<end_input()>

+methods for your subclass (to perform any needed per-file and/or

+per-document initialization or cleanup).

+

+If you need to perform any preprocessing of input before it is parsed

+you may want to override one or more of B<preprocess_line()> and/or

+B<preprocess_paragraph()>.

+

+Sometimes it may be necessary to make more than one pass over the input

+files. If this is the case you have several options. You can make the

+first pass using B<Pod::Parser> and override your methods to store the

+intermediate results in memory somewhere for the B<end_pod()> method to

+process. You could use B<Pod::Parser> for several passes with an

+appropriate state variable to control the operation for each pass. If

+your input source can't be reset to start at the beginning, you can

+store it in some other structure as a string or an array and have that

+structure implement a B<getline()> method (which is all that

+B<parse_from_filehandle()> uses to read input).

+

+Feel free to add any member data fields you need to keep track of things

+like current font, indentation, horizontal or vertical position, or

+whatever else you like. Be sure to read L<"PRIVATE METHODS AND DATA">

+to avoid name collisions.

+

+For the most part, the B<Pod::Parser> base class should be able to

+do most of the input parsing for you and leave you free to worry about

+how to interpret the commands and translate the result.

+

+Note that all we have described here in this quick overview is the

+simplest most straightforward use of B<Pod::Parser> to do stream-based

+parsing. It is also possible to use the B<Pod::Parser::parse_text> function

+to do more sophisticated tree-based parsing. See L<"TREE-BASED PARSING">.

+

+=head1 PARSING OPTIONS

+

+A I<parse-option> is simply a named option of B<Pod::Parser> with a

+value that corresponds to a certain specified behavior. These various

+behaviors of B<Pod::Parser> may be enabled/disabled by setting

+or unsetting one or more I<parse-options> using the B<parseopts()> method.

+The set of currently accepted parse-options is as follows:

+

+=over 3

+

+=item B<-want_nonPODs> (default: unset)

+

+Normally (by default) B<Pod::Parser> will only provide access to

+the POD sections of the input. Input paragraphs that are not part

+of the POD-format documentation are not made available to the caller

+(not even using B<preprocess_paragraph()>). Setting this option to a

+non-empty, non-zero value will allow B<preprocess_paragraph()> to see

+non-POD sections of the input as well as POD sections. The B<cutting()>

+method can be used to determine if the corresponding paragraph is a POD

+paragraph, or some other input paragraph.

+

+=item B<-process_cut_cmd> (default: unset)

+

+Normally (by default) B<Pod::Parser> handles the C<=cut> POD directive

+by itself and does not pass it on to the caller for processing. Setting

+this option to a non-empty, non-zero value will cause B<Pod::Parser> to

+pass the C<=cut> directive to the caller just like any other POD command

+(and hence it may be processed by the B<command()> method).

+

+B<Pod::Parser> will still interpret the C<=cut> directive to mean that

+"cutting mode" has been (re)entered, but the caller will get a chance

+to capture the actual C<=cut> paragraph itself for whatever purpose

+it desires.

+

+=item B<-warnings> (default: unset)

+

+Normally (by default) B<Pod::Parser> recognizes a bare minimum of

+pod syntax errors and warnings and issues diagnostic messages

+for errors, but not for warnings. (Use B<Pod::Checker> to do more

+thorough checking of POD syntax.) Setting this option to a non-empty,

+non-zero value will cause B<Pod::Parser> to issue diagnostics for

+the few warnings it recognizes as well as the errors.

+

+=back

+

+Please see L<"parseopts()"> for a complete description of the interface

+for the setting and unsetting of parse-options.

+

+=cut

+

+#############################################################################

+

+#use diagnostics;

+use Pod::InputObjects;

+use Carp;

+use Exporter;

+BEGIN {

+   if ($] < 5.006) {

+      require Symbol;

+      import Symbol;

+   }

+}

+@ISA = qw(Exporter);

+

+#############################################################################

+

+=head1 RECOMMENDED SUBROUTINE/METHOD OVERRIDES

+

+B<Pod::Parser> provides several methods which most subclasses will probably

+want to override. These methods are as follows:

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head1 B<command()>

+

+            $parser->command($cmd,$text,$line_num,$pod_para);

+

+This method should be overridden by subclasses to take the appropriate

+action when a POD command paragraph (denoted by a line beginning with

+"=") is encountered. When such a POD directive is seen in the input,

+this method is called and is passed:

+

+=over 3

+

+=item C<$cmd>

+

+the name of the command for this POD paragraph

+

+=item C<$text>

+

+the paragraph text for the given POD paragraph command.

+

+=item C<$line_num>

+

+the line-number of the beginning of the paragraph

+

+=item C<$pod_para>

+

+a reference to a C<Pod::Paragraph> object which contains further

+information about the paragraph command (see L<Pod::InputObjects>

+for details).

+

+=back

+

+B<Note> that this method I<is> called for C<=pod> paragraphs.

+

+The base class implementation of this method simply treats the raw POD

+command as normal block of paragraph text (invoking the B<textblock()>

+method with the command paragraph).

+

+=cut

+

+sub command {

+    my ($self, $cmd, $text, $line_num, $pod_para)  = @_;

+    ## Just treat this like a textblock

+    $self->textblock($pod_para->raw_text(), $line_num, $pod_para);

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<verbatim()>

+

+            $parser->verbatim($text,$line_num,$pod_para);

+

+This method may be overridden by subclasses to take the appropriate

+action when a block of verbatim text is encountered. It is passed the

+following parameters:

+

+=over 3

+

+=item C<$text>

+

+the block of text for the verbatim paragraph

+

+=item C<$line_num>

+

+the line-number of the beginning of the paragraph

+

+=item C<$pod_para>

+

+a reference to a C<Pod::Paragraph> object which contains further

+information about the paragraph (see L<Pod::InputObjects>

+for details).

+

+=back

+

+The base class implementation of this method simply prints the textblock

+(unmodified) to the output filehandle.

+

+=cut

+

+sub verbatim {

+    my ($self, $text, $line_num, $pod_para) = @_;

+    my $out_fh = $self->{_OUTPUT};

+    print $out_fh $text;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<textblock()>

+

+            $parser->textblock($text,$line_num,$pod_para);

+

+This method may be overridden by subclasses to take the appropriate

+action when a normal block of POD text is encountered (although the base

+class method will usually do what you want). It is passed the following

+parameters:

+

+=over 3

+

+=item C<$text>

+

+the block of text for the a POD paragraph

+

+=item C<$line_num>

+

+the line-number of the beginning of the paragraph

+

+=item C<$pod_para>

+

+a reference to a C<Pod::Paragraph> object which contains further

+information about the paragraph (see L<Pod::InputObjects>

+for details).

+

+=back

+

+In order to process interior sequences, subclasses implementations of

+this method will probably want to invoke either B<interpolate()> or

+B<parse_text()>, passing it the text block C<$text>, and the corresponding

+line number in C<$line_num>, and then perform any desired processing upon

+the returned result.

+

+The base class implementation of this method simply prints the text block

+as it occurred in the input stream).

+

+=cut

+

+sub textblock {

+    my ($self, $text, $line_num, $pod_para) = @_;

+    my $out_fh = $self->{_OUTPUT};

+    print $out_fh $self->interpolate($text, $line_num);

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<interior_sequence()>

+

+            $parser->interior_sequence($seq_cmd,$seq_arg,$pod_seq);

+

+This method should be overridden by subclasses to take the appropriate

+action when an interior sequence is encountered. An interior sequence is

+an embedded command within a block of text which appears as a command

+name (usually a single uppercase character) followed immediately by a

+string of text which is enclosed in angle brackets. This method is

+passed the sequence command C<$seq_cmd> and the corresponding text

+C<$seq_arg>. It is invoked by the B<interpolate()> method for each interior

+sequence that occurs in the string that it is passed. It should return

+the desired text string to be used in place of the interior sequence.

+The C<$pod_seq> argument is a reference to a C<Pod::InteriorSequence>

+object which contains further information about the interior sequence.

+Please see L<Pod::InputObjects> for details if you need to access this

+additional information.

+

+Subclass implementations of this method may wish to invoke the 

+B<nested()> method of C<$pod_seq> to see if it is nested inside

+some other interior-sequence (and if so, which kind).

+

+The base class implementation of the B<interior_sequence()> method

+simply returns the raw text of the interior sequence (as it occurred

+in the input) to the caller.

+

+=cut

+

+sub interior_sequence {

+    my ($self, $seq_cmd, $seq_arg, $pod_seq) = @_;

+    ## Just return the raw text of the interior sequence

+    return  $pod_seq->raw_text();

+}

+

+#############################################################################

+

+=head1 OPTIONAL SUBROUTINE/METHOD OVERRIDES

+

+B<Pod::Parser> provides several methods which subclasses may want to override

+to perform any special pre/post-processing. These methods do I<not> have to

+be overridden, but it may be useful for subclasses to take advantage of them.

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head1 B<new()>

+

+            my $parser = Pod::Parser->new();

+

+This is the constructor for B<Pod::Parser> and its subclasses. You

+I<do not> need to override this method! It is capable of constructing

+subclass objects as well as base class objects, provided you use

+any of the following constructor invocation styles:

+

+    my $parser1 = MyParser->new();

+    my $parser2 = new MyParser();

+    my $parser3 = $parser2->new();

+

+where C<MyParser> is some subclass of B<Pod::Parser>.

+

+Using the syntax C<MyParser::new()> to invoke the constructor is I<not>

+recommended, but if you insist on being able to do this, then the

+subclass I<will> need to override the B<new()> constructor method. If

+you do override the constructor, you I<must> be sure to invoke the

+B<initialize()> method of the newly blessed object.

+

+Using any of the above invocations, the first argument to the

+constructor is always the corresponding package name (or object

+reference). No other arguments are required, but if desired, an

+associative array (or hash-table) my be passed to the B<new()>

+constructor, as in:

+

+    my $parser1 = MyParser->new( MYDATA => $value1, MOREDATA => $value2 );

+    my $parser2 = new MyParser( -myflag => 1 );

+

+All arguments passed to the B<new()> constructor will be treated as

+key/value pairs in a hash-table. The newly constructed object will be

+initialized by copying the contents of the given hash-table (which may

+have been empty). The B<new()> constructor for this class and all of its

+subclasses returns a blessed reference to the initialized object (hash-table).

+

+=cut

+

+sub new {

+    ## Determine if we were called via an object-ref or a classname

+    my ($this,%params) = @_;

+    my $class = ref($this) || $this;

+    ## Any remaining arguments are treated as initial values for the

+    ## hash that is used to represent this object.

+    my $self = { %params };

+    ## Bless ourselves into the desired class and perform any initialization

+    bless $self, $class;

+    $self->initialize();

+    return $self;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<initialize()>

+

+            $parser->initialize();

+

+This method performs any necessary object initialization. It takes no

+arguments (other than the object instance of course, which is typically

+copied to a local variable named C<$self>). If subclasses override this

+method then they I<must> be sure to invoke C<$self-E<gt>SUPER::initialize()>.

+

+=cut

+

+sub initialize {

+    #my $self = shift;

+    #return;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<begin_pod()>

+

+            $parser->begin_pod();

+

+This method is invoked at the beginning of processing for each POD

+document that is encountered in the input. Subclasses should override

+this method to perform any per-document initialization.

+

+=cut

+

+sub begin_pod {

+    #my $self = shift;

+    #return;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<begin_input()>

+

+            $parser->begin_input();

+

+This method is invoked by B<parse_from_filehandle()> immediately I<before>

+processing input from a filehandle. The base class implementation does

+nothing, however, subclasses may override it to perform any per-file

+initializations.

+

+Note that if multiple files are parsed for a single POD document

+(perhaps the result of some future C<=include> directive) this method

+is invoked for every file that is parsed. If you wish to perform certain

+initializations once per document, then you should use B<begin_pod()>.

+

+=cut

+

+sub begin_input {

+    #my $self = shift;

+    #return;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<end_input()>

+

+            $parser->end_input();

+

+This method is invoked by B<parse_from_filehandle()> immediately I<after>

+processing input from a filehandle. The base class implementation does

+nothing, however, subclasses may override it to perform any per-file

+cleanup actions.

+

+Please note that if multiple files are parsed for a single POD document

+(perhaps the result of some kind of C<=include> directive) this method

+is invoked for every file that is parsed. If you wish to perform certain

+cleanup actions once per document, then you should use B<end_pod()>.

+

+=cut

+

+sub end_input {

+    #my $self = shift;

+    #return;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<end_pod()>

+

+            $parser->end_pod();

+

+This method is invoked at the end of processing for each POD document

+that is encountered in the input. Subclasses should override this method

+to perform any per-document finalization.

+

+=cut

+

+sub end_pod {

+    #my $self = shift;

+    #return;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<preprocess_line()>

+

+          $textline = $parser->preprocess_line($text, $line_num);

+

+This method should be overridden by subclasses that wish to perform

+any kind of preprocessing for each I<line> of input (I<before> it has

+been determined whether or not it is part of a POD paragraph). The

+parameter C<$text> is the input line; and the parameter C<$line_num> is

+the line number of the corresponding text line.

+

+The value returned should correspond to the new text to use in its

+place.  If the empty string or an undefined value is returned then no

+further processing will be performed for this line.

+

+Please note that the B<preprocess_line()> method is invoked I<before>

+the B<preprocess_paragraph()> method. After all (possibly preprocessed)

+lines in a paragraph have been assembled together and it has been

+determined that the paragraph is part of the POD documentation from one

+of the selected sections, then B<preprocess_paragraph()> is invoked.

+

+The base class implementation of this method returns the given text.

+

+=cut

+

+sub preprocess_line {

+    my ($self, $text, $line_num) = @_;

+    return  $text;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<preprocess_paragraph()>

+

+            $textblock = $parser->preprocess_paragraph($text, $line_num);

+

+This method should be overridden by subclasses that wish to perform any

+kind of preprocessing for each block (paragraph) of POD documentation

+that appears in the input stream. The parameter C<$text> is the POD

+paragraph from the input file; and the parameter C<$line_num> is the

+line number for the beginning of the corresponding paragraph.

+

+The value returned should correspond to the new text to use in its

+place If the empty string is returned or an undefined value is

+returned, then the given C<$text> is ignored (not processed).

+

+This method is invoked after gathering up all the lines in a paragraph

+and after determining the cutting state of the paragraph,

+but before trying to further parse or interpret them. After

+B<preprocess_paragraph()> returns, the current cutting state (which

+is returned by C<$self-E<gt>cutting()>) is examined. If it evaluates

+to true then input text (including the given C<$text>) is cut (not

+processed) until the next POD directive is encountered.

+

+Please note that the B<preprocess_line()> method is invoked I<before>

+the B<preprocess_paragraph()> method. After all (possibly preprocessed)

+lines in a paragraph have been assembled together and either it has been

+determined that the paragraph is part of the POD documentation from one

+of the selected sections or the C<-want_nonPODs> option is true,

+then B<preprocess_paragraph()> is invoked.

+

+The base class implementation of this method returns the given text.

+

+=cut

+

+sub preprocess_paragraph {

+    my ($self, $text, $line_num) = @_;

+    return  $text;

+}

+

+#############################################################################

+

+=head1 METHODS FOR PARSING AND PROCESSING

+

+B<Pod::Parser> provides several methods to process input text. These

+methods typically won't need to be overridden (and in some cases they

+can't be overridden), but subclasses may want to invoke them to exploit

+their functionality.

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head1 B<parse_text()>

+

+            $ptree1 = $parser->parse_text($text, $line_num);

+            $ptree2 = $parser->parse_text({%opts}, $text, $line_num);

+            $ptree3 = $parser->parse_text(\%opts, $text, $line_num);

+

+This method is useful if you need to perform your own interpolation 

+of interior sequences and can't rely upon B<interpolate> to expand

+them in simple bottom-up order.

+

+The parameter C<$text> is a string or block of text to be parsed

+for interior sequences; and the parameter C<$line_num> is the

+line number corresponding to the beginning of C<$text>.

+

+B<parse_text()> will parse the given text into a parse-tree of "nodes."

+and interior-sequences.  Each "node" in the parse tree is either a

+text-string, or a B<Pod::InteriorSequence>.  The result returned is a

+parse-tree of type B<Pod::ParseTree>. Please see L<Pod::InputObjects>

+for more information about B<Pod::InteriorSequence> and B<Pod::ParseTree>.

+

+If desired, an optional hash-ref may be specified as the first argument

+to customize certain aspects of the parse-tree that is created and

+returned. The set of recognized option keywords are:

+

+=over 3

+

+=item B<-expand_seq> =E<gt> I<code-ref>|I<method-name>

+

+Normally, the parse-tree returned by B<parse_text()> will contain an

+unexpanded C<Pod::InteriorSequence> object for each interior-sequence

+encountered. Specifying B<-expand_seq> tells B<parse_text()> to "expand"

+every interior-sequence it sees by invoking the referenced function

+(or named method of the parser object) and using the return value as the

+expanded result.

+

+If a subroutine reference was given, it is invoked as:

+

+  &$code_ref( $parser, $sequence )

+

+and if a method-name was given, it is invoked as:

+

+  $parser->method_name( $sequence )

+

+where C<$parser> is a reference to the parser object, and C<$sequence>

+is a reference to the interior-sequence object.

+[I<NOTE>: If the B<interior_sequence()> method is specified, then it is

+invoked according to the interface specified in L<"interior_sequence()">].

+

+=item B<-expand_text> =E<gt> I<code-ref>|I<method-name>

+

+Normally, the parse-tree returned by B<parse_text()> will contain a

+text-string for each contiguous sequence of characters outside of an

+interior-sequence. Specifying B<-expand_text> tells B<parse_text()> to

+"preprocess" every such text-string it sees by invoking the referenced

+function (or named method of the parser object) and using the return value

+as the preprocessed (or "expanded") result. [Note that if the result is

+an interior-sequence, then it will I<not> be expanded as specified by the

+B<-expand_seq> option; Any such recursive expansion needs to be handled by

+the specified callback routine.]

+

+If a subroutine reference was given, it is invoked as:

+

+  &$code_ref( $parser, $text, $ptree_node )

+

+and if a method-name was given, it is invoked as:

+

+  $parser->method_name( $text, $ptree_node )

+

+where C<$parser> is a reference to the parser object, C<$text> is the

+text-string encountered, and C<$ptree_node> is a reference to the current

+node in the parse-tree (usually an interior-sequence object or else the

+top-level node of the parse-tree).

+

+=item B<-expand_ptree> =E<gt> I<code-ref>|I<method-name>

+

+Rather than returning a C<Pod::ParseTree>, pass the parse-tree as an

+argument to the referenced subroutine (or named method of the parser

+object) and return the result instead of the parse-tree object.

+

+If a subroutine reference was given, it is invoked as:

+

+  &$code_ref( $parser, $ptree )

+

+and if a method-name was given, it is invoked as:

+

+  $parser->method_name( $ptree )

+

+where C<$parser> is a reference to the parser object, and C<$ptree>

+is a reference to the parse-tree object.

+

+=back

+

+=cut

+

+sub parse_text {

+    my $self = shift;

+    local $_ = '';

+

+    ## Get options and set any defaults

+    my %opts = (ref $_[0]) ? %{ shift() } : ();

+    my $expand_seq   = $opts{'-expand_seq'}   || undef;

+    my $expand_text  = $opts{'-expand_text'}  || undef;

+    my $expand_ptree = $opts{'-expand_ptree'} || undef;

+

+    my $text = shift;

+    my $line = shift;

+    my $file = $self->input_file();

+    my $cmd  = "";

+

+    ## Convert method calls into closures, for our convenience

+    my $xseq_sub   = $expand_seq;

+    my $xtext_sub  = $expand_text;

+    my $xptree_sub = $expand_ptree;

+    if (defined $expand_seq  and  $expand_seq eq 'interior_sequence') {

+        ## If 'interior_sequence' is the method to use, we have to pass

+        ## more than just the sequence object, we also need to pass the

+        ## sequence name and text.

+        $xseq_sub = sub {

+            my ($sself, $iseq) = @_;

+            my $args = join('', $iseq->parse_tree->children);

+            return  $sself->interior_sequence($iseq->name, $args, $iseq);

+        };

+    }

+    ref $xseq_sub    or  $xseq_sub   = sub { shift()->$expand_seq(@_) };

+    ref $xtext_sub   or  $xtext_sub  = sub { shift()->$expand_text(@_) };

+    ref $xptree_sub  or  $xptree_sub = sub { shift()->$expand_ptree(@_) };

+

+    ## Keep track of the "current" interior sequence, and maintain a stack

+    ## of "in progress" sequences.

+    ##

+    ## NOTE that we push our own "accumulator" at the very beginning of the

+    ## stack. It's really a parse-tree, not a sequence; but it implements

+    ## the methods we need so we can use it to gather-up all the sequences

+    ## and strings we parse. Thus, by the end of our parsing, it should be

+    ## the only thing left on our stack and all we have to do is return it!

+    ##

+    my $seq       = Pod::ParseTree->new();

+    my @seq_stack = ($seq);

+    my ($ldelim, $rdelim) = ('', '');

+

+    ## Iterate over all sequence starts text (NOTE: split with

+    ## capturing parens keeps the delimiters)

+    $_ = $text;

+    my @tokens = split /([A-Z]<(?:<+(?:\r?\n|[ \t]))?)/;

+    while ( @tokens ) {

+        $_ = shift @tokens;

+        ## Look for the beginning of a sequence

+        if ( /^([A-Z])(<(?:<+(?:\r?\n|[ \t]))?)$/ ) {

+            ## Push a new sequence onto the stack of those "in-progress"

+            my $ldelim_orig;

+            ($cmd, $ldelim_orig) = ($1, $2);

+            ($ldelim = $ldelim_orig) =~ s/\s+$//;

+            ($rdelim = $ldelim) =~ tr/</>/;

+            $seq = Pod::InteriorSequence->new(

+                       -name   => $cmd,

+                       -ldelim => $ldelim_orig,  -rdelim => $rdelim,

+                       -file   => $file,    -line   => $line

+                   );

+            (@seq_stack > 1)  and  $seq->nested($seq_stack[-1]);

+            push @seq_stack, $seq;

+        }

+        ## Look for sequence ending

+        elsif ( @seq_stack > 1 ) {

+            ## Make sure we match the right kind of closing delimiter

+            my ($seq_end, $post_seq) = ('', '');

+            if ( ($ldelim eq '<'   and  /\A(.*?)(>)/s)

+                 or  /\A(.*?)(\s+$rdelim)/s )

+            {

+                ## Found end-of-sequence, capture the interior and the

+                ## closing the delimiter, and put the rest back on the

+                ## token-list

+                $post_seq = substr($_, length($1) + length($2));

+                ($_, $seq_end) = ($1, $2);

+                (length $post_seq)  and  unshift @tokens, $post_seq;

+            }

+            if (length) {

+                ## In the middle of a sequence, append this text to it, and

+                ## dont forget to "expand" it if that's what the caller wanted

+                $seq->append($expand_text ? &$xtext_sub($self,$_,$seq) : $_);

+                $_ .= $seq_end;

+            }

+            if (length $seq_end) {

+                ## End of current sequence, record terminating delimiter

+                $seq->rdelim($seq_end);

+                ## Pop it off the stack of "in progress" sequences

+                pop @seq_stack;

+                ## Append result to its parent in current parse tree

+                $seq_stack[-1]->append($expand_seq ? &$xseq_sub($self,$seq)

+                                                   : $seq);

+                ## Remember the current cmd-name and left-delimiter

+                if(@seq_stack > 1) {

+                    $cmd = $seq_stack[-1]->name;

+                    $ldelim = $seq_stack[-1]->ldelim;

+                    $rdelim = $seq_stack[-1]->rdelim;

+                } else {

+                    $cmd = $ldelim = $rdelim = '';

+                }

+            }

+        }

+        elsif (length) {

+            ## In the middle of a sequence, append this text to it, and

+            ## dont forget to "expand" it if that's what the caller wanted

+            $seq->append($expand_text ? &$xtext_sub($self,$_,$seq) : $_);

+        }

+        ## Keep track of line count

+        $line += /\n/;

+        ## Remember the "current" sequence

+        $seq = $seq_stack[-1];

+    }

+

+    ## Handle unterminated sequences

+    my $errorsub = (@seq_stack > 1) ? $self->errorsub() : undef;

+    while (@seq_stack > 1) {

+       ($cmd, $file, $line) = ($seq->name, $seq->file_line);

+       $ldelim  = $seq->ldelim;

+       ($rdelim = $ldelim) =~ tr/</>/;

+       $rdelim  =~ s/^(\S+)(\s*)$/$2$1/;

+       pop @seq_stack;

+       my $errmsg = "*** ERROR: unterminated ${cmd}${ldelim}...${rdelim}".

+                    " at line $line in file $file\n";

+       (ref $errorsub) and &{$errorsub}($errmsg)

+           or (defined $errorsub) and $self->$errorsub($errmsg)

+               or  carp($errmsg);

+       $seq_stack[-1]->append($expand_seq ? &$xseq_sub($self,$seq) : $seq);

+       $seq = $seq_stack[-1];

+    }

+

+    ## Return the resulting parse-tree

+    my $ptree = (pop @seq_stack)->parse_tree;

+    return  $expand_ptree ? &$xptree_sub($self, $ptree) : $ptree;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<interpolate()>

+

+            $textblock = $parser->interpolate($text, $line_num);

+

+This method translates all text (including any embedded interior sequences)

+in the given text string C<$text> and returns the interpolated result. The

+parameter C<$line_num> is the line number corresponding to the beginning

+of C<$text>.

+

+B<interpolate()> merely invokes a private method to recursively expand

+nested interior sequences in bottom-up order (innermost sequences are

+expanded first). If there is a need to expand nested sequences in

+some alternate order, use B<parse_text> instead.

+

+=cut

+

+sub interpolate {

+    my($self, $text, $line_num) = @_;

+    my %parse_opts = ( -expand_seq => 'interior_sequence' );

+    my $ptree = $self->parse_text( \%parse_opts, $text, $line_num );

+    return  join '', $ptree->children();

+}

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head1 B<parse_paragraph()>

+

+            $parser->parse_paragraph($text, $line_num);

+

+This method takes the text of a POD paragraph to be processed, along

+with its corresponding line number, and invokes the appropriate method

+(one of B<command()>, B<verbatim()>, or B<textblock()>).

+

+For performance reasons, this method is invoked directly without any

+dynamic lookup; Hence subclasses may I<not> override it!

+

+=end __PRIVATE__

+

+=cut

+

+sub parse_paragraph {

+    my ($self, $text, $line_num) = @_;

+    local *myData = $self;  ## alias to avoid deref-ing overhead

+    local *myOpts = ($myData{_PARSEOPTS} ||= {});  ## get parse-options

+    local $_;

+

+    ## See if we want to preprocess nonPOD paragraphs as well as POD ones.

+    my $wantNonPods = $myOpts{'-want_nonPODs'};

+

+    ## Update cutting status

+    $myData{_CUTTING} = 0 if $text =~ /^={1,2}\S/;

+

+    ## Perform any desired preprocessing if we wanted it this early

+    $wantNonPods  and  $text = $self->preprocess_paragraph($text, $line_num);

+

+    ## Ignore up until next POD directive if we are cutting

+    return if $myData{_CUTTING};

+

+    ## Now we know this is block of text in a POD section!

+

+    ##-----------------------------------------------------------------

+    ## This is a hook (hack ;-) for Pod::Select to do its thing without

+    ## having to override methods, but also without Pod::Parser assuming

+    ## $self is an instance of Pod::Select (if the _SELECTED_SECTIONS

+    ## field exists then we assume there is an is_selected() method for

+    ## us to invoke (calling $self->can('is_selected') could verify this

+    ## but that is more overhead than I want to incur)

+    ##-----------------------------------------------------------------

+

+    ## Ignore this block if it isnt in one of the selected sections

+    if (exists $myData{_SELECTED_SECTIONS}) {

+        $self->is_selected($text)  or  return ($myData{_CUTTING} = 1);

+    }

+

+    ## If we havent already, perform any desired preprocessing and

+    ## then re-check the "cutting" state

+    unless ($wantNonPods) {

+       $text = $self->preprocess_paragraph($text, $line_num);

+       return 1  unless ((defined $text) and (length $text));

+       return 1  if ($myData{_CUTTING});

+    }

+

+    ## Look for one of the three types of paragraphs

+    my ($pfx, $cmd, $arg, $sep) = ('', '', '', '');

+    my $pod_para = undef;

+    if ($text =~ /^(={1,2})(?=\S)/) {

+        ## Looks like a command paragraph. Capture the command prefix used

+        ## ("=" or "=="), as well as the command-name, its paragraph text,

+        ## and whatever sequence of characters was used to separate them

+        $pfx = $1;

+        $_ = substr($text, length $pfx);

+        ($cmd, $sep, $text) = split /(\s+)/, $_, 2;

+        $sep = '' unless defined $sep;

+        $text = '' unless defined $text;

+        ## If this is a "cut" directive then we dont need to do anything

+        ## except return to "cutting" mode.

+        if ($cmd eq 'cut') {

+           $myData{_CUTTING} = 1;

+           return  unless $myOpts{'-process_cut_cmd'};

+        }

+    }

+    ## Save the attributes indicating how the command was specified.

+    $pod_para = new Pod::Paragraph(

+          -name      => $cmd,

+          -text      => $text,

+          -prefix    => $pfx,

+          -separator => $sep,

+          -file      => $myData{_INFILE},

+          -line      => $line_num

+    );

+    # ## Invoke appropriate callbacks

+    # if (exists $myData{_CALLBACKS}) {

+    #    ## Look through the callback list, invoke callbacks,

+    #    ## then see if we need to do the default actions

+    #    ## (invoke_callbacks will return true if we do).

+    #    return  1  unless $self->invoke_callbacks($cmd, $text, $line_num, $pod_para);

+    # }

+

+    # If the last paragraph ended in whitespace, and we're not between verbatim blocks, carp

+    if ($myData{_WHITESPACE} and $myOpts{'-warnings'}

+            and not ($text =~ /^\s+/ and ($myData{_PREVIOUS}||"") eq "verbatim")) {

+        my $errorsub = $self->errorsub();

+        my $line = $line_num - 1;

+        my $errmsg = "*** WARNING: line containing nothing but whitespace".

+                     " in paragraph at line $line in file $myData{_INFILE}\n";

+        (ref $errorsub) and &{$errorsub}($errmsg)

+            or (defined $errorsub) and $self->$errorsub($errmsg)

+                or  carp($errmsg);

+    }

+

+    if (length $cmd) {

+        ## A command paragraph

+        $self->command($cmd, $text, $line_num, $pod_para);

+        $myData{_PREVIOUS} = $cmd;

+    }

+    elsif ($text =~ /^\s+/) {

+        ## Indented text - must be a verbatim paragraph

+        $self->verbatim($text, $line_num, $pod_para);

+        $myData{_PREVIOUS} = "verbatim";

+    }

+    else {

+        ## Looks like an ordinary block of text

+        $self->textblock($text, $line_num, $pod_para);

+        $myData{_PREVIOUS} = "textblock";

+    }

+

+    # Update the whitespace for the next time around

+    #$myData{_WHITESPACE} = $text =~ /^[^\S\r\n]+\Z/m ? 1 : 0;

+    $myData{_WHITESPACE} = $text =~ /^[^\S\r\n]+\r*\Z/m ? 1 : 0;

+

+    return  1;

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<parse_from_filehandle()>

+

+            $parser->parse_from_filehandle($in_fh,$out_fh);

+

+This method takes an input filehandle (which is assumed to already be

+opened for reading) and reads the entire input stream looking for blocks

+(paragraphs) of POD documentation to be processed. If no first argument

+is given the default input filehandle C<STDIN> is used.

+

+The C<$in_fh> parameter may be any object that provides a B<getline()>

+method to retrieve a single line of input text (hence, an appropriate

+wrapper object could be used to parse PODs from a single string or an

+array of strings).

+

+Using C<$in_fh-E<gt>getline()>, input is read line-by-line and assembled

+into paragraphs or "blocks" (which are separated by lines containing

+nothing but whitespace). For each block of POD documentation

+encountered it will invoke a method to parse the given paragraph.

+

+If a second argument is given then it should correspond to a filehandle where

+output should be sent (otherwise the default output filehandle is

+C<STDOUT> if no output filehandle is currently in use).

+

+B<NOTE:> For performance reasons, this method caches the input stream at

+the top of the stack in a local variable. Any attempts by clients to

+change the stack contents during processing when in the midst executing

+of this method I<will not affect> the input stream used by the current

+invocation of this method.

+

+This method does I<not> usually need to be overridden by subclasses.

+

+=cut

+

+sub parse_from_filehandle {

+    my $self = shift;

+    my %opts = (ref $_[0] eq 'HASH') ? %{ shift() } : ();

+    my ($in_fh, $out_fh) = @_;

+    $in_fh = \*STDIN  unless ($in_fh);

+    local *myData = $self;  ## alias to avoid deref-ing overhead

+    local *myOpts = ($myData{_PARSEOPTS} ||= {});  ## get parse-options

+    local $_;

+

+    ## Put this stream at the top of the stack and do beginning-of-input

+    ## processing. NOTE that $in_fh might be reset during this process.

+    my $topstream = $self->_push_input_stream($in_fh, $out_fh);

+    (exists $opts{-cutting})  and  $self->cutting( $opts{-cutting} );

+

+    ## Initialize line/paragraph

+    my ($textline, $paragraph) = ('', '');

+    my ($nlines, $plines) = (0, 0);

+

+    ## Use <$fh> instead of $fh->getline where possible (for speed)

+    $_ = ref $in_fh;

+    my $tied_fh = (/^(?:GLOB|FileHandle|IO::\w+)$/  or  tied $in_fh);

+

+    ## Read paragraphs line-by-line

+    while (defined ($textline = $tied_fh ? <$in_fh> : $in_fh->getline)) {

+        $textline = $self->preprocess_line($textline, ++$nlines);

+        next  unless ((defined $textline)  &&  (length $textline));

+

+        if ((! length $paragraph) && ($textline =~ /^==/)) {

+            ## '==' denotes a one-line command paragraph

+            $paragraph = $textline;

+            $plines    = 1;

+            $textline  = '';

+        } else {

+            ## Append this line to the current paragraph

+            $paragraph .= $textline;

+            ++$plines;

+        }

+

+        ## See if this line is blank and ends the current paragraph.

+        ## If it isnt, then keep iterating until it is.

+        next unless (($textline =~ /^[^\S\r\n]*[\r\n]*$/)

+                                     && (length $paragraph));

+

+        ## Now process the paragraph

+        parse_paragraph($self, $paragraph, ($nlines - $plines) + 1);

+        $paragraph = '';

+        $plines = 0;

+    }

+    ## Dont forget about the last paragraph in the file

+    if (length $paragraph) {

+       parse_paragraph($self, $paragraph, ($nlines - $plines) + 1)

+    }

+

+    ## Now pop the input stream off the top of the input stack.

+    $self->_pop_input_stream();

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<parse_from_file()>

+

+            $parser->parse_from_file($filename,$outfile);

+

+This method takes a filename and does the following:

+

+=over 2

+

+=item *

+

+opens the input and output files for reading

+(creating the appropriate filehandles)

+

+=item *

+

+invokes the B<parse_from_filehandle()> method passing it the

+corresponding input and output filehandles.

+

+=item *

+

+closes the input and output files.

+

+=back

+

+If the special input filename "-" or "<&STDIN" is given then the STDIN

+filehandle is used for input (and no open or close is performed). If no

+input filename is specified then "-" is implied. Filehandle references,

+or objects that support the regular IO operations (like C<E<lt>$fhE<gt>>

+or C<$fh-<Egt>getline>) are also accepted; the handles must already be 

+opened.

+

+If a second argument is given then it should be the name of the desired

+output file. If the special output filename "-" or ">&STDOUT" is given

+then the STDOUT filehandle is used for output (and no open or close is

+performed). If the special output filename ">&STDERR" is given then the

+STDERR filehandle is used for output (and no open or close is

+performed). If no output filehandle is currently in use and no output

+filename is specified, then "-" is implied.

+Alternatively, filehandle references or objects that support the regular

+IO operations (like C<print>, e.g. L<IO::String>) are also accepted;

+the object must already be opened.

+

+This method does I<not> usually need to be overridden by subclasses.

+

+=cut

+

+sub parse_from_file {

+    my $self = shift;

+    my %opts = (ref $_[0] eq 'HASH') ? %{ shift() } : ();

+    my ($infile, $outfile) = @_;

+    my ($in_fh,  $out_fh);

+    if ($] < 5.006) {

+      ($in_fh,  $out_fh) = (gensym(), gensym());

+    }

+    my ($close_input, $close_output) = (0, 0);

+    local *myData = $self;

+    local *_;

+

+    ## Is $infile a filename or a (possibly implied) filehandle

+    if (defined $infile && ref $infile) {

+        if (ref($infile) =~ /^(SCALAR|ARRAY|HASH|CODE|REF)$/) {

+            croak "Input from $1 reference not supported!\n";

+        }

+        ## Must be a filehandle-ref (or else assume its a ref to an object

+        ## that supports the common IO read operations).

+        $myData{_INFILE} = ${$infile};

+        $in_fh = $infile;

+    }

+    elsif (!defined($infile) || !length($infile) || ($infile eq '-')

+        || ($infile =~ /^<&(?:STDIN|0)$/i))

+    {

+        ## Not a filename, just a string implying STDIN

+        $infile ||= '-';

+        $myData{_INFILE} = '<standard input>';

+        $in_fh = \*STDIN;

+    }

+    else {

+        ## We have a filename, open it for reading

+        $myData{_INFILE} = $infile;

+        open($in_fh, "< $infile")  or

+             croak "Can't open $infile for reading: $!\n";

+        $close_input = 1;

+    }

+

+    ## NOTE: we need to be *very* careful when "defaulting" the output

+    ## file. We only want to use a default if this is the beginning of

+    ## the entire document (but *not* if this is an included file). We

+    ## determine this by seeing if the input stream stack has been set-up

+    ## already

+

+    ## Is $outfile a filename, a (possibly implied) filehandle, maybe a ref?

+    if (ref $outfile) {

+        ## we need to check for ref() first, as other checks involve reading

+        if (ref($outfile) =~ /^(ARRAY|HASH|CODE)$/) {

+            croak "Output to $1 reference not supported!\n";

+        }

+        elsif (ref($outfile) eq 'SCALAR') {

+#           # NOTE: IO::String isn't a part of the perl distribution,

+#           #       so probably we shouldn't support this case...

+#           require IO::String;

+#           $myData{_OUTFILE} = "$outfile";

+#           $out_fh = IO::String->new($outfile);

+            croak "Output to SCALAR reference not supported!\n";

+        }

+        else {

+            ## Must be a filehandle-ref (or else assume its a ref to an

+            ## object that supports the common IO write operations).

+            $myData{_OUTFILE} = ${$outfile};

+            $out_fh = $outfile;

+        }

+    }

+    elsif (!defined($outfile) || !length($outfile) || ($outfile eq '-')

+        || ($outfile =~ /^>&?(?:STDOUT|1)$/i))

+    {

+        if (defined $myData{_TOP_STREAM}) {

+            $out_fh = $myData{_OUTPUT};

+        }

+        else {

+            ## Not a filename, just a string implying STDOUT

+            $outfile ||= '-';

+            $myData{_OUTFILE} = '<standard output>';

+            $out_fh  = \*STDOUT;

+        }

+    }

+    elsif ($outfile =~ /^>&(STDERR|2)$/i) {

+        ## Not a filename, just a string implying STDERR

+        $myData{_OUTFILE} = '<standard error>';

+        $out_fh  = \*STDERR;

+    }

+    else {

+        ## We have a filename, open it for writing

+        $myData{_OUTFILE} = $outfile;

+        (-d $outfile) and croak "$outfile is a directory, not POD input!\n";

+        open($out_fh, "> $outfile")  or

+             croak "Can't open $outfile for writing: $!\n";

+        $close_output = 1;

+    }

+

+    ## Whew! That was a lot of work to set up reasonably/robust behavior

+    ## in the case of a non-filename for reading and writing. Now we just

+    ## have to parse the input and close the handles when we're finished.

+    $self->parse_from_filehandle(\%opts, $in_fh, $out_fh);

+

+    $close_input  and

+        close($in_fh) || croak "Can't close $infile after reading: $!\n";

+    $close_output  and

+        close($out_fh) || croak "Can't close $outfile after writing: $!\n";

+}

+

+#############################################################################

+

+=head1 ACCESSOR METHODS

+

+Clients of B<Pod::Parser> should use the following methods to access

+instance data fields:

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=head1 B<errorsub()>

+

+            $parser->errorsub("method_name");

+            $parser->errorsub(\&warn_user);

+            $parser->errorsub(sub { print STDERR, @_ });

+

+Specifies the method or subroutine to use when printing error messages

+about POD syntax. The supplied method/subroutine I<must> return TRUE upon

+successful printing of the message. If C<undef> is given, then the B<carp>

+builtin is used to issue error messages (this is the default behavior).

+

+            my $errorsub = $parser->errorsub()

+            my $errmsg = "This is an error message!\n"

+            (ref $errorsub) and &{$errorsub}($errmsg)

+                or (defined $errorsub) and $parser->$errorsub($errmsg)

+                    or  carp($errmsg);

+

+Returns a method name, or else a reference to the user-supplied subroutine

+used to print error messages. Returns C<undef> if the B<carp> builtin

+is used to issue error messages (this is the default behavior).

+

+=cut

+

+sub errorsub {

+   return (@_ > 1) ? ($_[0]->{_ERRORSUB} = $_[1]) : $_[0]->{_ERRORSUB};

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<cutting()>

+

+            $boolean = $parser->cutting();

+

+Returns the current C<cutting> state: a boolean-valued scalar which

+evaluates to true if text from the input file is currently being "cut"

+(meaning it is I<not> considered part of the POD document).

+

+            $parser->cutting($boolean);

+

+Sets the current C<cutting> state to the given value and returns the

+result.

+

+=cut

+

+sub cutting {

+   return (@_ > 1) ? ($_[0]->{_CUTTING} = $_[1]) : $_[0]->{_CUTTING};

+}

+

+##---------------------------------------------------------------------------

+

+##---------------------------------------------------------------------------

+

+=head1 B<parseopts()>

+

+When invoked with no additional arguments, B<parseopts> returns a hashtable

+of all the current parsing options.

+

+            ## See if we are parsing non-POD sections as well as POD ones

+            my %opts = $parser->parseopts();

+            $opts{'-want_nonPODs}' and print "-want_nonPODs\n";

+

+When invoked using a single string, B<parseopts> treats the string as the

+name of a parse-option and returns its corresponding value if it exists

+(returns C<undef> if it doesn't).

+

+            ## Did we ask to see '=cut' paragraphs?

+            my $want_cut = $parser->parseopts('-process_cut_cmd');

+            $want_cut and print "-process_cut_cmd\n";

+

+When invoked with multiple arguments, B<parseopts> treats them as

+key/value pairs and the specified parse-option names are set to the

+given values. Any unspecified parse-options are unaffected.

+

+            ## Set them back to the default

+            $parser->parseopts(-warnings => 0);

+

+When passed a single hash-ref, B<parseopts> uses that hash to completely

+reset the existing parse-options, all previous parse-option values

+are lost.

+

+            ## Reset all options to default 

+            $parser->parseopts( { } );

+

+See L<"PARSING OPTIONS"> for more information on the name and meaning of each

+parse-option currently recognized.

+

+=cut

+

+sub parseopts {

+   local *myData = shift;

+   local *myOpts = ($myData{_PARSEOPTS} ||= {});

+   return %myOpts  if (@_ == 0);

+   if (@_ == 1) {

+      local $_ = shift;

+      return  ref($_)  ?  $myData{_PARSEOPTS} = $_  :  $myOpts{$_};

+   }

+   my @newOpts = (%myOpts, @_);

+   $myData{_PARSEOPTS} = { @newOpts };

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<output_file()>

+

+            $fname = $parser->output_file();

+

+Returns the name of the output file being written.

+

+=cut

+

+sub output_file {

+   return $_[0]->{_OUTFILE};

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<output_handle()>

+

+            $fhandle = $parser->output_handle();

+

+Returns the output filehandle object.

+

+=cut

+

+sub output_handle {

+   return $_[0]->{_OUTPUT};

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<input_file()>

+

+            $fname = $parser->input_file();

+

+Returns the name of the input file being read.

+

+=cut

+

+sub input_file {

+   return $_[0]->{_INFILE};

+}

+

+##---------------------------------------------------------------------------

+

+=head1 B<input_handle()>

+

+            $fhandle = $parser->input_handle();

+

+Returns the current input filehandle object.

+

+=cut

+

+sub input_handle {

+   return $_[0]->{_INPUT};

+}

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head1 B<input_streams()>

+

+            $listref = $parser->input_streams();

+

+Returns a reference to an array which corresponds to the stack of all

+the input streams that are currently in the middle of being parsed.

+

+While parsing an input stream, it is possible to invoke

+B<parse_from_file()> or B<parse_from_filehandle()> to parse a new input

+stream and then return to parsing the previous input stream. Each input

+stream to be parsed is pushed onto the end of this input stack

+before any of its input is read. The input stream that is currently

+being parsed is always at the end (or top) of the input stack. When an

+input stream has been exhausted, it is popped off the end of the

+input stack.

+

+Each element on this input stack is a reference to C<Pod::InputSource>

+object. Please see L<Pod::InputObjects> for more details.

+

+This method might be invoked when printing diagnostic messages, for example,

+to obtain the name and line number of the all input files that are currently

+being processed.

+

+=end __PRIVATE__

+

+=cut

+

+sub input_streams {

+   return $_[0]->{_INPUT_STREAMS};

+}

+

+##---------------------------------------------------------------------------

+

+=begin __PRIVATE__

+

+=head1 B<top_stream()>

+

+            $hashref = $parser->top_stream();

+

+Returns a reference to the hash-table that represents the element

+that is currently at the top (end) of the input stream stack

+(see L<"input_streams()">). The return value will be the C<undef>

+if the input stack is empty.

+

+This method might be used when printing diagnostic messages, for example,

+to obtain the name and line number of the current input file.

+

+=end __PRIVATE__

+

+=cut

+

+sub top_stream {

+   return $_[0]->{_TOP_STREAM} || undef;

+}

+

+#############################################################################

+

+=head1 PRIVATE METHODS AND DATA

+

+B<Pod::Parser> makes use of several internal methods and data fields

+which clients should not need to see or use. For the sake of avoiding

+name collisions for client data and methods, these methods and fields

+are briefly discussed here. Determined hackers may obtain further

+information about them by reading the B<Pod::Parser> source code.

+

+Private data fields are stored in the hash-object whose reference is

+returned by the B<new()> constructor for this class. The names of all

+private methods and data-fields used by B<Pod::Parser> begin with a

+prefix of "_" and match the regular expression C</^_\w+$/>.

+

+=cut

+

+##---------------------------------------------------------------------------

+

+=begin _PRIVATE_

+

+=head1 B<_push_input_stream()>

+

+            $hashref = $parser->_push_input_stream($in_fh,$out_fh);

+

+This method will push the given input stream on the input stack and

+perform any necessary beginning-of-document or beginning-of-file

+processing. The argument C<$in_fh> is the input stream filehandle to

+push, and C<$out_fh> is the corresponding output filehandle to use (if

+it is not given or is undefined, then the current output stream is used,

+which defaults to standard output if it doesnt exist yet).

+

+The value returned will be reference to the hash-table that represents

+the new top of the input stream stack. I<Please Note> that it is

+possible for this method to use default values for the input and output

+file handles. If this happens, you will need to look at the C<INPUT>

+and C<OUTPUT> instance data members to determine their new values.

+

+=end _PRIVATE_

+

+=cut

+

+sub _push_input_stream {

+    my ($self, $in_fh, $out_fh) = @_;

+    local *myData = $self;

+

+    ## Initialize stuff for the entire document if this is *not*

+    ## an included file.

+    ##

+    ## NOTE: we need to be *very* careful when "defaulting" the output

+    ## filehandle. We only want to use a default value if this is the

+    ## beginning of the entire document (but *not* if this is an included

+    ## file).

+    unless (defined  $myData{_TOP_STREAM}) {

+        $out_fh  = \*STDOUT  unless (defined $out_fh);

+        $myData{_CUTTING}       = 1;   ## current "cutting" state

+        $myData{_INPUT_STREAMS} = [];  ## stack of all input streams

+    }

+

+    ## Initialize input indicators

+    $myData{_OUTFILE} = '(unknown)'  unless (defined  $myData{_OUTFILE});

+    $myData{_OUTPUT}  = $out_fh      if (defined  $out_fh);

+    $in_fh            = \*STDIN      unless (defined  $in_fh);

+    $myData{_INFILE}  = '(unknown)'  unless (defined  $myData{_INFILE});

+    $myData{_INPUT}   = $in_fh;

+    my $input_top     = $myData{_TOP_STREAM}

+                      = new Pod::InputSource(

+                            -name        => $myData{_INFILE},

+                            -handle      => $in_fh,

+                            -was_cutting => $myData{_CUTTING}

+                        );

+    local *input_stack = $myData{_INPUT_STREAMS};

+    push(@input_stack, $input_top);

+

+    ## Perform beginning-of-document and/or beginning-of-input processing

+    $self->begin_pod()  if (@input_stack == 1);

+    $self->begin_input();

+

+    return  $input_top;

+}

+

+##---------------------------------------------------------------------------

+

+=begin _PRIVATE_

+

+=head1 B<_pop_input_stream()>

+

+            $hashref = $parser->_pop_input_stream();

+

+This takes no arguments. It will perform any necessary end-of-file or

+end-of-document processing and then pop the current input stream from

+the top of the input stack.

+

+The value returned will be reference to the hash-table that represents

+the new top of the input stream stack.

+

+=end _PRIVATE_

+

+=cut

+

+sub _pop_input_stream {

+    my ($self) = @_;

+    local *myData = $self;

+    local *input_stack = $myData{_INPUT_STREAMS};

+

+    ## Perform end-of-input and/or end-of-document processing

+    $self->end_input()  if (@input_stack > 0);

+    $self->end_pod()    if (@input_stack == 1);

+

+    ## Restore cutting state to whatever it was before we started

+    ## parsing this file.

+    my $old_top = pop(@input_stack);

+    $myData{_CUTTING} = $old_top->was_cutting();

+

+    ## Dont forget to reset the input indicators

+    my $input_top = undef;

+    if (@input_stack > 0) {

+       $input_top = $myData{_TOP_STREAM} = $input_stack[-1];

+       $myData{_INFILE}  = $input_top->name();

+       $myData{_INPUT}   = $input_top->handle();

+    } else {

+       delete $myData{_TOP_STREAM};

+       delete $myData{_INPUT_STREAMS};

+    }

+

+    return  $input_top;

+}

+

+#############################################################################

+

+=head1 TREE-BASED PARSING

+

+If straightforward stream-based parsing wont meet your needs (as is

+likely the case for tasks such as translating PODs into structured

+markup languages like HTML and XML) then you may need to take the

+tree-based approach. Rather than doing everything in one pass and

+calling the B<interpolate()> method to expand sequences into text, it

+may be desirable to instead create a parse-tree using the B<parse_text()>

+method to return a tree-like structure which may contain an ordered

+list of children (each of which may be a text-string, or a similar

+tree-like structure).

+

+Pay special attention to L<"METHODS FOR PARSING AND PROCESSING"> and

+to the objects described in L<Pod::InputObjects>. The former describes

+the gory details and parameters for how to customize and extend the

+parsing behavior of B<Pod::Parser>. B<Pod::InputObjects> provides

+several objects that may all be used interchangeably as parse-trees. The

+most obvious one is the B<Pod::ParseTree> object. It defines the basic

+interface and functionality that all things trying to be a POD parse-tree

+should do. A B<Pod::ParseTree> is defined such that each "node" may be a

+text-string, or a reference to another parse-tree.  Each B<Pod::Paragraph>

+object and each B<Pod::InteriorSequence> object also supports the basic

+parse-tree interface.

+

+The B<parse_text()> method takes a given paragraph of text, and

+returns a parse-tree that contains one or more children, each of which

+may be a text-string, or an InteriorSequence object. There are also

+callback-options that may be passed to B<parse_text()> to customize

+the way it expands or transforms interior-sequences, as well as the

+returned result. These callbacks can be used to create a parse-tree

+with custom-made objects (which may or may not support the parse-tree

+interface, depending on how you choose to do it).

+

+If you wish to turn an entire POD document into a parse-tree, that process

+is fairly straightforward. The B<parse_text()> method is the key to doing

+this successfully. Every paragraph-callback (i.e. the polymorphic methods

+for B<command()>, B<verbatim()>, and B<textblock()> paragraphs) takes

+a B<Pod::Paragraph> object as an argument. Each paragraph object has a

+B<parse_tree()> method that can be used to get or set a corresponding

+parse-tree. So for each of those paragraph-callback methods, simply call

+B<parse_text()> with the options you desire, and then use the returned

+parse-tree to assign to the given paragraph object.

+

+That gives you a parse-tree for each paragraph - so now all you need is

+an ordered list of paragraphs. You can maintain that yourself as a data

+element in the object/hash. The most straightforward way would be simply

+to use an array-ref, with the desired set of custom "options" for each

+invocation of B<parse_text>. Let's assume the desired option-set is

+given by the hash C<%options>. Then we might do something like the

+following:

+

+    package MyPodParserTree;

+

+    @ISA = qw( Pod::Parser );

+

+    ...

+

+    sub begin_pod {

+        my $self = shift;

+        $self->{'-paragraphs'} = [];  ## initialize paragraph list

+    }

+

+    sub command { 

+        my ($parser, $command, $paragraph, $line_num, $pod_para) = @_;

+        my $ptree = $parser->parse_text({%options}, $paragraph, ...);

+        $pod_para->parse_tree( $ptree );

+        push @{ $self->{'-paragraphs'} }, $pod_para;

+    }

+

+    sub verbatim { 

+        my ($parser, $paragraph, $line_num, $pod_para) = @_;

+        push @{ $self->{'-paragraphs'} }, $pod_para;

+    }

+

+    sub textblock { 

+        my ($parser, $paragraph, $line_num, $pod_para) = @_;

+        my $ptree = $parser->parse_text({%options}, $paragraph, ...);

+        $pod_para->parse_tree( $ptree );

+        push @{ $self->{'-paragraphs'} }, $pod_para;

+    }

+

+    ...

+

+    package main;

+    ...

+    my $parser = new MyPodParserTree(...);

+    $parser->parse_from_file(...);

+    my $paragraphs_ref = $parser->{'-paragraphs'};

+

+Of course, in this module-author's humble opinion, I'd be more inclined to

+use the existing B<Pod::ParseTree> object than a simple array. That way

+everything in it, paragraphs and sequences, all respond to the same core

+interface for all parse-tree nodes. The result would look something like:

+

+    package MyPodParserTree2;

+

+    ...

+

+    sub begin_pod {

+        my $self = shift;

+        $self->{'-ptree'} = new Pod::ParseTree;  ## initialize parse-tree

+    }

+

+    sub parse_tree {

+        ## convenience method to get/set the parse-tree for the entire POD

+        (@_ > 1)  and  $_[0]->{'-ptree'} = $_[1];

+        return $_[0]->{'-ptree'};

+    }

+

+    sub command { 

+        my ($parser, $command, $paragraph, $line_num, $pod_para) = @_;

+        my $ptree = $parser->parse_text({<<options>>}, $paragraph, ...);

+        $pod_para->parse_tree( $ptree );

+        $parser->parse_tree()->append( $pod_para );

+    }

+

+    sub verbatim { 

+        my ($parser, $paragraph, $line_num, $pod_para) = @_;

+        $parser->parse_tree()->append( $pod_para );

+    }

+

+    sub textblock { 

+        my ($parser, $paragraph, $line_num, $pod_para) = @_;

+        my $ptree = $parser->parse_text({<<options>>}, $paragraph, ...);

+        $pod_para->parse_tree( $ptree );

+        $parser->parse_tree()->append( $pod_para );

+    }

+

+    ...

+

+    package main;

+    ...

+    my $parser = new MyPodParserTree2(...);

+    $parser->parse_from_file(...);

+    my $ptree = $parser->parse_tree;

+    ...

+

+Now you have the entire POD document as one great big parse-tree. You

+can even use the B<-expand_seq> option to B<parse_text> to insert

+whole different kinds of objects. Just don't expect B<Pod::Parser>

+to know what to do with them after that. That will need to be in your

+code. Or, alternatively, you can insert any object you like so long as

+it conforms to the B<Pod::ParseTree> interface.

+

+One could use this to create subclasses of B<Pod::Paragraphs> and

+B<Pod::InteriorSequences> for specific commands (or to create your own

+custom node-types in the parse-tree) and add some kind of B<emit()>

+method to each custom node/subclass object in the tree. Then all you'd

+need to do is recursively walk the tree in the desired order, processing

+the children (most likely from left to right) by formatting them if

+they are text-strings, or by calling their B<emit()> method if they

+are objects/references.

+

+=head1 CAVEATS

+

+Please note that POD has the notion of "paragraphs": this is something

+starting I<after> a blank (read: empty) line, with the single exception

+of the file start, which is also starting a paragraph. That means that

+especially a command (e.g. C<=head1>) I<must> be preceded with a blank

+line; C<__END__> is I<not> a blank line.

+

+=head1 SEE ALSO

+

+L<Pod::InputObjects>, L<Pod::Select>

+

+B<Pod::InputObjects> defines POD input objects corresponding to

+command paragraphs, parse-trees, and interior-sequences.

+

+B<Pod::Select> is a subclass of B<Pod::Parser> which provides the ability

+to selectively include and/or exclude sections of a POD document from being

+translated based upon the current heading, subheading, subsubheading, etc.

+

+=for __PRIVATE__

+B<Pod::Callbacks> is a subclass of B<Pod::Parser> which gives its users

+the ability the employ I<callback functions> instead of, or in addition

+to, overriding methods of the base class.

+

+=for __PRIVATE__

+B<Pod::Select> and B<Pod::Callbacks> do not override any

+methods nor do they define any new methods with the same name. Because

+of this, they may I<both> be used (in combination) as a base class of

+the same subclass in order to combine their functionality without

+causing any namespace clashes due to multiple inheritance.

+

+=head1 AUTHOR

+

+Please report bugs using L<http://rt.cpan.org>.

+

+Brad Appleton E<lt>bradapp@enteract.comE<gt>

+

+Based on code for B<Pod::Text> written by

+Tom Christiansen E<lt>tchrist@mox.perl.comE<gt>

+

+=head1 LICENSE

+

+Pod-Parser is free software; you can redistribute it and/or modify it

+under the terms of the Artistic License distributed with Perl version

+5.000 or (at your option) any later version. Please refer to the

+Artistic License that came with your Perl distribution for more

+details. If your version of Perl was not distributed under the

+terms of the Artistic License, than you may distribute PodParser

+under the same terms as Perl itself.

+

+=cut

+

+1;

+# vim: ts=4 sw=4 et

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/scripts/podselect.PL b/gnu/usr.bin/perl/cpan/Pod-Parser/scripts/podselect.PL
index 7fadd7366cb..16e2d985be6 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/scripts/podselect.PL
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/scripts/podselect.PL
@@ -1,143 +1,143 @@
-#!/usr/local/bin/perl
-
-use Config;
-use File::Basename qw(&basename &dirname);
-use Cwd;
-
-# List explicitly here the variables you want Configure to
-# generate.  Metaconfig only looks for shell variables, so you
-# have to mention them as if they were shell variables, not
-# %Config entries.  Thus you write
-#  $startperl
-# to ensure Configure will look for $Config{startperl}.
-
-# This forces PL files to create target in same directory as PL file.
-# This is so that make depend always knows where to find PL derivatives.
-$origdir = cwd;
-chdir(dirname($0));
-$file = basename($0, '.PL');
-$file .= '.com' if $^O eq 'VMS';
-
-open OUT,">$file" or die "Can't create $file: $!";
-
-print "Extracting $file (with variable substitutions)\n";
-
-# In this section, perl variables will be expanded during extraction.
-# You can use $Config{...} to use Configure variables.
-
-print OUT <<"!GROK!THIS!";
-$Config{'startperl'}
-    eval 'exec perl -S \$0 "\$@"'
-        if 0;
-!GROK!THIS!
-
-# In the following, perl variables are not expanded during extraction.
-
-print OUT <<'!NO!SUBS!';
-
-#############################################################################
-# podselect -- command to invoke the podselect function in Pod::Select
-#
-# Copyright (c) 1996-2000 by Bradford Appleton. All rights reserved.
-# This file is part of "PodParser". PodParser is free software;
-# you can redistribute it and/or modify it under the same terms
-# as Perl itself.
-#############################################################################
-
-use strict;
-#use diagnostics;
-
-=head1 NAME
-
-podselect - print selected sections of pod documentation on standard output
-
-=head1 SYNOPSIS
-
-B<podselect> [B<-help>] [B<-man>] [B<-section>S< >I<section-spec>]
-[I<file>S< >...]
-
-=head1 OPTIONS AND ARGUMENTS
-
-=over 8
-
-=item B<-help>
-
-Print a brief help message and exit.
-
-=item B<-man>
-
-Print the manual page and exit.
-
-=item B<-section>S< >I<section-spec>
-
-Specify a section to include in the output.
-See L<Pod::Parser/"SECTION SPECIFICATIONS">
-for the format to use for I<section-spec>.
-This option may be given multiple times on the command line.
-
-=item I<file>
-
-The pathname of a file from which to select sections of pod
-documentation (defaults to standard input).
-
-=back
-
-=head1 DESCRIPTION
-
-B<podselect> will read the given input files looking for pod
-documentation and will print out (in raw pod format) all sections that
-match one ore more of the given section specifications. If no section
-specifications are given than all pod sections encountered are output.
-
-B<podselect> invokes the B<podselect()> function exported by B<Pod::Select>
-Please see L<Pod::Select/podselect()> for more details.
-
-=head1 SEE ALSO
-
-L<Pod::Parser> and L<Pod::Select>
-
-=head1 AUTHOR
-
-Please report bugs using L<http://rt.cpan.org>.
-
-Brad Appleton E<lt>bradapp@enteract.comE<gt>
-
-Based on code for B<Pod::Text::pod2text(1)> written by
-Tom Christiansen E<lt>tchrist@mox.perl.comE<gt>
-
-=cut
-
-use Pod::Select;
-use Pod::Usage;
-use Getopt::Long;
-
-## Define options
-my %options = (
-        'help'     => 0,
-        'man'      => 0,
-        'sections' => [],
-);
-
-## Parse options
-GetOptions(\%options, 'help', 'man', 'sections|select=s@')  ||  pod2usage(2);
-pod2usage(1)  if ($options{help});
-pod2usage(-verbose => 2)  if ($options{man});
-
-## Dont default to STDIN if connected to a terminal
-pod2usage(2) if ((@ARGV == 0) && (-t STDIN));
-
-## Invoke podselect().
-if (@{ $options{'sections'} } > 0) {
-    podselect({ -sections => $options{'sections'} }, @ARGV);
-}
-else {
-    podselect(@ARGV);
-}
-
-
-!NO!SUBS!
-
-close OUT or die "Can't close $file: $!";
-chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
-exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';
-chdir $origdir;
+#!/usr/local/bin/perl

+

+use Config;

+use File::Basename qw(&basename &dirname);

+use Cwd;

+

+# List explicitly here the variables you want Configure to

+# generate.  Metaconfig only looks for shell variables, so you

+# have to mention them as if they were shell variables, not

+# %Config entries.  Thus you write

+#  $startperl

+# to ensure Configure will look for $Config{startperl}.

+

+# This forces PL files to create target in same directory as PL file.

+# This is so that make depend always knows where to find PL derivatives.

+$origdir = cwd;

+chdir(dirname($0));

+$file = basename($0, '.PL');

+$file .= '.com' if $^O eq 'VMS';

+

+open OUT,">$file" or die "Can't create $file: $!";

+

+print "Extracting $file (with variable substitutions)\n";

+

+# In this section, perl variables will be expanded during extraction.

+# You can use $Config{...} to use Configure variables.

+

+print OUT <<"!GROK!THIS!";

+$Config{'startperl'}

+    eval 'exec perl -S \$0 "\$@"'

+        if 0;

+!GROK!THIS!

+

+# In the following, perl variables are not expanded during extraction.

+

+print OUT <<'!NO!SUBS!';

+

+#############################################################################

+# podselect -- command to invoke the podselect function in Pod::Select

+#

+# Copyright (c) 1996-2000 by Bradford Appleton. All rights reserved.

+# This file is part of "PodParser". PodParser is free software;

+# you can redistribute it and/or modify it under the same terms

+# as Perl itself.

+#############################################################################

+

+use strict;

+#use diagnostics;

+

+=head1 NAME

+

+podselect - print selected sections of pod documentation on standard output

+

+=head1 SYNOPSIS

+

+B<podselect> [B<-help>] [B<-man>] [B<-section>S< >I<section-spec>]

+[I<file>S< >...]

+

+=head1 OPTIONS AND ARGUMENTS

+

+=over 8

+

+=item B<-help>

+

+Print a brief help message and exit.

+

+=item B<-man>

+

+Print the manual page and exit.

+

+=item B<-section>S< >I<section-spec>

+

+Specify a section to include in the output.

+See L<Pod::Parser/"SECTION SPECIFICATIONS">

+for the format to use for I<section-spec>.

+This option may be given multiple times on the command line.

+

+=item I<file>

+

+The pathname of a file from which to select sections of pod

+documentation (defaults to standard input).

+

+=back

+

+=head1 DESCRIPTION

+

+B<podselect> will read the given input files looking for pod

+documentation and will print out (in raw pod format) all sections that

+match one ore more of the given section specifications. If no section

+specifications are given than all pod sections encountered are output.

+

+B<podselect> invokes the B<podselect()> function exported by B<Pod::Select>

+Please see L<Pod::Select/podselect()> for more details.

+

+=head1 SEE ALSO

+

+L<Pod::Parser> and L<Pod::Select>

+

+=head1 AUTHOR

+

+Please report bugs using L<http://rt.cpan.org>.

+

+Brad Appleton E<lt>bradapp@enteract.comE<gt>

+

+Based on code for B<Pod::Text::pod2text(1)> written by

+Tom Christiansen E<lt>tchrist@mox.perl.comE<gt>

+

+=cut

+

+use Pod::Select;

+use Pod::Usage;

+use Getopt::Long;

+

+## Define options

+my %options = (

+        'help'     => 0,

+        'man'      => 0,

+        'sections' => [],

+);

+

+## Parse options

+GetOptions(\%options, 'help', 'man', 'sections|select=s@')  ||  pod2usage(2);

+pod2usage(1)  if ($options{help});

+pod2usage(-verbose => 2)  if ($options{man});

+

+## Dont default to STDIN if connected to a terminal

+pod2usage(2) if ((@ARGV == 0) && (-t STDIN));

+

+## Invoke podselect().

+if (@{ $options{'sections'} } > 0) {

+    podselect({ -sections => $options{'sections'} }, @ARGV);

+}

+else {

+    podselect(@ARGV);

+}

+

+

+!NO!SUBS!

+

+close OUT or die "Can't close $file: $!";

+chmod 0755, $file or die "Can't reset permissions for $file: $!\n";

+exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';

+chdir $origdir;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_bad_pod.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_bad_pod.xr
index ad65663e221..c7907963d95 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_bad_pod.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_bad_pod.xr
@@ -1,5 +1,5 @@
-=head foo
-
-bar baz.
-
-=cut
+=head foo

+

+bar baz.

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_pod.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_pod.xr
index 7ea408de46a..b79591a95c4 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_pod.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/contains_pod.xr
@@ -1,5 +1,5 @@
-=head1 foo
-
-bar baz.
-
-=cut
+=head1 foo

+

+bar baz.

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.t
index 59e395ea04d..53d1046345b 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.t
@@ -1,21 +1,21 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-__END__
-
-=pod
-
-= this is a test
-of the emergency
-broadcast system
-
-=cut
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+__END__

+

+=pod

+

+= this is a test

+of the emergency

+broadcast system

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.xr
index f06d2dbb097..dd474a1a447 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/emptycmd.xr
@@ -1,2 +1,2 @@
-    = this is a test of the emergency broadcast system
-
+    = this is a test of the emergency broadcast system

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/find.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/find.t
index 27d48953dcb..7cfd7ae613e 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/find.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/find.t
@@ -1,103 +1,101 @@
-# Testing of Pod::Find
-# Author: Marek Rouchal <marek@saftsack.fs.uni-bayreuth.de>
-
-$| = 1;
-
-BEGIN {
-  if ($^O eq 'VMS') {
-    print "1..0 # needs upstream patch from https://rt.cpan.org/Ticket/Display.html?id=55121";
-    exit 0;
-  }
-}
-
-use strict;
-use Test::More tests => 4;
-
-BEGIN {
-  # 1. load successful
-  use_ok('Pod::Find', qw(pod_find pod_where));
-}
-
-use File::Spec;
-
-require Cwd;
-my $THISDIR = Cwd::cwd();
-my $VERBOSE = $ENV{PERL_CORE} ? 0 : ($ENV{TEST_VERBOSE} || 0);
-my $lib_dir = File::Spec->catdir($THISDIR,'lib');
-
-if ($^O eq 'VMS') {
-    $lib_dir = VMS::Filespec::unixify($lib_dir);
-}
-
-print "### 2. searching $lib_dir\n";
-my %pods = pod_find($lib_dir);
-my @results = values %pods;
-print "### found @results\n";
-my @compare = qw(
-    Pod::Checker
-    Pod::Find
-    Pod::InputObjects
-    Pod::ParseUtils
-    Pod::Parser
-    Pod::PlainText
-    Pod::Select
-    Pod::Usage
-);
-if (File::Spec->case_tolerant || $^O eq 'dos') {
-    # must downcase before sorting
-    map {$_ = lc $_} @compare;
-    map {$_ = lc $_} @results;
-}
-my $compare = join(',', sort @compare);
-my $result = join(',', sort @results);
-is($result, $compare);
-
-print "### 3. searching for File::Find\n";
-$result = pod_where({ -inc => 1, -verbose => $VERBOSE }, 'File::Find')
-  || 'undef - pod not found!';
-print "### found $result\n";
-
-require Config;
-$compare = $ENV{PERL_CORE} ?
-      File::Spec->catfile(File::Spec->updir, File::Spec->updir, 'lib','File','Find.pm')
-      : File::Spec->catfile($Config::Config{privlibexp},"File","Find.pm");
-my $resfile = _canon($result);
-my $cmpfile = _canon($compare);
-if($^O =~ /dos|win32/i && $resfile =~ /~\d(?=\\|$)/) {
-    # we have ~1 short filenames
-    $resfile = quotemeta($resfile);
-    $resfile =~ s/\\~\d(?=\\|$)/[^\\\\]+/g;
-    ok($cmpfile =~ /^$resfile$/, "pod_where found File::Find (with long filename matching)") ||
-      diag("'$cmpfile' does not match /^$resfile\$/");
-} else {
-    is($resfile,$cmpfile,"pod_where found File::Find");
-}
-
-# Search for a documentation pod rather than a module
-my $searchpod = 'Stuff';
-print "### 4. searching for $searchpod.pod\n";
-$result = pod_where(
-  { -dirs => [ File::Spec->catdir( qw(t), 'pod', 'testpods', 'lib', 'Pod') ],
-    -verbose => $VERBOSE }, $searchpod)
-  || "undef - $searchpod.pod not found!";
-print "### found $result\n";
-
-$compare = File::Spec->catfile(
-    qw(t), 'pod', 'testpods', 'lib', 'Pod' ,'Stuff.pm');
-is(_canon($result),_canon($compare));
-
-
-# make the path as generic as possible
-sub _canon
-{
-  my ($path) = @_;
-  $path = File::Spec->canonpath($path);
-  my @comp = File::Spec->splitpath($path);
-  my @dir = File::Spec->splitdir($comp[1]);
-  $comp[1] = File::Spec->catdir(@dir);
-  $path = File::Spec->catpath(@comp);
-  $path = uc($path) if File::Spec->case_tolerant;
-  print "### general path: $path\n" if $VERBOSE;
-  $path;
-}
-
+# Testing of Pod::Find

+# Author: Marek Rouchal <marek@saftsack.fs.uni-bayreuth.de>

+

+$| = 1;

+

+BEGIN {

+  if ($^O eq 'VMS') {

+    print "1..0 # needs upstream patch from https://rt.cpan.org/Ticket/Display.html?id=55121";

+    exit 0;

+  }

+}

+

+use strict;

+use Test::More tests => 4;

+

+BEGIN {

+  # 1. load successful

+  use_ok('Pod::Find', qw(pod_find pod_where));

+}

+

+use File::Spec;

+

+require Cwd;

+my $THISDIR = Cwd::cwd();

+my $VERBOSE = $ENV{PERL_CORE} ? 0 : ($ENV{TEST_VERBOSE} || 0);

+my $lib_dir = File::Spec->catdir($THISDIR,'lib');

+

+if ($^O eq 'VMS') {

+    $lib_dir = VMS::Filespec::unixify($lib_dir);

+}

+

+print "### 2. searching $lib_dir\n";

+my %pods = pod_find($lib_dir);

+my @results = values %pods;

+print "### found @results\n";

+my @compare = qw(

+    Pod::Find

+    Pod::InputObjects

+    Pod::ParseUtils

+    Pod::Parser

+    Pod::PlainText

+    Pod::Select

+);

+if (File::Spec->case_tolerant || $^O eq 'dos') {

+    # must downcase before sorting

+    map {$_ = lc $_} @compare;

+    map {$_ = lc $_} @results;

+}

+my $compare = join(',', sort @compare);

+my $result = join(',', sort @results);

+is($result, $compare);

+

+print "### 3. searching for File::Find\n";

+$result = pod_where({ -inc => 1, -verbose => $VERBOSE }, 'File::Find')

+  || 'undef - pod not found!';

+print "### found $result\n";

+

+require Config;

+$compare = $ENV{PERL_CORE} ?

+      File::Spec->catfile(File::Spec->updir, File::Spec->updir, 'lib','File','Find.pm')

+      : File::Spec->catfile($Config::Config{privlibexp},"File","Find.pm");

+my $resfile = _canon($result);

+my $cmpfile = _canon($compare);

+if($^O =~ /dos|win32/i && $resfile =~ /~\d(?=\\|$)/) {

+    # we have ~1 short filenames

+    $resfile = quotemeta($resfile);

+    $resfile =~ s/\\~\d(?=\\|$)/[^\\\\]+/g;

+    ok($cmpfile =~ /^$resfile$/, "pod_where found File::Find (with long filename matching)") ||

+      diag("'$cmpfile' does not match /^$resfile\$/");

+} else {

+    is($resfile,$cmpfile,"pod_where found File::Find");

+}

+

+# Search for a documentation pod rather than a module

+my $searchpod = 'Stuff';

+print "### 4. searching for $searchpod.pod\n";

+$result = pod_where(

+  { -dirs => [ File::Spec->catdir( qw(t), 'pod', 'testpods', 'lib', 'Pod') ],

+    -verbose => $VERBOSE }, $searchpod)

+  || "undef - $searchpod.pod not found!";

+print "### found $result\n";

+

+$compare = File::Spec->catfile(

+    qw(t), 'pod', 'testpods', 'lib', 'Pod' ,'Stuff.pm');

+is(_canon($result),_canon($compare));

+

+

+# make the path as generic as possible

+sub _canon

+{

+  my ($path) = @_;

+  $path = File::Spec->canonpath($path);

+  my @comp = File::Spec->splitpath($path);

+  my @dir = File::Spec->splitdir($comp[1]);

+  $comp[1] = File::Spec->catdir(@dir);

+  $path = File::Spec->catpath(@comp);

+  $path = uc($path) if File::Spec->case_tolerant;

+  print "### general path: $path\n" if $VERBOSE;

+  $path;

+}

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.t
index 44af44f17de..12ba3392c08 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.t
@@ -1,59 +1,59 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=pod
-
-This is a test
-
-=for theloveofpete
-You shouldn't see this
-or this
-or this
-
-=for text
-pod2text should see this
-and this
-and this
-
-and everything should see this!
-
-=begin text
-
-Similarly, this line ...
-
-and this one ...
-
-as well this one,
-
-should all be in pod2text output
-
-=end text
-
-Tweedley-deedley-dee, Im as happy as can be!
-Tweedley-deedley-dum, cuz youre my honey sugar plum!
-
-=begin atthebeginning
-
-But I expect to see neither hide ...
-
-nor tail ...
-
-of this text
-
-=end atthebeginning
-
-The rest of this should show up in everything.
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=pod

+

+This is a test

+

+=for theloveofpete

+You shouldn't see this

+or this

+or this

+

+=for text

+pod2text should see this

+and this

+and this

+

+and everything should see this!

+

+=begin text

+

+Similarly, this line ...

+

+and this one ...

+

+as well this one,

+

+should all be in pod2text output

+

+=end text

+

+Tweedley-deedley-dee, Im as happy as can be!

+Tweedley-deedley-dum, cuz youre my honey sugar plum!

+

+=begin atthebeginning

+

+But I expect to see neither hide ...

+

+nor tail ...

+

+of this text

+

+=end atthebeginning

+

+The rest of this should show up in everything.

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.xr
index 5f6b8b2ce8c..b616bf2cb2b 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/for.xr
@@ -1,21 +1,21 @@
-    This is a test
-
-    pod2text should see this
-    and this
-    and this
-
-    and everything should see this!
-
-Similarly, this line ...
-
-and this one ...
-
-as well this one,
-
-should all be in pod2text output
-
-    Tweedley-deedley-dee, Im as happy as can be! Tweedley-deedley-dum, cuz
-    youre my honey sugar plum!
-
-    The rest of this should show up in everything.
-
+    This is a test

+

+    pod2text should see this

+    and this

+    and this

+

+    and everything should see this!

+

+Similarly, this line ...

+

+and this one ...

+

+as well this one,

+

+should all be in pod2text output

+

+    Tweedley-deedley-dee, Im as happy as can be! Tweedley-deedley-dum, cuz

+    youre my honey sugar plum!

+

+    The rest of this should show up in everything.

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.t
index 78608d0fd9f..4688272231a 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.t
@@ -1,140 +1,140 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-#################################################################
-  use Pod::Usage;
-  pod2usage( VERBOSE => 2, EXIT => 1 );
-
-=pod
-
-=head1 NAME
-
-B<rdb2pg> - insert an rdb table into a PostgreSQL database
-
-=head1 SYNOPSIS
-
-B<rdb2pg>  [I<param>=I<value> ...]
-
-=head1 PARAMETERS
-
-B<rdb2pg> uses an IRAF-compatible parameter interface.  
-A template parameter file is in F</proj/axaf/simul/lib/uparm/rdb2pg.par>.
-
-=over 4
-
-=item B<input> I<file>
-
-The B<RDB> file to insert into the database. If the given name
-is the string C<stdin>, it reads from the UNIX standard input stream.
-
-
-=back
-
-=head1 DESCRIPTION
-
-B<rdb2pg> will enter the data from an B<RDB> database into a
-PostgreSQL database table, optionally creating the database and the
-table if they do not exist.  It automatically determines the
-PostgreSQL data type from the column definition in the B<RDB> file,
-but may be overriden via a series of definition files or directly
-via one of its parameters.
-
-The target database and table are specified by the C<db> and C<table>
-parameters.  If they do not exist, and the C<createdb> parameter is
-set, they will be created.  Table field definitions are determined
-in the following order:
-
-=cut
-
-#################################################################
-
-results in:
-
-
-#################################################################
-
-    rdb2pg - insert an rdb table into a PostgreSQL database
-
-    rdb2pg [*param*=*value* ...]
-
-    rdb2pg uses an IRAF-compatible parameter interface. A template
-    parameter file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.
-
-    The RDB file to insert into the database. If the given name is
-    the string `stdin', it reads from the UNIX standard input
-    stream.
-
-    rdb2pg will enter the data from an RDB database into a
-    PostgreSQL database table, optionally creating the database and
-    the table if they do not exist. It automatically determines the
-    PostgreSQL data type from the column definition in the RDB file,
-    but may be overriden via a series of definition files or
-    directly via one of its parameters.
-
-    The target database and table are specified by the `db' and
-    `table' parameters. If they do not exist, and the `createdb'
-    parameter is set, they will be created. Table field definitions
-    are determined in the following order:
-
-
-#################################################################
-
-while the original version of Text (using pod2text) gives
-
-#################################################################
-
-NAME
-    rdb2pg - insert an rdb table into a PostgreSQL database
-
-SYNOPSIS
-    rdb2pg [*param*=*value* ...]
-
-PARAMETERS
-    rdb2pg uses an IRAF-compatible parameter interface. A template
-    parameter file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.
-
-    input *file*
-        The RDB file to insert into the database. If the given name
-        is the string `stdin', it reads from the UNIX standard input
-        stream.
-
-DESCRIPTION
-    rdb2pg will enter the data from an RDB database into a
-    PostgreSQL database table, optionally creating the database and
-    the table if they do not exist. It automatically determines the
-    PostgreSQL data type from the column definition in the RDB file,
-    but may be overriden via a series of definition files or
-    directly via one of its parameters.
-
-    The target database and table are specified by the `db' and
-    `table' parameters. If they do not exist, and the `createdb'
-    parameter is set, they will be created. Table field definitions
-    are determined in the following order:
-
-
-#################################################################
-
-
-Thanks for any help.  If, as your email indicates, you've not much
-time to look at this, I can work around things by calling pod2text()
-directly using the official Text.pm.
-
-Diab
-
--------------
-Diab Jerius
-djerius@cfa.harvard.edu
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+#################################################################

+  use Pod::Usage;

+  pod2usage( VERBOSE => 2, EXIT => 1 );

+

+=pod

+

+=head1 NAME

+

+B<rdb2pg> - insert an rdb table into a PostgreSQL database

+

+=head1 SYNOPSIS

+

+B<rdb2pg>  [I<param>=I<value> ...]

+

+=head1 PARAMETERS

+

+B<rdb2pg> uses an IRAF-compatible parameter interface.  

+A template parameter file is in F</proj/axaf/simul/lib/uparm/rdb2pg.par>.

+

+=over 4

+

+=item B<input> I<file>

+

+The B<RDB> file to insert into the database. If the given name

+is the string C<stdin>, it reads from the UNIX standard input stream.

+

+

+=back

+

+=head1 DESCRIPTION

+

+B<rdb2pg> will enter the data from an B<RDB> database into a

+PostgreSQL database table, optionally creating the database and the

+table if they do not exist.  It automatically determines the

+PostgreSQL data type from the column definition in the B<RDB> file,

+but may be overriden via a series of definition files or directly

+via one of its parameters.

+

+The target database and table are specified by the C<db> and C<table>

+parameters.  If they do not exist, and the C<createdb> parameter is

+set, they will be created.  Table field definitions are determined

+in the following order:

+

+=cut

+

+#################################################################

+

+results in:

+

+

+#################################################################

+

+    rdb2pg - insert an rdb table into a PostgreSQL database

+

+    rdb2pg [*param*=*value* ...]

+

+    rdb2pg uses an IRAF-compatible parameter interface. A template

+    parameter file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.

+

+    The RDB file to insert into the database. If the given name is

+    the string `stdin', it reads from the UNIX standard input

+    stream.

+

+    rdb2pg will enter the data from an RDB database into a

+    PostgreSQL database table, optionally creating the database and

+    the table if they do not exist. It automatically determines the

+    PostgreSQL data type from the column definition in the RDB file,

+    but may be overriden via a series of definition files or

+    directly via one of its parameters.

+

+    The target database and table are specified by the `db' and

+    `table' parameters. If they do not exist, and the `createdb'

+    parameter is set, they will be created. Table field definitions

+    are determined in the following order:

+

+

+#################################################################

+

+while the original version of Text (using pod2text) gives

+

+#################################################################

+

+NAME

+    rdb2pg - insert an rdb table into a PostgreSQL database

+

+SYNOPSIS

+    rdb2pg [*param*=*value* ...]

+

+PARAMETERS

+    rdb2pg uses an IRAF-compatible parameter interface. A template

+    parameter file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.

+

+    input *file*

+        The RDB file to insert into the database. If the given name

+        is the string `stdin', it reads from the UNIX standard input

+        stream.

+

+DESCRIPTION

+    rdb2pg will enter the data from an RDB database into a

+    PostgreSQL database table, optionally creating the database and

+    the table if they do not exist. It automatically determines the

+    PostgreSQL data type from the column definition in the RDB file,

+    but may be overriden via a series of definition files or

+    directly via one of its parameters.

+

+    The target database and table are specified by the `db' and

+    `table' parameters. If they do not exist, and the `createdb'

+    parameter is set, they will be created. Table field definitions

+    are determined in the following order:

+

+

+#################################################################

+

+

+Thanks for any help.  If, as your email indicates, you've not much

+time to look at this, I can work around things by calling pod2text()

+directly using the official Text.pm.

+

+Diab

+

+-------------

+Diab Jerius

+djerius@cfa.harvard.edu

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.xr
index fb37a2b0cf6..f92efb5ecf5 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/headings.xr
@@ -1,26 +1,26 @@
-NAME
-    rdb2pg - insert an rdb table into a PostgreSQL database
-
-SYNOPSIS
-    rdb2pg [*param*=*value* ...]
-
-PARAMETERS
-    rdb2pg uses an IRAF-compatible parameter interface. A template parameter
-    file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.
-
-    input *file*
-        The RDB file to insert into the database. If the given name is the
-        string `stdin', it reads from the UNIX standard input stream.
-
-DESCRIPTION
-    rdb2pg will enter the data from an RDB database into a PostgreSQL
-    database table, optionally creating the database and the table if they
-    do not exist. It automatically determines the PostgreSQL data type from
-    the column definition in the RDB file, but may be overriden via a series
-    of definition files or directly via one of its parameters.
-
-    The target database and table are specified by the `db' and `table'
-    parameters. If they do not exist, and the `createdb' parameter is set,
-    they will be created. Table field definitions are determined in the
-    following order:
-
+NAME

+    rdb2pg - insert an rdb table into a PostgreSQL database

+

+SYNOPSIS

+    rdb2pg [*param*=*value* ...]

+

+PARAMETERS

+    rdb2pg uses an IRAF-compatible parameter interface. A template parameter

+    file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.

+

+    input *file*

+        The RDB file to insert into the database. If the given name is the

+        string `stdin', it reads from the UNIX standard input stream.

+

+DESCRIPTION

+    rdb2pg will enter the data from an RDB database into a PostgreSQL

+    database table, optionally creating the database and the table if they

+    do not exist. It automatically determines the PostgreSQL data type from

+    the column definition in the RDB file, but may be overriden via a series

+    of definition files or directly via one of its parameters.

+

+    The target database and table are specified by the `db' and `table'

+    parameters. If they do not exist, and the `createdb' parameter is set,

+    they will be created. Table field definitions are determined in the

+    following order:

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.t
index 4e73b783563..9edb47864ce 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.t
@@ -1,36 +1,36 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=pod
-
-This file tries to demonstrate a simple =include directive
-for pods. It is used as follows:
-
-   =include filename
-
-where "filename" is expected to be an absolute pathname, or else
-reside be relative to the directory in which the current processed
-podfile resides, or be relative to the current directory.
-
-Lets try it out with the file "included.t" shall we.
-
-***THIS TEXT IS IMMEDIATELY BEFORE THE INCLUDE***
-
-=include included.t
-
-***THIS TEXT IS IMMEDIATELY AFTER THE INCLUDE***
-
-So how did we do???
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=pod

+

+This file tries to demonstrate a simple =include directive

+for pods. It is used as follows:

+

+   =include filename

+

+where "filename" is expected to be an absolute pathname, or else

+reside be relative to the directory in which the current processed

+podfile resides, or be relative to the current directory.

+

+Lets try it out with the file "included.t" shall we.

+

+***THIS TEXT IS IMMEDIATELY BEFORE THE INCLUDE***

+

+=include included.t

+

+***THIS TEXT IS IMMEDIATELY AFTER THE INCLUDE***

+

+So how did we do???

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.xr
index 624ee444474..187653b741a 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/include.xr
@@ -1,22 +1,22 @@
-    This file tries to demonstrate a simple =include directive for pods. It
-    is used as follows:
-
-       =include filename
-
-    where "filename" is expected to be an absolute pathname, or else reside
-    be relative to the directory in which the current processed podfile
-    resides, or be relative to the current directory.
-
-    Lets try it out with the file "included.t" shall we.
-
-    ***THIS TEXT IS IMMEDIATELY BEFORE THE INCLUDE***
-
-###### begin =include included.t #####
-    This is the text of the included file named "included.t". It should
-    appear in the final pod document from pod2xxx
-
-###### end =include included.t #####
-    ***THIS TEXT IS IMMEDIATELY AFTER THE INCLUDE***
-
-    So how did we do???
-
+    This file tries to demonstrate a simple =include directive for pods. It

+    is used as follows:

+

+       =include filename

+

+    where "filename" is expected to be an absolute pathname, or else reside

+    be relative to the directory in which the current processed podfile

+    resides, or be relative to the current directory.

+

+    Lets try it out with the file "included.t" shall we.

+

+    ***THIS TEXT IS IMMEDIATELY BEFORE THE INCLUDE***

+

+###### begin =include included.t #####

+    This is the text of the included file named "included.t". It should

+    appear in the final pod document from pod2xxx

+

+###### end =include included.t #####

+    ***THIS TEXT IS IMMEDIATELY AFTER THE INCLUDE***

+

+    So how did we do???

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.t
index 4f171c454bf..d6e4a504311 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.t
@@ -1,35 +1,35 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-##------------------------------------------------------------
-# This file is =included by "include.t"
-#
-# This text should NOT be in the resultant pod document
-# because we havent seen an =xxx pod directive in this file!
-##------------------------------------------------------------
-
-=pod
-
-This is the text of the included file named "included.t".
-It should appear in the final pod document from pod2xxx
-
-=cut
-
-##------------------------------------------------------------
-# This text should NOT be in the resultant pod document
-# because it is *after* an =cut an no other pod directives
-# proceed it!
-##------------------------------------------------------------
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+##------------------------------------------------------------

+# This file is =included by "include.t"

+#

+# This text should NOT be in the resultant pod document

+# because we havent seen an =xxx pod directive in this file!

+##------------------------------------------------------------

+

+=pod

+

+This is the text of the included file named "included.t".

+It should appear in the final pod document from pod2xxx

+

+=cut

+

+##------------------------------------------------------------

+# This text should NOT be in the resultant pod document

+# because it is *after* an =cut an no other pod directives

+# proceed it!

+##------------------------------------------------------------

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.xr
index 54142fa0d32..16a65cd3586 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/included.xr
@@ -1,3 +1,3 @@
-    This is the text of the included file named "included.t". It should
-    appear in the final pod document from pod2xxx
-
+    This is the text of the included file named "included.t". It should

+    appear in the final pod document from pod2xxx

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.t
index 02e2c9e3071..33a0a7ca9f3 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.t
@@ -1,66 +1,66 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=pod
-
-Try out I<LOTS> of different ways of specifying references:
-
-Reference the L<manpage/section>
-
-Reference the L<manpage / section>
-
-Reference the L<manpage/ section>
-
-Reference the L<manpage /section>
-
-Reference the L<"manpage/section">
-
-Reference the L<"manpage"/section>
-
-Reference the L<manpage/"section">
-
-Reference the L<manpage/
-section>
-
-Reference the L<manpage
-/section>
-
-Now try it using the new "|" stuff ...
-
-Reference the L<thistext|manpage/section>
-
-Reference the L<thistext | manpage / section>
-
-Reference the L<thistext| manpage/ section>
-
-Reference the L<thistext |manpage /section>
-
-Reference the L<thistext|
-"manpage/section">
-
-Reference the L<thistext
-|"manpage"/section>
-
-Reference the L<thistext|manpage/"section">
-
-Reference the L<thistext|
-manpage/
-section>
-
-Reference the L<thistext
-|manpage
-/section>
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=pod

+

+Try out I<LOTS> of different ways of specifying references:

+

+Reference the L<manpage/section>

+

+Reference the L<manpage / section>

+

+Reference the L<manpage/ section>

+

+Reference the L<manpage /section>

+

+Reference the L<"manpage/section">

+

+Reference the L<"manpage"/section>

+

+Reference the L<manpage/"section">

+

+Reference the L<manpage/

+section>

+

+Reference the L<manpage

+/section>

+

+Now try it using the new "|" stuff ...

+

+Reference the L<thistext|manpage/section>

+

+Reference the L<thistext | manpage / section>

+

+Reference the L<thistext| manpage/ section>

+

+Reference the L<thistext |manpage /section>

+

+Reference the L<thistext|

+"manpage/section">

+

+Reference the L<thistext

+|"manpage"/section>

+

+Reference the L<thistext|manpage/"section">

+

+Reference the L<thistext|

+manpage/

+section>

+

+Reference the L<thistext

+|manpage

+/section>

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.xr
index 297053b1ace..c287cf5a6d9 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/lref.xr
@@ -1,40 +1,40 @@
-    Try out *LOTS* of different ways of specifying references:
-
-    Reference the the section entry in the manpage manpage
-
-    Reference the the section entry in the manpage manpage
-
-    Reference the the section entry in the manpage manpage
-
-    Reference the the section entry in the manpage manpage
-
-    Reference the the section on "manpage/section"
-
-    Reference the the section entry in the "manpage" manpage
-
-    Reference the the section on "section" in the manpage manpage
-
-    Reference the the section entry in the manpage manpage
-
-    Reference the the section entry in the manpage manpage
-
-    Now try it using the new "|" stuff ...
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
-    Reference the thistext
-
+    Try out *LOTS* of different ways of specifying references:

+

+    Reference the the section entry in the manpage manpage

+

+    Reference the the section entry in the manpage manpage

+

+    Reference the the section entry in the manpage manpage

+

+    Reference the the section entry in the manpage manpage

+

+    Reference the the section on "manpage/section"

+

+    Reference the the section entry in the "manpage" manpage

+

+    Reference the the section on "section" in the manpage manpage

+

+    Reference the the section entry in the manpage manpage

+

+    Reference the the section entry in the manpage manpage

+

+    Now try it using the new "|" stuff ...

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

+    Reference the thistext

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.t
index 0fe410a4e6d..98ad34222eb 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.t
@@ -1,31 +1,31 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=head1 Test multiline item lists
-
-This is a test to ensure that multiline =item paragraphs
-get indented appropriately.
-
-=over 4 
-
-=item This 
-is
-a
-test.
-
-=back
-
-=cut
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=head1 Test multiline item lists

+

+This is a test to ensure that multiline =item paragraphs

+get indented appropriately.

+

+=over 4 

+

+=item This 

+is

+a

+test.

+

+=back

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.xr
index 9eea63a8f09..cda163b7f5b 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/multiline_items.xr
@@ -1,6 +1,6 @@
-Test multiline item lists
-    This is a test to ensure that multiline =item paragraphs get indented
-    appropriately.
-
-    This is a test.
-
+Test multiline item lists

+    This is a test to ensure that multiline =item paragraphs get indented

+    appropriately.

+

+    This is a test.

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.t
index c8e9b224272..f60a67f1abb 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.t
@@ -1,64 +1,64 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=head1 Test nested item lists
-
-This is a test to ensure the nested =item paragraphs
-get indented appropriately.
-
-=over 2
-
-=item 1
-
-First section.
-
-=over 2
-
-=item a
-
-this is item a
-
-=item b
-
-this is item b
-
-=back
-
-=item 2
-
-Second section.
-
-=over 2
-
-=item a
-
-this is item a
-
-=item b
-
-this is item b
-
-=item c
-
-=item d
-
-This is item c & d.
-
-=back
-
-=back
-
-=cut
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=head1 Test nested item lists

+

+This is a test to ensure the nested =item paragraphs

+get indented appropriately.

+

+=over 2

+

+=item 1

+

+First section.

+

+=over 2

+

+=item a

+

+this is item a

+

+=item b

+

+this is item b

+

+=back

+

+=item 2

+

+Second section.

+

+=over 2

+

+=item a

+

+this is item a

+

+=item b

+

+this is item b

+

+=item c

+

+=item d

+

+This is item c & d.

+

+=back

+

+=back

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.xr
index dd1adac1272..30834e9ca62 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_items.xr
@@ -1,19 +1,19 @@
-Test nested item lists
-    This is a test to ensure the nested =item paragraphs get indented
-    appropriately.
-
-    1 First section.
-
-      a this is item a
-
-      b this is item b
-
-    2 Second section.
-
-      a this is item a
-
-      b this is item b
-
-      c
-      d This is item c & d.
-
+Test nested item lists

+    This is a test to ensure the nested =item paragraphs get indented

+    appropriately.

+

+    1 First section.

+

+      a this is item a

+

+      b this is item b

+

+    2 Second section.

+

+      a this is item a

+

+      b this is item b

+

+      c

+      d This is item c & d.

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.t
index 8559f1f25f6..6f7ae67e997 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.t
@@ -1,23 +1,23 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=pod
-
-The statement: C<This is dog kind's I<finest> hour!> is a parody of a
-quotation from Winston Churchill.
-
-=cut
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=pod

+

+The statement: C<This is dog kind's I<finest> hour!> is a parody of a

+quotation from Winston Churchill.

+

+=cut

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.xr
index f981061f949..4d2e09e499c 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/nested_seqs.xr
@@ -1,3 +1,3 @@
-    The statement: `This is dog kind's *finest* hour!' is a parody of a
-    quotation from Winston Churchill.
-
+    The statement: `This is dog kind's *finest* hour!' is a parody of a

+    quotation from Winston Churchill.

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.t
index 28bd1d09e5f..65df35271be 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.t
@@ -1,46 +1,46 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-==head1 NAME
-B<rdb2pg> - insert an rdb table into a PostgreSQL database
-
-==head1 SYNOPSIS
-B<rdb2pg>  [I<param>=I<value> ...]
-
-==head1 PARAMETERS
-B<rdb2pg> uses an IRAF-compatible parameter interface.  
-A template parameter file is in F</proj/axaf/simul/lib/uparm/rdb2pg.par>.
-
-==over 4
-==item B<input> I<file>
-The B<RDB> file to insert into the database. If the given name
-is the string C<stdin>, it reads from the UNIX standard input stream.
-
-==back
-
-==head1 DESCRIPTION
-B<rdb2pg> will enter the data from an B<RDB> database into a
-PostgreSQL database table, optionally creating the database and the
-table if they do not exist.  It automatically determines the
-PostgreSQL data type from the column definition in the B<RDB> file,
-but may be overriden via a series of definition files or directly
-via one of its parameters.
-
-The target database and table are specified by the C<db> and C<table>
-parameters.  If they do not exist, and the C<createdb> parameter is
-set, they will be created.  Table field definitions are determined
-in the following order:
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+==head1 NAME

+B<rdb2pg> - insert an rdb table into a PostgreSQL database

+

+==head1 SYNOPSIS

+B<rdb2pg>  [I<param>=I<value> ...]

+

+==head1 PARAMETERS

+B<rdb2pg> uses an IRAF-compatible parameter interface.  

+A template parameter file is in F</proj/axaf/simul/lib/uparm/rdb2pg.par>.

+

+==over 4

+==item B<input> I<file>

+The B<RDB> file to insert into the database. If the given name

+is the string C<stdin>, it reads from the UNIX standard input stream.

+

+==back

+

+==head1 DESCRIPTION

+B<rdb2pg> will enter the data from an B<RDB> database into a

+PostgreSQL database table, optionally creating the database and the

+table if they do not exist.  It automatically determines the

+PostgreSQL data type from the column definition in the B<RDB> file,

+but may be overriden via a series of definition files or directly

+via one of its parameters.

+

+The target database and table are specified by the C<db> and C<table>

+parameters.  If they do not exist, and the C<createdb> parameter is

+set, they will be created.  Table field definitions are determined

+in the following order:

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.xr
index fb37a2b0cf6..f92efb5ecf5 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/oneline_cmds.xr
@@ -1,26 +1,26 @@
-NAME
-    rdb2pg - insert an rdb table into a PostgreSQL database
-
-SYNOPSIS
-    rdb2pg [*param*=*value* ...]
-
-PARAMETERS
-    rdb2pg uses an IRAF-compatible parameter interface. A template parameter
-    file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.
-
-    input *file*
-        The RDB file to insert into the database. If the given name is the
-        string `stdin', it reads from the UNIX standard input stream.
-
-DESCRIPTION
-    rdb2pg will enter the data from an RDB database into a PostgreSQL
-    database table, optionally creating the database and the table if they
-    do not exist. It automatically determines the PostgreSQL data type from
-    the column definition in the RDB file, but may be overriden via a series
-    of definition files or directly via one of its parameters.
-
-    The target database and table are specified by the `db' and `table'
-    parameters. If they do not exist, and the `createdb' parameter is set,
-    they will be created. Table field definitions are determined in the
-    following order:
-
+NAME

+    rdb2pg - insert an rdb table into a PostgreSQL database

+

+SYNOPSIS

+    rdb2pg [*param*=*value* ...]

+

+PARAMETERS

+    rdb2pg uses an IRAF-compatible parameter interface. A template parameter

+    file is in /proj/axaf/simul/lib/uparm/rdb2pg.par.

+

+    input *file*

+        The RDB file to insert into the database. If the given name is the

+        string `stdin', it reads from the UNIX standard input stream.

+

+DESCRIPTION

+    rdb2pg will enter the data from an RDB database into a PostgreSQL

+    database table, optionally creating the database and the table if they

+    do not exist. It automatically determines the PostgreSQL data type from

+    the column definition in the RDB file, but may be overriden via a series

+    of definition files or directly via one of its parameters.

+

+    The target database and table are specified by the `db' and `table'

+    parameters. If they do not exist, and the `createdb' parameter is set,

+    they will be created. Table field definitions are determined in the

+    following order:

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.t
index 0004548cb7a..2d8e6b4f585 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.t
@@ -1,18 +1,18 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-=include podselect.PL
-
-
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+=include podselect.PL

+

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.xr
index c288e91280c..00b977491cd 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/podselect.xr
@@ -1,44 +1,44 @@
-###### begin =include podselect.PL #####
-NAME
-    podselect - print selected sections of pod documentation on standard
-    output
-
-SYNOPSIS
-    podselect [-help] [-man] [-section *section-spec*] [*file* ...]
-
-OPTIONS AND ARGUMENTS
-    -help   Print a brief help message and exit.
-
-    -man    Print the manual page and exit.
-
-    -section *section-spec*
-            Specify a section to include in the output. See the section on
-            "SECTION SPECIFICATIONS" in the Pod::Parser manpage for the
-            format to use for *section-spec*. This option may be given
-            multiple times on the command line.
-
-    *file*  The pathname of a file from which to select sections of pod
-            documentation (defaults to standard input).
-
-DESCRIPTION
-    podselect will read the given input files looking for pod documentation
-    and will print out (in raw pod format) all sections that match one ore
-    more of the given section specifications. If no section specifications
-    are given than all pod sections encountered are output.
-
-    podselect invokes the podselect() function exported by Pod::Select
-    Please see the podselect() entry in the Pod::Select manpage for more
-    details.
-
-SEE ALSO
-    the Pod::Parser manpage and the Pod::Select manpage
-
-AUTHOR
-    Please report bugs using http://rt.cpan.org.
-
-    Brad Appleton <bradapp@enteract.com>
-
-    Based on code for Pod::Text::pod2text(1) written by Tom Christiansen
-    <tchrist@mox.perl.com>
-
-###### end =include podselect.PL #####
+###### begin =include podselect.PL #####

+NAME

+    podselect - print selected sections of pod documentation on standard

+    output

+

+SYNOPSIS

+    podselect [-help] [-man] [-section *section-spec*] [*file* ...]

+

+OPTIONS AND ARGUMENTS

+    -help   Print a brief help message and exit.

+

+    -man    Print the manual page and exit.

+

+    -section *section-spec*

+            Specify a section to include in the output. See the section on

+            "SECTION SPECIFICATIONS" in the Pod::Parser manpage for the

+            format to use for *section-spec*. This option may be given

+            multiple times on the command line.

+

+    *file*  The pathname of a file from which to select sections of pod

+            documentation (defaults to standard input).

+

+DESCRIPTION

+    podselect will read the given input files looking for pod documentation

+    and will print out (in raw pod format) all sections that match one ore

+    more of the given section specifications. If no section specifications

+    are given than all pod sections encountered are output.

+

+    podselect invokes the podselect() function exported by Pod::Select

+    Please see the podselect() entry in the Pod::Select manpage for more

+    details.

+

+SEE ALSO

+    the Pod::Parser manpage and the Pod::Select manpage

+

+AUTHOR

+    Please report bugs using http://rt.cpan.org.

+

+    Brad Appleton <bradapp@enteract.com>

+

+    Based on code for Pod::Text::pod2text(1) written by Tom Christiansen

+    <tchrist@mox.perl.com>

+

+###### end =include podselect.PL #####

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/selfcheck.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/selfcheck.t
index d170570c6cb..17df68e301a 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/selfcheck.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/selfcheck.t
@@ -1,45 +1,53 @@
-#!/usr/bin/perl
-use File::Basename;
-use File::Spec;
-use strict;
-my $THISDIR;
-BEGIN {
-   $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testpchk.pl";
-   import TestPodChecker qw(testpodcheck);
-}
-
-# test that our POD is correct!
-my $path = File::Spec->catfile($THISDIR,(File::Spec->updir()) x 2, 'lib', 'Pod', '*.pm');
-print "THISDIR=$THISDIR PATH=$path\n";
-my @pods = glob($path);
-print "PODS=@pods\n";
-
-print "1..",scalar(@pods),"\n";
-
-my $errs = 0;
-my $testnum = 1;
-foreach my $pod (@pods) {
-  my $out = File::Spec->catfile($THISDIR, basename($pod));
-  $out =~ s{\.pm}{.OUT};
-  my %options = ( -Out => $out );
-  my $failmsg = testpodcheck(-In => $pod, -Out => $out, -Cmp => "$THISDIR/empty.xr");
-  if($failmsg) {
-    if(open(IN, "<$out")) {
-      while(<IN>) {
-        warn "podchecker: $_";
-      }
-      close(IN);
-    } else {
-      warn "Error: Cannot read output file $out: $!\n";
-    }
-    print "not ok $testnum\n";
-    $errs++;
-  } else {
-    print "ok $testnum\n";
-  }
-  $testnum++;
-}
-exit( ($errs == 0) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
+#!/usr/bin/perl

+use Test::More;

+use File::Basename;

+use File::Spec;

+use strict;

+my $THISDIR;

+BEGIN {

+   $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   eval {

+     require "testpchk.pl";

+     import TestPodChecker qw(testpodcheck);

+   };

+   warn $@ if $@;

+};

+

+my @pods;

+unless($Pod::Checker::VERSION && $Pod::Checker::VERSION > 1.40) {

+  plan skip_all => "we do not have a good Pod::Checker around";

+} else {

+  my $path = File::Spec->catfile($THISDIR,(File::Spec->updir()) x 2, 'lib', 'Pod', '*.pm');

+  print "THISDIR=$THISDIR PATH=$path\n";

+  @pods = glob($path);

+  print "PODS=@pods\n";

+  plan tests => scalar(@pods);

+}

+

+# test that our POD is correct!

+my $errs = 0;

+

+foreach my $pod (@pods) {

+  my $out = File::Spec->catfile($THISDIR, basename($pod));

+  $out =~ s{\.pm}{.OUT};

+  my %options = ( -Out => $out );

+  my $failmsg = testpodcheck(-In => $pod, -Out => $out, -Cmp => "$THISDIR/empty.xr");

+  if($failmsg) {

+    if(open(IN, "<$out")) {

+      while(<IN>) {

+        warn "podchecker: $_";

+      }

+      close(IN);

+    } else {

+      warn "Error: Cannot read output file $out: $!\n";

+    }

+    ok(0, $pod);

+    $errs++;

+  } else {

+    ok(1, $pod);

+  }

+}

+

+exit( ($errs == 0) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.t
index ecd99ecde81..f1399ccf771 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.t
@@ -1,46 +1,46 @@
-BEGIN {
-   use File::Basename;
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testp2pt.pl";
-   import TestPodIncPlainText;
-}
-
-my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash
-my $passed  = testpodplaintext \%options, $0;
-exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};
-
-
-__END__
-
-
-=pod
-
-This is a test to see if I can do not only C<$self> and C<method()>, but
-also C<< $self->method() >> and C<< $self->{FIELDNAME} >> and
-C<< $Foo <=> $Bar >> without resorting to escape sequences. If 
-I want to refer to the right-shift operator I can do something
-like C<<< $x >> 3 >>> or even C<<<< $y >> 5 >>>>.
-
-Now for the grand finale of C<< $self->method()->{FIELDNAME} = {FOO=>BAR} >>.
-And I also want to make sure that newlines work like this
-C<<<
-$self->{FOOBAR} >> 3 and [$b => $a]->[$a <=> $b]
->>>
-
-Of course I should still be able to do all this I<with> escape sequences
-too: C<$self-E<gt>method()> and C<$self-E<gt>{FIELDNAME}> and C<{FOO=E<gt>BAR}>.
-
-Dont forget C<$self-E<gt>method()-E<gt>{FIELDNAME} = {FOO=E<gt>BAR}>.
-
-And make sure that C<0> works too!
-
-Now, if I use << or >> as my delimiters, then I have to use whitespace.
-So things like C<<$self->method()>> and C<<$self->{FIELDNAME}>> wont end
-up doing what you might expect since the first > will still terminate
-the first < seen.
-
-Lets make sure these work for empty ones too, like C<<  >> and C<< >> >>
-(just to be obnoxious)
-
-=cut
+BEGIN {

+   use File::Basename;

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testp2pt.pl";

+   import TestPodIncPlainText;

+}

+

+my %options = map { $_ => 1 } @ARGV;  ## convert cmdline to options-hash

+my $passed  = testpodplaintext \%options, $0;

+exit( ($passed == 1) ? 0 : -1 )  unless $ENV{HARNESS_ACTIVE};

+

+

+__END__

+

+

+=pod

+

+This is a test to see if I can do not only C<$self> and C<method()>, but

+also C<< $self->method() >> and C<< $self->{FIELDNAME} >> and

+C<< $Foo <=> $Bar >> without resorting to escape sequences. If 

+I want to refer to the right-shift operator I can do something

+like C<<< $x >> 3 >>> or even C<<<< $y >> 5 >>>>.

+

+Now for the grand finale of C<< $self->method()->{FIELDNAME} = {FOO=>BAR} >>.

+And I also want to make sure that newlines work like this

+C<<<

+$self->{FOOBAR} >> 3 and [$b => $a]->[$a <=> $b]

+>>>

+

+Of course I should still be able to do all this I<with> escape sequences

+too: C<$self-E<gt>method()> and C<$self-E<gt>{FIELDNAME}> and C<{FOO=E<gt>BAR}>.

+

+Dont forget C<$self-E<gt>method()-E<gt>{FIELDNAME} = {FOO=E<gt>BAR}>.

+

+And make sure that C<0> works too!

+

+Now, if I use << or >> as my delimiters, then I have to use whitespace.

+So things like C<<$self->method()>> and C<<$self->{FIELDNAME}>> wont end

+up doing what you might expect since the first > will still terminate

+the first < seen.

+

+Lets make sure these work for empty ones too, like C<<  >> and C<< >> >>

+(just to be obnoxious)

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.xr b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.xr
index a8c715ae0ac..4d6c55e5a18 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.xr
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/special_seqs.xr
@@ -1,25 +1,25 @@
-    This is a test to see if I can do not only `$self' and `method()', but
-    also `$self->method()' and `$self->{FIELDNAME}' and `$Foo <=> $Bar'
-    without resorting to escape sequences. If I want to refer to the
-    right-shift operator I can do something like `$x >> 3' or even `$y >>
-    5'.
-
-    Now for the grand finale of `$self->method()->{FIELDNAME} = {FOO=>BAR}'.
-    And I also want to make sure that newlines work like this
-    `$self->{FOOBAR} >> 3 and [$b => $a]->[$a <=> $b]'
-
-    Of course I should still be able to do all this *with* escape sequences
-    too: `$self->method()' and `$self->{FIELDNAME}' and `{FOO=>BAR}'.
-
-    Dont forget `$self->method()->{FIELDNAME} = {FOO=>BAR}'.
-
-    And make sure that `0' works too!
-
-    Now, if I use << or >> as my delimiters, then I have to use whitespace.
-    So things like `<$self-'method()>> and `<$self-'{FIELDNAME}>> wont end
-    up doing what you might expect since the first > will still terminate
-    the first < seen.
-
-    Lets make sure these work for empty ones too, like and `>>' (just to be
-    obnoxious)
-
+    This is a test to see if I can do not only `$self' and `method()', but

+    also `$self->method()' and `$self->{FIELDNAME}' and `$Foo <=> $Bar'

+    without resorting to escape sequences. If I want to refer to the

+    right-shift operator I can do something like `$x >> 3' or even `$y >>

+    5'.

+

+    Now for the grand finale of `$self->method()->{FIELDNAME} = {FOO=>BAR}'.

+    And I also want to make sure that newlines work like this

+    `$self->{FOOBAR} >> 3 and [$b => $a]->[$a <=> $b]'

+

+    Of course I should still be able to do all this *with* escape sequences

+    too: `$self->method()' and `$self->{FIELDNAME}' and `{FOO=>BAR}'.

+

+    Dont forget `$self->method()->{FIELDNAME} = {FOO=>BAR}'.

+

+    And make sure that `0' works too!

+

+    Now, if I use << or >> as my delimiters, then I have to use whitespace.

+    So things like `<$self-'method()>> and `<$self-'{FIELDNAME}>> wont end

+    up doing what you might expect since the first > will still terminate

+    the first < seen.

+

+    Lets make sure these work for empty ones too, like and `>>' (just to be

+    obnoxious)

+

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testcmp.pl b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testcmp.pl
index 17f0b0b4c2c..b8592fcc2a8 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testcmp.pl
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testcmp.pl
@@ -1,94 +1,94 @@
-package TestCompare;
-
-use vars qw(@ISA @EXPORT $MYPKG);
-#use strict;
-#use diagnostics;
-use Carp;
-use Exporter;
-use File::Basename;
-use File::Spec;
-use FileHandle;
-
-@ISA = qw(Exporter);
-@EXPORT = qw(&testcmp);
-$MYPKG = eval { (caller)[0] };
-
-##--------------------------------------------------------------------------
-
-=head1 NAME
-
-testcmp -- compare two files line-by-line
-
-=head1 SYNOPSIS
-
-    $is_diff = testcmp($file1, $file2);
-
-or
-
-    $is_diff = testcmp({-cmplines => \&mycmp}, $file1, $file2);
-
-=head2 DESCRIPTION
-
-Compare two text files line-by-line and return 0 if they are the
-same, 1 if they differ. Each of $file1 and $file2 may be a filenames,
-or a filehandles (in which case it must already be open for reading).
-
-If the first argument is a hashref, then the B<-cmplines> key in the
-hash may have a subroutine reference as its corresponding value.
-The referenced user-defined subroutine should be a line-comparator
-function that takes two pre-chomped text-lines as its arguments
-(the first is from $file1 and the second is from $file2). It should
-return 0 if it considers the two lines equivalent, and non-zero
-otherwise.
-
-=cut
-
-##--------------------------------------------------------------------------
-
-sub testcmp( $ $ ; $) {
-   my %opts = ref($_[0]) eq 'HASH' ? %{shift()} : ();
-   my ($file1, $file2) = @_;
-   my ($fh1, $fh2) = ($file1, $file2);
-   unless (ref $fh1) {
-      $fh1 = FileHandle->new($file1, "r") or die "Can't open $file1: $!";
-   }
-   unless (ref $fh2) {
-      $fh2 = FileHandle->new($file2, "r") or die "Can't open $file2: $!";
-   }
-  
-   my $cmplines = $opts{'-cmplines'} || undef;
-   my ($f1text, $f2text) = ("", "");
-   my ($line, $diffs)    = (0, 0);
-  
-   while ( defined($f1text) and defined($f2text) ) {
-      defined($f1text = <$fh1>)  and  chomp($f1text);
-      defined($f2text = <$fh2>)  and  chomp($f2text);
-      ++$line;
-      last unless ( defined($f1text) and defined($f2text) );
-      # kill any extra line endings
-      $f1text =~ s/[\r\n]+$//s;
-      $f2text =~ s/[\r\n]+$//s;
-      $diffs = (ref $cmplines) ? &$cmplines($f1text, $f2text)
-                               : ($f1text ne $f2text);
-      last if $diffs;
-   }
-   close($fh1) unless (ref $file1);
-   close($fh2) unless (ref $file2);
-  
-   $diffs = 1  if (defined($f1text) or defined($f2text));
-   if ( defined($f1text) and defined($f2text) ) {
-      ## these two lines must be different
-      warn "$file1 and $file2 differ at line $line\n";
-   }
-   elsif (defined($f1text)  and  (! defined($f1text))) {
-      ## file1 must be shorter
-      warn "$file1 is shorter than $file2\n";
-   }
-   elsif (defined $f2text) {
-      ## file2 must be longer
-      warn "$file1 is shorter than $file2\n";
-   }
-   return $diffs;
-}
-
-1;
+package TestCompare;

+

+use vars qw(@ISA @EXPORT $MYPKG);

+#use strict;

+#use diagnostics;

+use Carp;

+use Exporter;

+use File::Basename;

+use File::Spec;

+use FileHandle;

+

+@ISA = qw(Exporter);

+@EXPORT = qw(&testcmp);

+$MYPKG = eval { (caller)[0] };

+

+##--------------------------------------------------------------------------

+

+=head1 NAME

+

+testcmp -- compare two files line-by-line

+

+=head1 SYNOPSIS

+

+    $is_diff = testcmp($file1, $file2);

+

+or

+

+    $is_diff = testcmp({-cmplines => \&mycmp}, $file1, $file2);

+

+=head2 DESCRIPTION

+

+Compare two text files line-by-line and return 0 if they are the

+same, 1 if they differ. Each of $file1 and $file2 may be a filenames,

+or a filehandles (in which case it must already be open for reading).

+

+If the first argument is a hashref, then the B<-cmplines> key in the

+hash may have a subroutine reference as its corresponding value.

+The referenced user-defined subroutine should be a line-comparator

+function that takes two pre-chomped text-lines as its arguments

+(the first is from $file1 and the second is from $file2). It should

+return 0 if it considers the two lines equivalent, and non-zero

+otherwise.

+

+=cut

+

+##--------------------------------------------------------------------------

+

+sub testcmp( $ $ ; $) {

+   my %opts = ref($_[0]) eq 'HASH' ? %{shift()} : ();

+   my ($file1, $file2) = @_;

+   my ($fh1, $fh2) = ($file1, $file2);

+   unless (ref $fh1) {

+      $fh1 = FileHandle->new($file1, "r") or die "Can't open $file1: $!";

+   }

+   unless (ref $fh2) {

+      $fh2 = FileHandle->new($file2, "r") or die "Can't open $file2: $!";

+   }

+  

+   my $cmplines = $opts{'-cmplines'} || undef;

+   my ($f1text, $f2text) = ("", "");

+   my ($line, $diffs)    = (0, 0);

+  

+   while ( defined($f1text) and defined($f2text) ) {

+      defined($f1text = <$fh1>)  and  chomp($f1text);

+      defined($f2text = <$fh2>)  and  chomp($f2text);

+      ++$line;

+      last unless ( defined($f1text) and defined($f2text) );

+      # kill any extra line endings

+      $f1text =~ s/[\r\n]+$//s;

+      $f2text =~ s/[\r\n]+$//s;

+      $diffs = (ref $cmplines) ? &$cmplines($f1text, $f2text)

+                               : ($f1text ne $f2text);

+      last if $diffs;

+   }

+   close($fh1) unless (ref $file1);

+   close($fh2) unless (ref $file2);

+  

+   $diffs = 1  if (defined($f1text) or defined($f2text));

+   if ( defined($f1text) and defined($f2text) ) {

+      ## these two lines must be different

+      warn "$file1 and $file2 differ at line $line\n";

+   }

+   elsif (defined($f1text)  and  (! defined($f1text))) {

+      ## file1 must be shorter

+      warn "$file1 is shorter than $file2\n";

+   }

+   elsif (defined $f2text) {

+      ## file2 must be longer

+      warn "$file1 is shorter than $file2\n";

+   }

+   return $diffs;

+}

+

+1;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testp2pt.pl b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testp2pt.pl
index 308cd1ccd6b..5c17300b508 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testp2pt.pl
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testp2pt.pl
@@ -1,192 +1,192 @@
-package TestPodIncPlainText;
-
-BEGIN {
-   use File::Basename;
-   use File::Spec;
-   use Cwd qw(abs_path);
-   push @INC, '..';
-   my $THISDIR = abs_path(dirname $0);
-   unshift @INC, $THISDIR;
-   require "testcmp.pl";
-   import TestCompare;
-   my $PARENTDIR = dirname $THISDIR;
-   push @INC, map { File::Spec->catfile($_, 'lib') } ($PARENTDIR, $THISDIR);
-}
-
-#use strict;
-#use diagnostics;
-use Carp;
-use Exporter;
-#use File::Compare;
-#use Cwd qw(abs_path);
-
-use vars qw($MYPKG @EXPORT @ISA);
-$MYPKG = eval { (caller)[0] };
-@EXPORT = qw(&testpodplaintext);
-BEGIN {
-    require Pod::PlainText;
-    @ISA = qw( Pod::PlainText );
-    require VMS::Filespec if $^O eq 'VMS';
-}
-
-## Hardcode settings for TERMCAP and COLUMNS so we can try to get
-## reproducible results between environments
-@ENV{qw(TERMCAP COLUMNS)} = ('co=76:do=^J', 76);
-
-sub catfile(@) { File::Spec->catfile(@_); }
-
-my $INSTDIR = abs_path(dirname $0);
-$INSTDIR = VMS::Filespec::unixpath($INSTDIR) if $^O eq 'VMS';
-$INSTDIR =~ s#/$## if $^O eq 'VMS';
-$INSTDIR =~ s#:$## if $^O eq 'MacOS';
-$INSTDIR = (dirname $INSTDIR) if (basename($INSTDIR) eq 'pod');
-$INSTDIR =~ s#:$## if $^O eq 'MacOS';
-$INSTDIR = (dirname $INSTDIR) if (basename($INSTDIR) eq 't');
-my @PODINCDIRS = ( catfile($INSTDIR, 'lib', 'Pod'),
-                   catfile($INSTDIR, 'scripts'),
-                   catfile($INSTDIR, 'pod'),
-                   catfile($INSTDIR, 't', 'pod')
-                 );
-
-# FIXME - we should make the core capable of finding utilities built in
-# locations in ext.
-push @PODINCDIRS, catfile((File::Spec->updir()) x 2, 'pod') if $ENV{PERL_CORE};
-
-## Find the path to the file to =include
-sub findinclude {
-    my $self    = shift;
-    my $incname = shift;
-
-    ## See if its already found w/out any "searching;
-    return  $incname if (-r $incname);
-
-    ## Need to search for it. Look in the following directories ...
-    ##   1. the directory containing this pod file
-    my $thispoddir = dirname $self->input_file;
-    ##   2. the parent directory of the above
-    my $parentdir  = dirname $thispoddir;
-    my @podincdirs = ($thispoddir, $parentdir, @PODINCDIRS);
-
-    for (@podincdirs) {
-       my $incfile = catfile($_, $incname);
-       return $incfile  if (-r $incfile);
-    }
-    warn("*** Can't find =include file $incname in @podincdirs\n");
-    return "";
-}
-
-sub command {
-    my $self = shift;
-    my ($cmd, $text, $line_num, $pod_para)  = @_;
-    $cmd     = ''  unless (defined $cmd);
-    local $_ = $text || '';
-    my $out_fh  = $self->output_handle;
-
-    ## Defer to the superclass for everything except '=include'
-    return  $self->SUPER::command(@_) unless ($cmd eq "include");
-
-    ## We have an '=include' command
-    my $incdebug = 1; ## debugging
-    my @incargs = split;
-    if (@incargs == 0) {
-        warn("*** No filename given for '=include'\n");
-        return;
-    }
-    my $incfile  = $self->findinclude(shift @incargs)  or  return;
-    my $incbase  = basename $incfile;
-    print $out_fh "###### begin =include $incbase #####\n"  if ($incdebug);
-    $self->parse_from_file( {-cutting => 1}, $incfile );
-    print $out_fh "###### end =include $incbase #####\n"    if ($incdebug);
-}
-
-sub begin_input {
-   $_[0]->{_INFILE} = VMS::Filespec::unixify($_[0]->{_INFILE}) if $^O eq 'VMS';
-}
-
-sub podinc2plaintext( $ $ ) {
-    my ($infile, $outfile) = @_;
-    local $_;
-    my $text_parser = $MYPKG->new;
-    $text_parser->parse_from_file($infile, $outfile);
-}
-
-sub testpodinc2plaintext( @ ) {
-   my %args = @_;
-   my $infile  = $args{'-In'}  || croak "No input file given!";
-   my $outfile = $args{'-Out'} || croak "No output file given!";
-   my $cmpfile = $args{'-Cmp'} || croak "No compare-result file given!";
-
-   my $different = '';
-   my $testname = basename $cmpfile, '.t', '.xr';
-
-   unless (-e $cmpfile) {
-      my $msg = "*** Can't find comparison file $cmpfile for testing $infile";
-      warn  "$msg\n";
-      return  $msg;
-   }
-
-   print "# Running testpodinc2plaintext for '$testname'...\n";
-   ## Compare the output against the expected result
-   podinc2plaintext($infile, $outfile);
-   if ( testcmp($outfile, $cmpfile) ) {
-       $different = "$outfile is different from $cmpfile";
-   }
-   else {
-       unlink($outfile);
-   }
-   return  $different;
-}
-
-sub testpodplaintext( @ ) {
-   my %opts = (ref $_[0] eq 'HASH') ? %{shift()} : ();
-   my @testpods = @_;
-   my ($testname, $testdir) = ("", "");
-   my ($podfile, $cmpfile) = ("", "");
-   my ($outfile, $errfile) = ("", "");
-   my $passes = 0;
-   my $failed = 0;
-   local $_;
-
-   print "1..", scalar @testpods, "\n"  unless ($opts{'-xrgen'});
-
-   for $podfile (@testpods) {
-      ($testname, $_) = fileparse($podfile);
-      $testdir ||=  $_;
-      $testname  =~ s/\.t$//;
-      $cmpfile   =  $testdir . $testname . '.xr';
-      $outfile   =  $testdir . $testname . '.OUT';
-
-      if ($opts{'-xrgen'}) {
-          if ($opts{'-force'} or ! -e $cmpfile) {
-             ## Create the comparison file
-             print "# Creating expected result for \"$testname\"" .
-                   " pod2plaintext test ...\n";
-             podinc2plaintext($podfile, $cmpfile);
-          }
-          else {
-             print "# File $cmpfile already exists" .
-                   " (use '-force' to regenerate it).\n";
-          }
-          next;
-      }
-
-      my $failmsg = testpodinc2plaintext
-                        -In  => $podfile,
-                        -Out => $outfile,
-                        -Cmp => $cmpfile;
-      if ($failmsg) {
-          ++$failed;
-          print "#\tFAILED. ($failmsg)\n";
-	  print "not ok ", $failed+$passes, "\n";
-      }
-      else {
-          ++$passes;
-          unlink($outfile);
-          print "#\tPASSED.\n";
-	  print "ok ", $failed+$passes, "\n";
-      }
-   }
-   return  $passes;
-}
-
-1;
+package TestPodIncPlainText;

+

+BEGIN {

+   use File::Basename;

+   use File::Spec;

+   use Cwd qw(abs_path);

+   push @INC, '..';

+   my $THISDIR = abs_path(dirname $0);

+   unshift @INC, $THISDIR;

+   require "testcmp.pl";

+   import TestCompare;

+   my $PARENTDIR = dirname $THISDIR;

+   push @INC, map { File::Spec->catfile($_, 'lib') } ($PARENTDIR, $THISDIR);

+}

+

+#use strict;

+#use diagnostics;

+use Carp;

+use Exporter;

+#use File::Compare;

+#use Cwd qw(abs_path);

+

+use vars qw($MYPKG @EXPORT @ISA);

+$MYPKG = eval { (caller)[0] };

+@EXPORT = qw(&testpodplaintext);

+BEGIN {

+    require Pod::PlainText;

+    @ISA = qw( Pod::PlainText );

+    require VMS::Filespec if $^O eq 'VMS';

+}

+

+## Hardcode settings for TERMCAP and COLUMNS so we can try to get

+## reproducible results between environments

+@ENV{qw(TERMCAP COLUMNS)} = ('co=76:do=^J', 76);

+

+sub catfile(@) { File::Spec->catfile(@_); }

+

+my $INSTDIR = abs_path(dirname $0);

+$INSTDIR = VMS::Filespec::unixpath($INSTDIR) if $^O eq 'VMS';

+$INSTDIR =~ s#/$## if $^O eq 'VMS';

+$INSTDIR =~ s#:$## if $^O eq 'MacOS';

+$INSTDIR = (dirname $INSTDIR) if (basename($INSTDIR) eq 'pod');

+$INSTDIR =~ s#:$## if $^O eq 'MacOS';

+$INSTDIR = (dirname $INSTDIR) if (basename($INSTDIR) eq 't');

+my @PODINCDIRS = ( catfile($INSTDIR, 'lib', 'Pod'),

+                   catfile($INSTDIR, 'scripts'),

+                   catfile($INSTDIR, 'pod'),

+                   catfile($INSTDIR, 't', 'pod')

+                 );

+

+# FIXME - we should make the core capable of finding utilities built in

+# locations in ext.

+push @PODINCDIRS, catfile((File::Spec->updir()) x 2, 'pod') if $ENV{PERL_CORE};

+

+## Find the path to the file to =include

+sub findinclude {

+    my $self    = shift;

+    my $incname = shift;

+

+    ## See if its already found w/out any "searching;

+    return  $incname if (-r $incname);

+

+    ## Need to search for it. Look in the following directories ...

+    ##   1. the directory containing this pod file

+    my $thispoddir = dirname $self->input_file;

+    ##   2. the parent directory of the above

+    my $parentdir  = dirname $thispoddir;

+    my @podincdirs = ($thispoddir, $parentdir, @PODINCDIRS);

+

+    for (@podincdirs) {

+       my $incfile = catfile($_, $incname);

+       return $incfile  if (-r $incfile);

+    }

+    warn("*** Can't find =include file $incname in @podincdirs\n");

+    return "";

+}

+

+sub command {

+    my $self = shift;

+    my ($cmd, $text, $line_num, $pod_para)  = @_;

+    $cmd     = ''  unless (defined $cmd);

+    local $_ = $text || '';

+    my $out_fh  = $self->output_handle;

+

+    ## Defer to the superclass for everything except '=include'

+    return  $self->SUPER::command(@_) unless ($cmd eq "include");

+

+    ## We have an '=include' command

+    my $incdebug = 1; ## debugging

+    my @incargs = split;

+    if (@incargs == 0) {

+        warn("*** No filename given for '=include'\n");

+        return;

+    }

+    my $incfile  = $self->findinclude(shift @incargs)  or  return;

+    my $incbase  = basename $incfile;

+    print $out_fh "###### begin =include $incbase #####\n"  if ($incdebug);

+    $self->parse_from_file( {-cutting => 1}, $incfile );

+    print $out_fh "###### end =include $incbase #####\n"    if ($incdebug);

+}

+

+sub begin_input {

+   $_[0]->{_INFILE} = VMS::Filespec::unixify($_[0]->{_INFILE}) if $^O eq 'VMS';

+}

+

+sub podinc2plaintext( $ $ ) {

+    my ($infile, $outfile) = @_;

+    local $_;

+    my $text_parser = $MYPKG->new;

+    $text_parser->parse_from_file($infile, $outfile);

+}

+

+sub testpodinc2plaintext( @ ) {

+   my %args = @_;

+   my $infile  = $args{'-In'}  || croak "No input file given!";

+   my $outfile = $args{'-Out'} || croak "No output file given!";

+   my $cmpfile = $args{'-Cmp'} || croak "No compare-result file given!";

+

+   my $different = '';

+   my $testname = basename $cmpfile, '.t', '.xr';

+

+   unless (-e $cmpfile) {

+      my $msg = "*** Can't find comparison file $cmpfile for testing $infile";

+      warn  "$msg\n";

+      return  $msg;

+   }

+

+   print "# Running testpodinc2plaintext for '$testname'...\n";

+   ## Compare the output against the expected result

+   podinc2plaintext($infile, $outfile);

+   if ( testcmp($outfile, $cmpfile) ) {

+       $different = "$outfile is different from $cmpfile";

+   }

+   else {

+       unlink($outfile);

+   }

+   return  $different;

+}

+

+sub testpodplaintext( @ ) {

+   my %opts = (ref $_[0] eq 'HASH') ? %{shift()} : ();

+   my @testpods = @_;

+   my ($testname, $testdir) = ("", "");

+   my ($podfile, $cmpfile) = ("", "");

+   my ($outfile, $errfile) = ("", "");

+   my $passes = 0;

+   my $failed = 0;

+   local $_;

+

+   print "1..", scalar @testpods, "\n"  unless ($opts{'-xrgen'});

+

+   for $podfile (@testpods) {

+      ($testname, $_) = fileparse($podfile);

+      $testdir ||=  $_;

+      $testname  =~ s/\.t$//;

+      $cmpfile   =  $testdir . $testname . '.xr';

+      $outfile   =  $testdir . $testname . '.OUT';

+

+      if ($opts{'-xrgen'}) {

+          if ($opts{'-force'} or ! -e $cmpfile) {

+             ## Create the comparison file

+             print "# Creating expected result for \"$testname\"" .

+                   " pod2plaintext test ...\n";

+             podinc2plaintext($podfile, $cmpfile);

+          }

+          else {

+             print "# File $cmpfile already exists" .

+                   " (use '-force' to regenerate it).\n";

+          }

+          next;

+      }

+

+      my $failmsg = testpodinc2plaintext

+                        -In  => $podfile,

+                        -Out => $outfile,

+                        -Cmp => $cmpfile;

+      if ($failmsg) {

+          ++$failed;

+          print "#\tFAILED. ($failmsg)\n";

+	  print "not ok ", $failed+$passes, "\n";

+      }

+      else {

+          ++$passes;

+          unlink($outfile);

+          print "#\tPASSED.\n";

+	  print "ok ", $failed+$passes, "\n";

+      }

+   }

+   return  $passes;

+}

+

+1;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpchk.pl b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpchk.pl
index aeb0be333d3..0464a9a0fcf 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpchk.pl
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpchk.pl
@@ -1,130 +1,130 @@
-package TestPodChecker;
-
-BEGIN {
-   use File::Basename;
-   use File::Spec;
-   push @INC, '..';
-   my $THISDIR = dirname $0;
-   unshift @INC, $THISDIR;
-   require "testcmp.pl";
-   import TestCompare;
-   my $PARENTDIR = dirname $THISDIR;
-   push @INC, map { File::Spec->catfile($_, 'lib') } ($PARENTDIR, $THISDIR);
-   require VMS::Filespec if $^O eq 'VMS';
-}
-
-use Pod::Checker;
-use vars qw(@ISA @EXPORT $MYPKG);
-#use strict;
-#use diagnostics;
-use Carp;
-use Exporter;
-#use File::Compare;
-
-@ISA = qw(Exporter);
-@EXPORT = qw(&testpodchecker);
-@EXPORT_OK = qw(&testpodcheck);
-$MYPKG = eval { (caller)[0] };
-
-sub stripname( $ ) {
-   local $_ = shift;
-   return /(\w[.\w]*)\s*$/ ? $1 : $_;
-}
-
-sub msgcmp( $ $ ) {
-   ## filter out platform-dependent aspects of error messages
-   my ($line1, $line2) = @_;
-   for ($line1, $line2) {
-      ## remove filenames from error messages to avoid any
-      ## filepath naming differences between OS platforms
-      s/(at line \S+ in file) .*\W(\w+\.[tT])\s*$/$1 \L$2\E/;
-      s/.*\W(\w+\.[tT]) (has \d+ pod syntax error)/\L$1\E $2/;
-   }
-   return ($line1 ne $line2);
-}
-
-sub testpodcheck( @ ) {
-   my %args = @_;
-   my $infile  = $args{'-In'}  || croak "No input file given!";
-   my $outfile = $args{'-Out'} || croak "No output file given!";
-   my $cmpfile = $args{'-Cmp'} || croak "No compare-result file given!";
-
-   my $different = '';
-   my $testname = basename $infile, '.t', '.xr';
-
-   unless (-e $cmpfile) {
-      my $msg = "*** Can't find comparison file $cmpfile for testing $infile";
-      warn  "$msg\n";
-      return  $msg;
-   }
-
-   print "# Running podchecker for '$testname'...\n";
-   ## Compare the output against the expected result
-   if ($^O eq 'VMS') {
-      for ($infile, $outfile, $cmpfile) {
-         $_ = VMS::Filespec::unixify($_)  unless  ref;
-      }
-   }
-   podchecker($infile, $outfile);
-   if ( testcmp({'-cmplines' => \&msgcmp}, $outfile, $cmpfile) ) {
-       $different = "$outfile is different from $cmpfile";
-   }
-   else {
-       unlink($outfile);
-   }
-   return  $different;
-}
-
-sub testpodchecker( @ ) {
-   my %opts = (ref $_[0] eq 'HASH') ? %{shift()} : ();
-   my @testpods = @_;
-   my ($testname, $testdir) = ("", "");
-   my ($podfile, $cmpfile) = ("", "");
-   my ($outfile, $errfile) = ("", "");
-   my $passes = 0;
-   my $failed = 0;
-   local $_;
-
-   print "1..", scalar @testpods, "\n"  unless ($opts{'-xrgen'});
-
-   for $podfile (@testpods) {
-      ($testname, $_) = fileparse($podfile);
-      $testdir ||=  $_;
-      $testname  =~ s/\.t$//;
-      $cmpfile   =  $testdir . $testname . '.xr';
-      $outfile   =  $testdir . $testname . '.OUT';
-
-      if ($opts{'-xrgen'}) {
-          if ($opts{'-force'} or ! -e $cmpfile) {
-             ## Create the comparison file
-             print "# Creating expected result for \"$testname\"" .
-                   " podchecker test ...\n";
-             podchecker($podfile, $cmpfile);
-          }
-          else {
-             print "# File $cmpfile already exists" .
-                   " (use '-force' to regenerate it).\n";
-          }
-          next;
-      }
-
-      my $failmsg = testpodcheck
-                        -In  => $podfile,
-                        -Out => $outfile,
-                        -Cmp => $cmpfile;
-      if ($failmsg) {
-          ++$failed;
-          print "#\tFAILED. ($failmsg)\n";
-	  print "not ok ", $failed+$passes, "\n";
-      }
-      else {
-          ++$passes;
-          unlink($outfile);
-          print "#\tPASSED.\n";
-	  print "ok ", $failed+$passes, "\n";
-      }
-   }
-   return  $passes;
-}
-
-1;
+package TestPodChecker;

+

+BEGIN {

+   use File::Basename;

+   use File::Spec;

+   push @INC, '..';

+   my $THISDIR = dirname $0;

+   unshift @INC, $THISDIR;

+   require "testcmp.pl";

+   import TestCompare;

+   my $PARENTDIR = dirname $THISDIR;

+   push @INC, map { File::Spec->catfile($_, 'lib') } ($PARENTDIR, $THISDIR);

+   require VMS::Filespec if $^O eq 'VMS';

+}

+

+use Pod::Checker;

+use vars qw(@ISA @EXPORT $MYPKG);

+#use strict;

+#use diagnostics;

+use Carp;

+use Exporter;

+#use File::Compare;

+

+@ISA = qw(Exporter);

+@EXPORT = qw(&testpodchecker);

+@EXPORT_OK = qw(&testpodcheck);

+$MYPKG = eval { (caller)[0] };

+

+sub stripname( $ ) {

+   local $_ = shift;

+   return /(\w[.\w]*)\s*$/ ? $1 : $_;

+}

+

+sub msgcmp( $ $ ) {

+   ## filter out platform-dependent aspects of error messages

+   my ($line1, $line2) = @_;

+   for ($line1, $line2) {

+      ## remove filenames from error messages to avoid any

+      ## filepath naming differences between OS platforms

+      s/(at line \S+ in file) .*\W(\w+\.[tT])\s*$/$1 \L$2\E/;

+      s/.*\W(\w+\.[tT]) (has \d+ pod syntax error)/\L$1\E $2/;

+   }

+   return ($line1 ne $line2);

+}

+

+sub testpodcheck( @ ) {

+   my %args = @_;

+   my $infile  = $args{'-In'}  || croak "No input file given!";

+   my $outfile = $args{'-Out'} || croak "No output file given!";

+   my $cmpfile = $args{'-Cmp'} || croak "No compare-result file given!";

+

+   my $different = '';

+   my $testname = basename $infile, '.t', '.xr';

+

+   unless (-e $cmpfile) {

+      my $msg = "*** Can't find comparison file $cmpfile for testing $infile";

+      warn  "$msg\n";

+      return  $msg;

+   }

+

+   print "# Running podchecker for '$testname'...\n";

+   ## Compare the output against the expected result

+   if ($^O eq 'VMS') {

+      for ($infile, $outfile, $cmpfile) {

+         $_ = VMS::Filespec::unixify($_)  unless  ref;

+      }

+   }

+   podchecker($infile, $outfile);

+   if ( testcmp({'-cmplines' => \&msgcmp}, $outfile, $cmpfile) ) {

+       $different = "$outfile is different from $cmpfile";

+   }

+   else {

+       unlink($outfile);

+   }

+   return  $different;

+}

+

+sub testpodchecker( @ ) {

+   my %opts = (ref $_[0] eq 'HASH') ? %{shift()} : ();

+   my @testpods = @_;

+   my ($testname, $testdir) = ("", "");

+   my ($podfile, $cmpfile) = ("", "");

+   my ($outfile, $errfile) = ("", "");

+   my $passes = 0;

+   my $failed = 0;

+   local $_;

+

+   print "1..", scalar @testpods, "\n"  unless ($opts{'-xrgen'});

+

+   for $podfile (@testpods) {

+      ($testname, $_) = fileparse($podfile);

+      $testdir ||=  $_;

+      $testname  =~ s/\.t$//;

+      $cmpfile   =  $testdir . $testname . '.xr';

+      $outfile   =  $testdir . $testname . '.OUT';

+

+      if ($opts{'-xrgen'}) {

+          if ($opts{'-force'} or ! -e $cmpfile) {

+             ## Create the comparison file

+             print "# Creating expected result for \"$testname\"" .

+                   " podchecker test ...\n";

+             podchecker($podfile, $cmpfile);

+          }

+          else {

+             print "# File $cmpfile already exists" .

+                   " (use '-force' to regenerate it).\n";

+          }

+          next;

+      }

+

+      my $failmsg = testpodcheck

+                        -In  => $podfile,

+                        -Out => $outfile,

+                        -Cmp => $cmpfile;

+      if ($failmsg) {

+          ++$failed;

+          print "#\tFAILED. ($failmsg)\n";

+	  print "not ok ", $failed+$passes, "\n";

+      }

+      else {

+          ++$passes;

+          unlink($outfile);

+          print "#\tPASSED.\n";

+	  print "ok ", $failed+$passes, "\n";

+      }

+   }

+   return  $passes;

+}

+

+1;

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpods/lib/Pod/Stuff.pm b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpods/lib/Pod/Stuff.pm
index d5c11203037..00a719c6560 100644
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpods/lib/Pod/Stuff.pm
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/testpods/lib/Pod/Stuff.pm
@@ -1,20 +1,20 @@
-=head1 NAME
-
-Pod::Stuff - dummy testing pod
-
-=head1 DESCRIPTION
-
-This isn't really anything, its just some dummy pod code.
-And stuff.
-
-Lots of stuff.
-
-=head2 STUFF
-
-For all your stuff [tm]
-
-Stuffit
-
-Mmmm, stuffed pizza bread.
-
-=cut
+=head1 NAME

+

+Pod::Stuff - dummy testing pod

+

+=head1 DESCRIPTION

+

+This isn't really anything, its just some dummy pod code.

+And stuff.

+

+Lots of stuff.

+

+=head2 STUFF

+

+For all your stuff [tm]

+

+Stuffit

+

+Mmmm, stuffed pizza bread.

+

+=cut

diff --git a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/twice.t b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/twice.t
index 098bc3c628d..ffb957dadda 100755
--- a/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/twice.t
+++ b/gnu/usr.bin/perl/cpan/Pod-Parser/t/pod/twice.t
@@ -1,36 +1,36 @@
-use strict;
-use Test;
-use File::Spec;
-
-BEGIN { plan tests => 1 }
-
-use Pod::Parser;
-use Carp;
-$SIG{__DIE__} = \&Carp::confess;
-
-eval {require IO::String;};
-skip($@ ? 'no IO::String' : '', sub {
-  {
-    my $pod_string = 'some I<silly> text';
-    my $handle = IO::String->new( \$pod_string );
-    my $parser = Pod::Parser->new();
-    $parser->parse_from_file( $0, $handle );
-  }
-  # free the reference
-  {
-    my $parser = Pod::Parser->new();
-    $parser->parse_from_file( $0, File::Spec->devnull );
-  }
-  1;
-});
-
-exit 0;
-
-__END__
-
-=head1 EXAMPLE
-
-This test makes sure the parse_from_file is re-entrant
-
-=cut
-
+use strict;

+use Test;

+use File::Spec;

+

+BEGIN { plan tests => 1 }

+

+use Pod::Parser;

+use Carp;

+$SIG{__DIE__} = \&Carp::confess;

+

+eval {require IO::String;};

+skip($@ ? 'no IO::String' : '', sub {

+  {

+    my $pod_string = 'some I<silly> text';

+    my $handle = IO::String->new( \$pod_string );

+    my $parser = Pod::Parser->new();

+    $parser->parse_from_file( $0, $handle );

+  }

+  # free the reference

+  {

+    my $parser = Pod::Parser->new();

+    $parser->parse_from_file( $0, File::Spec->devnull );

+  }

+  1;

+});

+

+exit 0;

+

+__END__

+

+=head1 EXAMPLE

+

+This test makes sure the parse_from_file is re-entrant

+

+=cut

+