use strict;

use warnings;

use FindBin;

use lib "$FindBin::RealBin/../lib";

use Getopt::Long qw(:config no_ignore_case);

use Pod::Usage;

use LaTeXML::Core;

use LaTeXML; # Currently, just for version information.

use LaTeXML::Util::Pathname;

use LaTeXML::Common::Error;

use Encode;

my ($verbosity, $strict, $comments, $noparse, $includestyles) = (0, 0, 1, 0, 0);

my ($format, $destination, $help, $showversion) = ('xml', '');

my ($preamble, $postamble, $logfile) = (undef, undef, undef);

my ($documentid);

my $inputencoding;

my $mode = undef;

my @paths = ();

my (@preload);

GetOptions("destination=s" => \$destination,

"output=s" => \$destination,

"preload=s" => \@preload,

"path=s" => \@paths,

"preamble=s" => \$preamble,

"postamble=s" => \$postamble,

"quiet" => sub { $verbosity--; },

"verbose" => sub { $verbosity++; },

"strict" => \$strict,

"log=s" => \$logfile,

"xml" => sub { $format = 'xml'; },

"tex" => sub { $format = 'tex'; },

"box" => sub { $format = 'box'; },

"bibtex" => sub { $mode = 'BibTeX'; },

"noparse" => \$noparse,

"includestyles" => \$includestyles,

"inputencoding=s" => \$inputencoding,

"comments!" => \$comments,

"VERSION" => \$showversion,

"debug=s" => sub { no strict 'refs'; $LaTeXML::DEBUG{ lc($_[1]) } = 1; },

"documentid=s" => \$documentid,

"help" => \$help,

) or pod2usage(-message => $LaTeXML::IDENTITY,

-exitval => 1, -verbose => 0, -output => \*STDERR);

pod2usage(-message => $LaTeXML::IDENTITY, -exitval => 0, -verbose => 2, -output => \*STDOUT)

if $help;

if ($showversion) { print STDERR "$LaTeXML::IDENTITY\n"; exit(0); }

my $source = shift(@ARGV);

SetVerbosity($verbosity);

UseSTDERR();

if (my @fails = validate_args()) {

print STDERR join("\n", $LaTeXML::IDENTITY, (map { colorizeString($_, 'error'); } @fails),

"use option --help for details", "Conversion failed", '');

exit(1); }

my $starttime = StartTime();

my $latexml;

my $digested;

my $serialized;

eval { # Catch errors

UseLog($logfile);

Note("$LaTeXML::IDENTITY processing $source");

$latexml = LaTeXML::Core->new(

preload => [@preload],

searchpaths => [@paths],

graphicspaths => ['.'],

verbosity => $verbosity, strict => $strict,

includecomments => $comments, inputencoding => $inputencoding,

includestyles => $includestyles,

documentid => $documentid,

nomathparse => $noparse);

# Now do all processing relative to that State, to capture all erros

$latexml->withState(sub {

# ========================================

# First read and digest whatever we're given.

$digested = $latexml->digestFile($source, mode => $mode,

preamble => $preamble, postamble => $postamble);

# ========================================

# Now, convert to DOM, serialize, encode and output, as appropriate.

if ($digested) {

if ($format eq 'tex') {

$serialized = LaTeXML::Core::Token::UnTeX($digested); }

elsif ($format eq 'box') {

$serialized = ($verbosity > 0 ? $digested->stringify : $digested->toString); }

else {

my $dom = $latexml->convertDocument($digested);

$serialized = $dom->toString(1); }

# NOTE that we are serializing via LaTeXML's Document::serialize_aux

# which has NOT been encoded into bytes, so we need an explicit encode before printing/returning

$serialized = Encode::encode('UTF-8', $serialized) if $serialized;

}

$latexml->showProfile(); # Show profile (if any)

}); };

my $exit_message = $@;

Debug($@) if $@ ne $LaTeXML::Common::Error::DIE_MESSAGE;

my $code = $latexml && $latexml->getStatusCode;

my $status = $latexml && $latexml->getStatusMessage;

my $runtime = RunTime($starttime);

Note("Conversion " . ($code == 3 ? 'failed' : 'complete') . ": " . $status . " (reqd. $runtime)");

UseLog(undef);

if (!$serialized) { }

elsif ($destination) {

my $OUTPUT;

open($OUTPUT, ">", $destination) or die "Couldn't open output file $destination: $!";

print $OUTPUT $serialized;

close($OUTPUT); }

else {

print $serialized; }

$latexml = undef;

$digested = undef;

$serialized = undef;

CheckDebuggable();

UseSTDERR(undef);

if ($exit_message) { # non-zero exit code for fatal conversions

exit(1);

}

sub validate_args {

my @fails = ();

push(@fails, "Unrecognized trailing arguments " . join(',', @ARGV)) if @ARGV;

# Check search paths

@paths = map { pathname_canonical($_) } reverse(@paths);

if (my @baddirs = grep { !-d $_ } @paths) {

push(@fails, "These search path do not exist: " . join(', ', @baddirs)); }

# Find the requested source

my $pathname;

if (!$source) {

push(@fails, "No input file given"); }

elsif ($source eq '-') {

{ local $/ = undef;

$source = "literal:" . <>;

$mode = 'TeX' unless defined $mode; } } # Or sniff for bibtex data?

elsif (pathname_is_literaldata($source)) {

}

elsif (!($pathname = pathname_find($source, types => ['tex', 'bib', ''], paths => ['.', @paths]))

|| !-r $pathname) {

push(@fails, "Input file '$source' not readable"); }

else {

$mode = 'BibTeX' if !defined $mode && ($pathname =~ /\.bib$/);

$mode = 'TeX' unless defined $mode; }

# Always create a .log file for tracking the conversion messages

# Use $jobname.latexml.log or just latexml.log for logging by default

if ($pathname && !$logfile) {

my ($dir, $name, $ext) = pathname_split($pathname);

if ($name) {

$logfile = pathname_make(dir => pathname_cwd(), name => $name, type => 'latexml.log'); } }

$logfile = 'latexml.log' unless $logfile;

# Check that destination is valid before wasting any time...

if ($destination) {

$destination = pathname_canonical($destination);

if (my $dir = pathname_directory($destination)) {

if (!(pathname_mkdir($dir) && -w $dir)) {

push(@fails, "Couldn't create writable destination directory $dir: $!"); } } }

return @fails; }