#!/usr/bin/env perl use warnings; use strict; ## Copyright John Collins 1998-2025 ## (username jcc8 at node psu.edu) ## (and thanks to David Coppit (username david at node coppit.org) ## for suggestions) ## Copyright Evan McLean ## (modifications up to version 2) ## Copyright 1992 by David J. Musliner and The University of Michigan. ## (original version) ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 2 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, write to the Free Software ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 ## ## See file CHANGES for list of main version-to-version changes. ## ## Modified by Evan McLean (no longer available for support) ## Original script (RCS version 2.3) called "go" written by David J. Musliner ## ##----------------------------------------------------------------------- ## Explicit exit codes: ## 10 = bad command line arguments ## 11 = file specified on command line not found ## or other file not found ## 12 = failure in some part of making files ## 13 = error in initialization file ## 20 = probable bug ## or retcode from called program. our ($my_name, $My_name, $version_num, $version_details); BEGIN { # Make sure the following are available when printing diagnostics in BEGIN # blocks. $my_name = 'latexmk'; $My_name = 'Latexmk'; $version_num = '4.87'; $version_details = "$My_name, John Collins, 15 June 2025. Version $version_num"; } # Ensure that when STDERR and STDOUT are both redirected, the results are # in the order they are written. Otherwise, the default situation for # redirected output is that STDERR is always autoflushed, but STDOUT is # not, and therefore output does not appear in the order is was written. STDOUT->autoflush(1); use Config; use File::Basename; use File::Copy; use File::Spec::Functions qw( catfile file_name_is_absolute rel2abs ); # If possible, use better glob, which does not use space as item separator. # It's either File::Glob::bsd_glob or File::Glob::glob # The first does not exist in old versions of Perl, while the second # is deprecated in more recent versions and will be removed our $have_bsd_glob = 0; use File::Glob; if ( eval{ File::Glob->import('bsd_glob'); 1; } ) { # Success in importing bsd_glob $have_bsd_glob = 1; } elsif ( eval{ File::Glob->import('glob'); 1; } ) { warn( "$My_name: I could not import File::Glob:bsd_glob, probably because your\n", " Perl is too old. I have arranged to use the deprecated File::Glob:glob\n", " instead.\n", " WARNING: It may malfunction on clean up operation on filenames containing\n", " spaces.\n" ); $have_bsd_glob = 0; } else { die "Could not import 'File::Glob:bsd_glob' or 'File::Glob:glob'\n"; } use File::Path 2.08 qw( make_path ); use FileHandle; use File::Find; use List::Util qw( max ); use Cwd; use Cwd "abs_path"; use Cwd "chdir"; # Ensure $ENV{PWD} tracks cwd. use Digest::MD5; our %HiRes_non_imports; use Time::HiRes; BEGIN { # Import some HiRes functions to override standard ones. # However, Time::HiRes's documentation says that some of its functions # may be unimplemented on some systems. # So take precautions in case the ones I need aren't implemented. # I must do the import in a BEGIN block, i.e., during compilation # phase, else calls to time() etc get compiled to use std time(), i.e., # CORE::time(), instead of the HiRes versions. # # Notes: # (a) On Windows with a standard Windows perl, the HiRes functions still # only give 1 sec resolution, and utime is not imported. # (b) Other cases, may or may not give better than 1 sec, depending on # combination of OS, file system, and server (for remote system). %HiRes_non_imports = (); foreach ( ( qw( time stat sleep utime ) ) ) { if ( ! eval{ Time::HiRes->import($_); 1; } ) { $HiRes_non_imports{$_} = 1; # warn "$My_name: Cannot import Time::HiRes::$_ on this system because:\n", # "$@"; } } } ################################################# # # Unicode set up to be used in latexmk # use Encode qw( decode encode ); use Unicode::Normalize; use utf8; # Strings are coded in UTF-8 in this file, stored internally # decoded into Perl's internal character representation. use feature 'unicode_strings'; use feature 'say'; # Coding: # 1. $CS_system = CS for file names in file system calls, and for CL. # It's to be UTF-8 on all except: MSWin when the MSWin system code page is # not 65001. # 2. Internally use CS_system generally, and especially for filenames. # Then standard file system calls, print to terminal don't need encoding, # and things in rc files work unchanged from earlier versions of latexmk, # when I didn't treat non-ASCII coding issues explicitly. # 3. But must set console codepage to system codepage on MSWin, otherwise # display on terminal is garbled. # 4. fdb_latexmk: write and read UTF-8, convert to and from CS_system for # strings. # 5. .fls, .log, .aux are all UTF-8, so if necessary convert to CS_system. # 6. However, with TeXLive on MSWin with system CP not equal to 65001, # the PWD is in CS_system on all but most recent *latex (that's a bug). # Convert file/path names to CS_system. # 7. Don't support non-UTF-8 on *nix. # 8. Do NOT do any conversion to a NF for Unicode: File systems and OS calls # to access them are **either** normalization-sensitive (I think, e.g., # ext4) and we need to preserve normalization, **or** they are # normalization-insensitve (e.g., hfs+, apfs), in which case we can access # a file with any normalization for its name. # # N.B. I18N::Langinfo often doesn't give useful enough information. # My default CSs: UTF-8 our $CS_system = 'UTF-8'; # Quick short cut for tests of whether conversions needed: our $no_CP_conversions = 1; # Win32 specific CP **numbers**. Initialize to 65001 (utf-8), and change # by results of system calls. # Corresponding CS name: Prefix by 'CP'. # Preserve intial values for console/terminal to allow restore on exit. our ($CP_Win_system, $CP_init_Win_console_in, $CP_init_Win_console_out); $CP_Win_system = $CP_init_Win_console_in = $CP_init_Win_console_out = '65001'; # Whether to revert Windows console CPs on exit: our $Win_revert_settings = 0; if ($^O eq "MSWin32") { eval { require Win32; $CP_Win_system = Win32::GetACP(); $CS_system = 'CP' . $CP_Win_system; $CP_init_Win_console_in = Win32::GetConsoleCP(); $CP_init_Win_console_out = Win32::GetConsoleOutputCP(); if ( Win32::SetConsoleOutputCP($CP_Win_system) && Win32::SetConsoleCP($CP_Win_system) ) { } else { warn "Cannot set Windows Console Output CP to $CP_Win_system.\n"; } }; if ($@) { warn "Trouble finding and setting code pages used by Windows:\n", " $@", " I'LL CONTINUE WITH UTF-8.\n"; } else { $Win_revert_settings = ($CP_init_Win_console_in ne $CP_Win_system) || ($CP_init_Win_console_out ne $CP_Win_system); print "Initial Win CP for (console input, console output, system): ", "(CP$CP_init_Win_console_in, CP$CP_init_Win_console_out, CP$CP_Win_system)\n", "I changed them all to CP$CP_Win_system\n"; } } $no_CP_conversions = ($CS_system eq 'UTF-8') || ($CS_system eq 'CP65001'); # Ensure that on ctrl/C interruption, etc, Windows console CPs are restored: use sigtrap qw(die untrapped normal-signals); END { if ($Win_revert_settings ) { warn "Reverting Windows console CPs to ", "(in,out) = ($CP_init_Win_console_in,$CP_init_Win_console_out)\n"; Win32::SetConsoleCP($CP_init_Win_console_in); Win32::SetConsoleOutputCP($CP_init_Win_console_out); } } ######################################################## ################################################################ ################################################################ #============ Deal with how I'm invoked: name and CL args: # Name that I'm invoked with indicates default behavior (latexmk # v. pdflatexmk, etc): our ($invoked_name) = fileparseA($0); # Save name, since I override it if I don't recognize it our $invoked_kind = $invoked_name; print "$My_name: Invoked as '$invoked_name'\n" if ($invoked_name ne 'latexmk'); # Map my invoked name to pointer to array of default values for $dvi_mode, # $postscript_mode, $pdf_mode, $xdv_mode. These are used if after processing # rc files and CL args, no values are set for any of these variables. # Thus default compilation for latexmk is by latex, # for pdflatexmk is by pdflatex, etc. our %compilation_defaults = ( 'latexmk' => [1,0,0,0], 'lualatexmk' => [0,0,4,0], 'pdflatexmk' => [0,0,1,0], 'xelatexmk' => [0,0,5,0], ); # If name isn't in canonical set, change it to a good default: unless (exists $compilation_defaults{$invoked_name}) { $invoked_name = 'latexmk'; } #================== ################################################################ ################################################################ # Translation of signal names to numbers and vv: our %signo = (); our @signame = (); if ( defined $Config{sig_name} ) { my $i = 0; foreach my $name (split('\s+', $Config{sig_name})) { $signo{$name} = $i; $signame[$i] = $name; $i++; } } else { warn "Something wrong with the perl configuration: No signals?\n"; } # Line length in log file that indicates wrapping. # This number EXCLUDES line-end characters, and is one-based. # It is the parameter max_print_line in the TeX program. (tex.web) our $log_wrap = 79; # Expected biggest construct in log file in bytes. # Use to limit number of (potentially) wrapped lines to combine into single line. our $max_log_construct = 600; # Whether to search for ^^ notation in log file for non-7-bit characters, # and convert to bytes. (Note: ^^ notation is produced by hilatex in # TeXLive 2023..., and by pdflatex in MiKTeX 22.1... if no special option is # used (-enable-8bit-chars). (Also pdflatex in TeXLive 2025 (and earlier) # gives it if -translate-file=empty is used.) # Same applies to .aux file. # But .fls file is always UTF-8, so we don't need the conversion there. our $conv_hathat = 1; ######################################################################### ## Default parsing and file-handling settings ## Array of reg-exps for patterns in log-file for file-not-found ## Each item is the string in a regexp, without the enclosing slashes. ## First parenthesized part is the filename. ## Note the need to quote slashes and single right quotes to make them ## appear in the regexp. ## Add items by push, e.g., ## push @file_not_found, '^No data file found `([^\\\']*)\\\''; ## will give match to line starting "No data file found `filename'" our @file_not_found = ( '^No file\\s+(.*): Run ', # That first pattern is used by recent versions (from 2024 onwards), # and must appear ahead of other patterns starting 'No file', since # the parsing of the target line is ambiguous between patterns. '^No file\\s+(.*)\\.$', '^No file\\s+(.+)\s*$', '^\\! LaTeX Error: File `([^\\\']*)\\\' not found\\.', '^\\! I can\\\'t find file `([^\\\']*)\\\'\\.', '.*?:\\d*: LaTeX Error: File `([^\\\']*)\\\' not found\\.', '^LaTeX Warning: File `([^\\\']*)\\\' not found', '^Package .* [fF]ile `([^\\\']*)\\\' not found', '^Package .* No file `([^\\\']*)\\\'', 'Error: pdflatex \(file ([^\)]*)\): cannot find image file', ': File (.*) not found:\s*$', '! Unable to load picture or PDF file \\\'([^\\\']+)\\\'.', ); # Array of reg-exps for patterns in log file for certain latex warnings # that we will call bad warnings. They are not treated as errors by # *latex, but depending on the $bad_warning_is_error setting # we will treat as if they were actual errors. our @bad_warnings = ( # Remember: \\ in perl inside single quotes gives a '\', so we need # '\\\\' to get '\\' in the regexp. '^\(\\\\end occurred when .* was incomplete\)', '^\(\\\\end occurred inside .*\)', ); our $bad_warning_is_error = 0; # Characters that we won't allow in the name of a TeX file. # Notes: Some are disallowed by TeX itself (at least, not without dirty # tricks à la David Carlisle). # '\' results in TeX macro expansion # '$' results in possible variable substitution by kpsewhich called from tex. # '"' gets special treatment. # NULL never allowed in file/path name. # See subroutine test_fix_texnames and its call for their use. # The full range of these excluded characters only applies when the # filename is used in TeX code, directly or indirectly. (E.g., # .tex filename given on the command line to *tex, or in \input # statements, and the like.) It does not apply in other # situations, e.g., for the name of the directory given to the # -output-directory option. The name of the output directory can # correctly appear as part of the names of files read in both the # .log file and the .fls file. So this list of disallowed # characters definitely does not apply to filenames obtained from # the .log and .fls files etc. # (Of course, some of these characters are prohibited in file and # path names, either (like NULL) in all current OSs and file # systems, or on particular combinations of OS and file system. We # won't try to implement all the restrictions; it's too hard.) our $illegal_in_texname = "\x00\t\f\n\r\$%\\~\x7F"; # Whether to normalize aux_dir and out_dir where possible. # This is important when these directories aren't subdirectories of the cwd, # and TeXLive's makeindex and/or bibtex are used. our $normalize_names = 2; # Strongest kind. ## Hash mapping file extension (w/o period, e.g., 'eps') to a single regexp, # whose matching by a line in a file with that extension indicates that the # line is to be ignored in the calculation of the hash number (md5 checksum) # for the file. Typically used for ignoring datestamps in testing whether # a file has changed. # Add items e.g., by # $hash_calc_ignore_pattern{'eps'} = '^%%CreationDate: '; # This makes the hash calculation for an eps file ignore lines starting with # '%%CreationDate: ' # ?? Note that a file will be considered changed if # (a) its size changes # or (b) its hash changes # So it is useful to ignore lines in the hash calculation only if they # are of a fixed size (as with a date/time stamp). our %hash_calc_ignore_pattern =(); # Specification of templates for extra rules. # See subroutine rdb_initialize_rules for examples of rule templates, and # how they get used to construct rules. # (Documentation obviously needs to be improved!) our %extra_rule_spec = (); #??????? !!!!!!!!! If @aux_hooks and @latex_file_hooks are still needed, # should I incorporate them into the general hook hash??? # # Hooks for customized extra processing on aux files. The following # variable is an array of references to functions. Each function is # invoked in turn when a line of an aux file is processed (if none # of the built-in actions have been done). On entry to the function, # the following variables are set: # $_ = current line of aux file # $rule = name of rule during the invocation of which, the aux file # was supposed to have been generated. our @aux_hooks = (); # # Hooks for customized processing on lists of source and missing files. # The following variable is an array of references to functions. Each # function is invoked in turn after a run of latex (or pdflatex etc) and # latexmk has analyzed the .log and .fls files for dependency information. # On entry to each called function, the following variables are set: # $rule = name of *latex rule # %dependents: maps source files and possible source files to a status. # See begining of sub parse_log for possible values. our @latex_file_hooks = (); # # Single hash for various stacks of hooks: our %hooks = (); for ( 'before_xlatex', 'after_xlatex', 'after_xlatex_analysis', 'after_main_pdf', 'cleanup', 'cleanup_extra_full' ) { $hooks{$_} = []; } $hooks{aux_hooks} = \@aux_hooks; $hooks{latex_file_hooks} = \@latex_file_hooks; ######################################################################### ## Default document processing programs, and related settings, ## These are mostly the same on all systems. ## Most of these variables represents the external command needed to ## perform a certain action. Some represent switches. ## Which TeX distribution is being used ## E.g., "MiKTeX 2.9", "TeX Live 2018" ## "" means not determined. Obtain from first line of .log file. our $tex_distribution = ''; # List of known *latex rules: our %possible_primaries = ( 'dvilualatex' => 'primary', 'hilatex' => 'primary', 'latex' => 'primary', 'lualatex' => 'primary', 'pdflatex' => 'primary', 'xelatex' => 'primary' ); # Command strings for them: our ($dvilualatex, $hilatex, $latex, $lualatex, $pdflatex, $xelatex ); std_tex_cmds(); # Possible code to execute by *latex before inputting source file. # Not used by default. our $pre_tex_code = ''; ## Default switches: our $hilatex_default_switches = ''; our $latex_default_switches = ''; our $pdflatex_default_switches = ''; our $dvilualatex_default_switches = ''; our $lualatex_default_switches = ''; # Note that xelatex is used to give xdv file, not pdf file, hence # we need the -no-pdf option. our $xelatex_default_switches = '-no-pdf'; ## Switch(es) to make them silent: our $hilatex_silent_switch = '-interaction=batchmode'; our $latex_silent_switch = '-interaction=batchmode'; our $pdflatex_silent_switch = '-interaction=batchmode'; our $dvilualatex_silent_switch = '-interaction=batchmode'; our $lualatex_silent_switch = '-interaction=batchmode'; our $xelatex_silent_switch = '-interaction=batchmode'; # Whether to emulate -aux-directory, so we can use it on system(s) (TeXLive) # that don't support it. # Possible values: 0: I don't do any emulation, and use -aux-directory & # -out-directory options to *latex. # 1: Emulate MiKTeX behavior: Use -output-directory= # in call to *latex. Then move pdf (etc) files after run. our $emulate_aux = 1; # Whether emulate_aux had to be switched on during a run: our $emulate_aux_switched = 0; #-------------------- # Specification of extensions/files that need special treatment, # e.g., in cleanup or in analyzing missing dependent files. # # %input_extensions maps primary_rule_name to pointer to hash of file extensions # used for extensionless files specified in the source file by constructs # like \input{file} \includegraphics{file} our %input_extensions = (); set_input_ext( 'latex', 'tex', 'eps' ); set_input_ext( 'pdflatex', 'tex', 'jpg', 'pdf', 'png' ); $input_extensions{lualatex} = $input_extensions{pdflatex}; $input_extensions{xelatex} = $input_extensions{pdflatex}; # Save these values as standards to be used when switching output, # i.e., when actual primary rule differs from standard. our %standard_input_extensions = %input_extensions; # Possible extensions for main output file of *latex: our %allowed_output_ext = ( ".dvi" => 1, ".xdv" => 1, ".pdf" => 1 ); # Extensions etc, of special use by latexmk our $save_error_suffix = '-SAVE-ERROR'; # Suffix to be added to filename, when an # erroneous file is saved insted of being deleted. our $fdb_ext = 'fdb_latexmk'; # Extension for the file for latexmk's # file-database # Make it long to avoid possible collisions. our $fdb_ver = 4; # Version number for kind of fdb_file. # Variables relevant to specifying cleanup. # The first set of variables is intended to be user configurable. # # The @generated_exts array contains list of extensions (without # period) for files that are generated by rules run by latexmk. # # Instead of an extension, an item in the array can be a string containing # the placeholder %R for the root of the filenames. This is used for more # general patterns. Such a pattern may contain wildcards (bsd_glob # definitions). # # By default, it excludes "final output files" that # are normally only deleted on a full cleanup, not a small cleanup. # These files get two kinds of special treatment: # 1. In clean up, where depending on the kind of clean up, some # or all of these generated files are deleted. # (Note that special treatment is given to aux files.) # 2. In analyzing the results of a run of *LaTeX, to # determine if another run is needed. With an error free run, # a rerun should be provoked by a change in any source file, # whether a user file or a generated file. But with a run # that ends in an error, only a change in a user file during # the run (which might correct the error) should provoke a # rerun, but a change in a generated file should not. # Also at the start of a round of processing, only user-file # changes are relevant. # Special cases for extensions aux and bbl # aux files beyond the standard one are found by a special analysis # bbl files get special treatment because their deletion is conditional # and because of the possibility of extra bibtex/biber rules with # non-standard basename. our @generated_exts = ( 'aux', 'bcf', 'bcf'.$save_error_suffix, 'fls', 'idx', 'ind', 'lof', 'lot', 'out', 'run.xml', 'toc', 'blg', 'ilg', 'log', 'xdv' ); # N.B. 'out' is generated by hyperref package our $clean_ext = ""; # For backward compatibility: Space separated # extensions to be added to @generated_exts after # startup (and rc file reading). # Extensions of files to be deleted by -C, but aren't normally included # in the small clean up by -c. Analogous to @generated_exts and $clean_ext, # except that pattern rules (with %R) aren't applied. our @final_output_exts = ( 'dvi', 'dviF', 'hnt', 'ps', 'psF', 'pdf', 'synctex', 'synctex.gz' ); our $clean_full_ext = ""; # Set of extra specific files to be deleted in small cleanup. These are # ones that get generated under some kinds of error conditions. All cases: # Relative to current directory, and relative to aux and out directories. our @std_small_cleanup_files = ( 'texput.log', "texput.aux", "missfont.log" ); #------------------------- # Information about options to latex and pdflatex that latexmk will simply # pass through to *latex # Option without arg. maps to itself. # Option with arg. maps the option part to the full specification # e.g., -kpathsea-debug => -kpathsea-debug=NUMBER our %allowed_latex_options = (); our %allowed_latex_options_with_arg = (); foreach ( ##### # TeXLive options "-cnf-line=STRING parse STRING as a configuration file line", "-draftmode switch on draft mode (generates no output PDF)", "-enc enable encTeX extensions such as \\mubyte", "-etex enable e-TeX extensions", "-file-line-error enable file:line:error style messages", "-no-file-line-error disable file:line:error style messages", "-fmt=FMTNAME use FMTNAME instead of program name or a %& line", "-halt-on-error stop processing at the first error", "-interaction=STRING set interaction mode (STRING=batchmode/nonstopmode/\n". " scrollmode/errorstopmode)", "-ipc send DVI output to a socket as well as the usual\n". " output file", "-ipc-start as -ipc, and also start the server at the other end", "-kpathsea-debug=NUMBER set path searching debugging flags according to\n". " the bits of NUMBER", "-mktex=FMT enable mktexFMT generation (FMT=tex/tfm/pk)", "-no-mktex=FMT disable mktexFMT generation (FMT=tex/tfm/pk)", "-mltex enable MLTeX extensions such as \charsubdef", "-output-comment=STRING use STRING for DVI file comment instead of date\n". " (no effect for PDF)", "-parse-first-line enable parsing of first line of input file", "-no-parse-first-line disable parsing of first line of input file", "-progname=STRING set program (and fmt) name to STRING", "-shell-escape enable \\write18{SHELL COMMAND}", "-no-shell-escape disable \\write18{SHELL COMMAND}", "-shell-restricted enable restricted \\write18", "-src-specials insert source specials into the DVI file", "-src-specials=WHERE insert source specials in certain places of\n". " the DVI file. WHERE is a comma-separated value\n". " list: cr display hbox math par parend vbox", "-synctex=NUMBER generate SyncTeX data for previewers if nonzero", "-translate-file=TCXNAME use the TCX file TCXNAME", "-8bit make all characters printable by default", ##### # MikTeX options not in TeXLive "-alias=app pretend to be app", "-buf-size=n maximum number of characters simultaneously present\n". " in current lines", "-c-style-errors C-style error messages", "-disable-installer disable automatic installation of missing packages", "-disable-pipes disable input (output) from (to) child processes", "-disable-write18 disable the \\write18{command} construct", "-dont-parse-first-line disable checking whether the first line of the main\n". " input file starts with %&", "-enable-enctex enable encTeX extensions such as \\mubyte", "-enable-installer enable automatic installation of missing packages", "-enable-mltex enable MLTeX extensions such as \charsubdef", "-enable-pipes enable input (output) from (to) child processes", "-enable-write18 fully enable the \\write18{command} construct", "-error-line=n set the width of context lines on terminal error\n". " messages", "-extra-mem-bot=n set the extra size (in memory words) for large data\n". " structures", "-extra-mem-top=n set the extra size (in memory words) for chars,\n". " tokens, et al", "-font-max=n set the maximum internal font number", "-font-mem-size=n set the size, in TeX memory words, of the font memory", "-half-error-line=n set the width of first lines of contexts in terminal\n". " error messages", "-hash-extra=n set the extra space for the hash table of control\n". " sequences", "-job-time=file set the time-stamp of all output files equal to\n". " file's time-stamp", "-main-memory=n change the total size (in memory words) of the main\n". " memory array", "-max-in-open=n set the maximum number of input files and error\n". " insertions that can be going on simultaneously", "-max-print-line=n set the width of longest text lines output", "-max-strings=n set the maximum number of strings", "-nest-size=n set the maximum number of semantic levels\n". " simultaneously active", "-no-c-style-errors standard error messages", "-param-size=n set the the maximum number of simultaneous macro\n". " parameters", "-pool-size=n set the maximum number of characters in strings", "-record-package-usages=file record all package usages and write them into\n". " file", "-restrict-write18 partially enable the \\write18{command} construct", "-save-size=n set the the amount of space for saving values\n". " outside of current group", "-stack-size=n set the maximum number of simultaneous input sources", "-string-vacancies=n set the minimum number of characters that should be\n". " available for the user's control sequences and font\n". " names", "-tcx=name process the TCX table name", "-time-statistics show processing time statistics", "-trace enable trace messages", "-trace=tracestreams enable trace messages. The tracestreams argument is\n". " a comma-separated list of trace stream names", "-trie-size=n set the amount of space for hyphenation patterns", "-undump=name use name as the name of the format to be used,\n". " instead of the name by which the program was\n". " called or a %& line.", ##### # Options passed to *latex that have special processing by latexmk, # so they are commented out here. #-jobname=STRING set the job name to STRING #-aux-directory=dir Set the directory dir to which auxiliary files are written #-output-directory=DIR use existing DIR as the directory to write files in # "-output-format=FORMAT use FORMAT for job output; FORMAT is `dvi\" or `pdf\"", #-quiet #-recorder enable filename recorder # # Options with different processing by latexmk than *latex #-help #-version # # Options NOT used by latexmk #-includedirectory=dir prefix dir to the search path #-initialize become the INI variant of the compiler #-ini be pdfinitex, for dumping formats; this is implicitly # true if the program name is `pdfinitex' ) { if ( /^([^\s=]+)=/ ) { $allowed_latex_options_with_arg{$1} = $_; } elsif ( /^([^\s=]+)\s/ ) { $allowed_latex_options{$1} = $_; } } # Arrays of options that will be added to latex and pdflatex. # These need to be stored until after the command line parsing is finished, # in case the values of $latex and/or $pdflatex change after an option # is added. our @extra_dvilualatex_options = (); our @extra_hilatex_options = (); our @extra_latex_options = (); our @extra_pdflatex_options = (); our @extra_lualatex_options = (); our @extra_xelatex_options = (); ## Command to invoke biber & bibtex our $biber = 'biber %O %S'; our $bibtex = 'bibtex %O %S'; # Switch(es) to make biber & bibtex silent: our $biber_silent_switch = '--onlylog'; our $bibtex_silent_switch = '-terse'; our $bibtex_use = 1; # Whether to actually run bibtex to update bbl files. # This variable is also used in deciding whether to # delete bbl files in clean up operations. # 0: Never run bibtex. # Do NOT delete bbl files on clean up. # 1: Run bibtex only if the bibfiles exists # according to kpsewhich, and the bbl files # appear to be out-of-date. # Do NOT delete bbl files on clean up. # 1.5: Run bibtex only if the bibfiles exists # according to kpsewhich, and the bbl files # appear to be out-of-date. # Only delete bbl files on clean up if bibfiles exist. # 2: Run bibtex when the bbl files are out-of-date # Delete bbl files on clean up. # # In any event bibtex is only run if the log file # indicates that the document uses bbl files. our $bibtex_fudge = 1; # Whether or not to cd to aux dir when running bibtex. # If the cd is not done, and bibtex is passed a # filename with a path component, then it can easily # happen that (a) bibtex refuses to write bbl and blg # files to the aux directory, for security reasons, # and/or (b) bibtex in pre-2019 versions fails to find # some input file(s). But in some other cases, the cd # method fails. ## Command to invoke makeindex our $makeindex = 'makeindex %O -o %D %S'; # Switch(es) to make makeinex silent: our $makeindex_silent_switch = '-q'; our $makeindex_fudge = 1; # Whether or not to cd to aux dir when running makeindex. # Set to 1 to avoid security-related prohibition on # makeindex writing to aux_dir when it is not specified # as a subdirectory of cwd. ## Command to convert dvi file to pdf file directly. # Use option -dALLOWPSTRANSPARENCY so that it works with documents # using pstricks etc: our $dvipdf = 'dvipdf -dALLOWPSTRANSPARENCY %O %S %D'; # N.B. Standard dvipdf runs dvips and gs with their silent switch, so for # standard dvipdf $dvipdf_silent_switch is unneeded, but innocuous. # But dvipdfmx can be used instead, and it has a silent switch (-q). # So implementing $dvipdf_silent_switch is useful. our $dvipdf_silent_switch = '-q'; ## Command to convert dvi file to ps file: our $dvips = 'dvips %O -o %D %S'; ## Command to convert dvi file to ps file in landscape format: our $dvips_landscape = 'dvips -tlandscape %O -o %D %S'; # Switch(es) to get dvips to make ps file suitable for conversion to good pdf: # (If this is not used, ps file and hence pdf file contains bitmap fonts # (type 3), which look horrible under acroread. An appropriate switch # ensures type 1 fonts are generated. You can put this switch in the # dvips command if you prefer.) our $dvips_pdf_switch = '-P pdf'; # Switch(es) to make dvips silent: our $dvips_silent_switch = '-q'; ## Command to convert ps file to pdf file. # Use option -dALLOWPSTRANSPARENCY so that it works with documents # using pstricks etc: our $ps2pdf = 'ps2pdf -dALLOWPSTRANSPARENCY %O %S %D'; ## Command to convert xdv file to pdf file our $xdvipdfmx = 'xdvipdfmx -E -o %D %O %S'; our $xdvipdfmx_silent_switch = '-q'; ## Command to search for tex-related files our $kpsewhich = 'kpsewhich %S'; ## Command to run make: our $make = 'make'; ##Printing: our $print_type = 'auto'; # When printing, print the postscript file. # Possible values: 'dvi', 'ps', 'pdf', 'auto', 'none' # 'auto' ==> set print type according to the printable # file(s) being made: priority 'ps', 'pdf', 'dvi' # Viewers. These are system dependent, so default to none: our ( $pdf_previewer, $ps_previewer, $ps_previewer_landscape, $dvi_previewer, $dvi_previewer_landscape, $hnt_previewer ); $pdf_previewer = $ps_previewer = $ps_previewer_landscape = $dvi_previewer = $dvi_previewer_landscape = $hnt_previewer = "NONE"; our $dvi_update_signal = undef; our $ps_update_signal = undef; our $pdf_update_signal = undef; our $dvi_update_command = undef; our $ps_update_command = undef; our $pdf_update_command = undef; # Viewer update methods: # 0 => auto update: viewer watches file (e.g., gv) # 1 => manual update: user must do something: e.g., click on window. # (e.g., ghostview, MSWIN previewers, acroread under UNIX) # 2 => send signal. Number of signal in $dvi_update_signal, # $ps_update_signal, $pdf_update_signal # 3 => viewer can't update, because it locks the file and the file # cannot be updated. (acroread under MSWIN) # 4 => run a command to force the update. The commands are # specified by the variables $dvi_update_command, # $ps_update_command, $pdf_update_command our $dvi_update_method = 1; our $hnt_update_method = 1; our $ps_update_method = 1; our $pdf_update_method = 1; # Whether to allow latexmk to create subdirectories of aux_dir when there's # a report in the log file that *latex "can't write on file ...". # Values: 0: no subdir creation, # 1: only for aux files (occurs with \include{chapters/chap} etc # 2: generally our $allow_subdir_creation = 1; our $new_viewer_always = 0; # If 1, always open a new viewer in pvc mode. # If 0, only open a new viewer if no previous # viewer for the same file is detected. # Commands for use in pvc mode for compiling, success, warnings, and failure; # they default to empty, i.e., not to use: our ($compiling_cmd, $success_cmd, $warning_cmd, $failure_cmd) = ( '', '', '', '' ); # Commands for printing are highly system dependent, so default to NONE: our $lpr = 'NONE $lpr variable is not configured to allow printing of ps files'; our $lpr_dvi = 'NONE $lpr_dvi variable is not configured to allow printing of dvi files'; our $lpr_pdf = 'NONE $lpr_pdf variable is not configured to allow printing of pdf files'; # The $pscmd below holds a **system-dependent** command to list running # processes. It is used to find the process ID of the viewer looking at # the current output file. The output of the command must include the # process number and the command line of the processes, since the # relevant process is identified by the name of file to be viewed. # Its use is not essential. our $pscmd = 'NONE $pscmd variable is not configured to detect running processes'; our $pid_position = -1; # offset of PID in output of pscmd. # Negative means I cannot use ps our $quote_filenames = 1; # Quote filenames in external commands our $del_dir = ''; # Directory into which cleaned up files are to be put. # If $del_dir is '', just delete the files in a clean up. our @rc_system_files = (); ######################################################################### ################################################################ ## Special variables for system-dependent fudges, etc. # ???????? !!!!!!!!!! our $log_file_binary = 0; # Whether to treat log file as binary # Normally not, since the log file SHOULD be pure text. # But Miktex 2.7 sometimes puts binary characters # in it. (Typically in construct \OML ... after # overfull box with mathmode.) # Sometimes there is ctrl/Z, which is not only non-text, # but is end-of-file marker for MS-Win in text mode. our $MSWin_fudge_break = 1; # Give special treatment to ctrl/C and ctrl/break # in -pvc mode under MSWin # Under MSWin32 (at least with perl 5.8 and WinXP) # when latexmk is running another program, and the # user gives ctrl/C or ctrl/break, to stop the # daughter program, not only does it reach # the daughter, but also latexmk/perl, so # latexmk is stopped also. In -pvc mode, # this is not normally desired. So when the # $MSWin_fudge_break variable is set, # latexmk arranges to ignore ctrl/C and # ctrl/break during processing of files; # only the daughter programs receive them. # This fudge is not applied in other # situations, since then having latexmk also # stopping because of the ctrl/C or # ctrl/break signal is desirable. # The fudge is not needed under UNIX (at least # with Perl 5.005 on Solaris 8). Only the # daughter programs receive the signal. In # fact the inverse would be useful: In # normal processing, as opposed to -pvc, if # force mode (-f) is set, a ctrl/C is # received by a daughter program does not # also stop latexmk. Under tcsh, we get # back to a command prompt, while latexmk # keeps running in the background! ## Substitute backslashes in file and directory names for ## MSWin command line our $MSWin_back_slash = 0; ## Separator of elements in search_path. Default is unix value our $search_path_separator = ':'; # Directory for temporary files. Default to current directory. our $tmpdir = "."; # Latexmk does tests on whether a particular generated file, e.g., log or # fls, has been generated on a current run of a rule, especially *latex, or # is leftover from previous runs. An expected file can fail to be # generated or generated in other than the expected place because of errors # or because of misconfiguration of latexmk. There are also files (notably # bcf files) that are generated or not according to the current set of # packages, options, etc used by a document. # # The test for whether a file was generated on the current run of a rule is # that the modification time of the file is at least as recent as the # system time at the start of the run. A file with a modification time # significantly less than the time at the start of the run is presumably # left over from a previous run and not generated in the currrent run. (An # allowance is made in this comparison for the effects of granularity of # file-system times. Such granularity can make a file time a second or two # earlier than the system time at which the file was last modified.) # # But generated files may be on a file system hosted by a server computer # that is different than the computer running latexmk. There may be an # offset between the time on the two computers; this can make it # incorrectly appear that the generated files were made before the # run. Most of the time, this problem does not arise, since (a) typical # usage of latexmk is with a local file system, and (b) current-day # computers and operating systems have their time synchronized accurately # with a time server. Difficulties are most acute with small documents # compiled on a fast computer, e.g., with sub-second compilation times. # # When latexmk sees symptoms of an excessive offset, it measures the offset # between the filesystem time and the system time. This involves writing a # temporary file, getting its modification time, and deleting it. Then # when testing for whether a file was made on the current run or not, an # allowance is then made for the measured time offset between the two # computers. # # Note that typically an invocation of latexmk's processing of a document # occurs after some human action, e.g., editting a document or a # configuration file. So a file that is left over from a previous run and # not overwritten on the current run will have a file time at least many # seconds less than the current time, corresponding to the time scale for a # human run-edit-run cycle. So one does NOT have to particularly precise # about time differences. # # Granularity of file system etc: # FAT file system: 2 sec granularity. Others 1 sec or often much less. # # Functions available to latexmk from Perl: # mtime from Perl's CORE::stat: 1 sec, but 2 sec on FAT file system; # mtime from Time_HiRes::stat: can be much less than 1 sec, if the # combination of Perl, the OS and the file system support it. # system time from CORE::time(): 1 sec; # system time from Time::HiRes::time(): Much less than 1 sec. # Variables controlling the assessment of time offset between file system # and computer: our $filetime_causality_threshold = 5; # This is the size of time differences below which latexmk doesn't # worry. It allows for (a) different granularity between system time # and filesystem time, (b) for a modest mismatch between file and system # time. This allowance can be generous; it merely needs to be below the # human time-scale for editing documents, reconfiguring (or # misconfiguring) latexmk, etc. our $filetime_offset_measured = 0; # Measurement not yet done. our $filetime_offset = 0; # Filetime relative to system time. # Assume zero to start (corresponding to # local file system). # Will be updated if necessary. our $filetime_offset_report_threshold = 10; # Threshold beyond which filetime offsets # are reported at end of run; large # offsets indicate incorrect system # time on at least one system. ################################################################ ################################################################ # System-dependent overrides: # Currently, the cases I have tests for are: MSWin32, cygwin, linux and # darwin, msys, with the main complications being for MSWin32 and cygwin. # Further special treatment may also be useful for MSYS (for which $^O reports # "msys"). This is another *nix-emulation/system for MSWindows. At # present it is treated as unix-like, but the environment variables # are those of Windows. (The test for USERNAME as well as USER was # to make latexmk work under MSYS's perl.) # our $start_NT = 'NONE'; if ( $^O eq "MSWin32" ) { # Pure MSWindows configuration ## Configuration parameters: ## Use first existing case for $tmpdir: $tmpdir = $ENV{TMPDIR} || $ENV{TEMP} || '.'; $log_file_binary = 1; # Protect against ctrl/Z in log file from # Miktex 2.7. ## List of possibilities for the system-wide initialization file. ## The first one found (if any) is used. @rc_system_files = ( "C:/latexmk/LatexMk", "C:/latexmk/latexmkrc" ); $search_path_separator = ';'; # Separator of elements in search_path # For a pdf-file, "start x.pdf" starts the pdf viewer associated with # pdf files, so no program name is needed: $pdf_previewer = 'start %O %S'; $ps_previewer = 'start %O %S'; $ps_previewer_landscape = $ps_previewer; $dvi_previewer = 'start %O %S'; $dvi_previewer_landscape = "$dvi_previewer"; $hnt_previewer = 'start %O %S'; $pdf_update_method = 3; # acroread locks the pdf file } elsif ( $^O eq "cygwin" ) { # The problem is a mixed MSWin32 and UNIX environment. # Perl decides the OS is cygwin in two situations: # 1. When latexmk is run from a cygwin shell under a cygwin # environment. Perl behaves in a UNIX way. This is OK, since # the user is presumably expecting UNIXy behavior. # 2. When CYGWIN exectuables are in the path, but latexmk is run # from a native NT shell. Presumably the user is expecting NT # behavior. But perl behaves more UNIXy. This causes some # clashes. # The issues to handle are: # 1. Perl sees both MSWin32 and cygwin filenames. This is # normally only an advantage. # 2. Perl uses a UNIX shell in the system command # This is a nasty problem: under native NT, there is a # start command that knows about NT file associations, so that # we can do, e.g., (under native NT) system("start file.pdf"); # But this won't work when perl has decided the OS is cygwin, # even if it is invoked from a native NT command line. An # NT command processor must be used to deal with this. # 3. External executables can be native NT (which only know # NT-style file names) or cygwin executables (which normally # know both cygwin UNIX-style file names and NT file names, # but not always; some do not know about drive names, for # example). # Cygwin executables for tex and latex may only know cygwin # filenames. # 4. The BIBINPUTS environment variables may be # UNIX-style or MSWin-style depending on whether native NT or # cygwin executables are used. They are therefore parsed # differently. Here is the clash: # a. If a user is running under an NT shell, is using a # native NT installation of tex (e.g., fptex or miktex), # but has the cygwin executables in the path, then perl # detects the OS as cygwin, but the user needs NT # behavior from latexmk. # b. If a user is running under an UNIX shell in a cygwin # environment, and is using the cygwin installation of # tex, then perl detects the OS as cygwin, and the user # needs UNIX behavior from latexmk. # Latexmk has no way of detecting the difference. The two # situations may even arise for the same user on the same # computer simply by changing the order of directories in the # path environment variable ## Configuration parameters: We'll assume native NT executables. ## The user should override if they are not. # This may fail: perl converts MSWin temp directory name to cygwin # format. Names containing this string cannot be handled by native # NT executables. $tmpdir = $ENV{TMPDIR} || $ENV{TEMP} || '.'; ## List of possibilities for the system-wide initialization file. ## The first one found (if any) is used. ## We could stay with MSWin files here, since cygwin perl understands them ## @rc_system_files = ( 'C:/latexmk/LatexMk', 'C:/latexmk/latexmkrc' ); ## But they are deprecated in v. 1.7. So use the UNIX version, prefixed ## with a cygwin equivalent of the MSWin location ## In addition, we need to add the same set of possible locations as with ## unix, so that the user use a unix-style setup. @rc_system_files = (); foreach ( 'LatexMk', 'latexmkrc' ) { push @rc_system_files, ( "/cygdrive/c/latexmk/$_", "/etc/$_", "/opt/local/share/latexmk/$_", "/usr/local/share/latexmk/$_", "/usr/local/lib/latexmk/$_" ); } $search_path_separator = ';'; # Separator of elements in search_path # This is tricky. The search_path_separator depends on the kind # of executable: native NT v. cygwin. # So the user will have to override this. # We will assume that files can be viewed by native NT programs. # Then we must fix the start command/directive, so that the # NT-native start command of a cmd.exe is used. # For a pdf-file, "start x.pdf" starts the pdf viewer associated with # pdf files, so no program name is needed: $start_NT = "cmd /c start \"\""; $pdf_previewer = "$start_NT %O %S"; $ps_previewer = "$start_NT %O %S"; $ps_previewer_landscape = $ps_previewer; $dvi_previewer = "$start_NT %O %S"; $dvi_previewer_landscape = $dvi_previewer; $hnt_previewer = "$start_NT %O %S"; # Viewer update methods: # 0 => auto update: viewer watches file (e.g., gv) # 1 => manual update: user must do something: e.g., click on window. # (e.g., ghostview, MSWIN previewers, acroread under UNIX) # 2 => send signal. Number of signal in $dvi_update_signal, # $ps_update_signal, $pdf_update_signal # 3 => viewer can't update, because it locks the file and the file # cannot be updated. (acroread under MSWIN) $pdf_update_method = 3; # acroread locks the pdf file } elsif ( $^O eq "msys" ) { $search_path_separator = ';'; # Separator of elements in search_path # I think MS-Win value is OK, since # msys is running under MS-Win $pdf_previewer = q[sh -c 'start %S']; $ps_previewer = q[sh -c 'start %S']; $dvi_previewer = q[sh -c 'start %S']; $hnt_previewer = q[sh -c 'start %S']; $ps_previewer_landscape = $ps_previewer; $dvi_previewer_landscape = "$dvi_previewer"; } else { # Assume anything else is UNIX or clone # Do special cases (e.g., linux, darwin (i.e., OS-X)) inside this block. ## Use first existing case for $tmpdir: $tmpdir = $ENV{TMPDIR} || '/tmp'; ## List of possibilities for the system-wide initialization file. ## The first one found (if any) is used. @rc_system_files = (); foreach ( 'LatexMk', 'latexmkrc' ) { push @rc_system_files, ( "/etc/$_", "/opt/local/share/latexmk/$_", "/usr/local/share/latexmk/$_", "/usr/local/lib/latexmk/$_" ); } $search_path_separator = ':'; # Separator of elements in search_path $dvi_update_signal = $signo{USR1} if ( defined $signo{USR1} ); # Suitable for xdvi $ps_update_signal = $signo{HUP} if ( defined $signo{HUP} ); # Suitable for gv $pdf_update_signal = $signo{HUP} if ( defined $signo{HUP} ); # Suitable for gv ## default document processing programs. # Viewer update methods: # 0 => auto update: viewer watches file (e.g., gv) # 1 => manual update: user must do something: e.g., click on window. # (e.g., ghostview, MSWIN previewers, acroread under UNIX) # 2 => send signal. Number of signal in $dvi_update_signal, # $ps_update_signal, $pdf_update_signal # 3 => viewer can't update, because it locks the file and the file # cannot be updated. (acroread under MSWIN) # 4 => Run command to update. Command in $dvi_update_command, # $ps_update_command, $pdf_update_command. $dvi_previewer = 'start xdvi %O %S'; $dvi_previewer_landscape = 'start xdvi -paper usr %O %S'; if ( defined $dvi_update_signal ) { $dvi_update_method = 2; # xdvi responds to signal to update } else { $dvi_update_method = 1; } # if ( defined $ps_update_signal ) { # $ps_update_method = 2; # gv responds to signal to update # $ps_previewer = 'start gv -nowatch'; # $ps_previewer_landscape = 'start gv -swap -nowatch'; # } else { # $ps_update_method = 0; # gv -watch watches the ps file # $ps_previewer = 'start gv -watch'; # $ps_previewer_landscape = 'start gv -swap -watch'; # } # Turn off the fancy options for gv. Regular gv likes -watch etc # GNU gv likes --watch etc. User must configure $ps_update_method = 0; # gv -watch watches the ps file $ps_previewer = 'start gv %O %S'; $ps_previewer_landscape = 'start gv -swap %O %S'; $pdf_previewer = 'start acroread %O %S'; $pdf_update_method = 1; # acroread under unix needs manual update $lpr = 'lpr %O %S'; # Assume lpr command prints postscript files correctly $lpr_dvi = 'NONE $lpr_dvi variable is not configured to allow printing of dvi files'; $lpr_pdf = 'NONE $lpr_pdf variable is not configured to allow printing of pdf files'; # The $pscmd below holds a command to list running processes. It # is used to find the process ID of the viewer looking at the # current output file. The output of the command must include the # process number and the command line of the processes, since the # relevant process is identified by the name of file to be viewed. # Uses: # 1. In preview_continuous mode, to save running a previewer # when one is already running on the relevant file. # 2. With xdvi in preview_continuous mode, xdvi must be # signalled to make it read a new dvi file. # # The following works on Solaris, LINUX, HP-UX, IRIX # Use -f to get full listing, including command line arguments. # Use -u $ENV{USER} to get all processes started by current user (not just # those associated with current terminal), but none of other users' # processes. # However, the USER environment variable may not exist. Windows uses # USERNAME instead. (And this propagates to a situation of # unix-emulation software running under Windows.) if ( exists $ENV{USER} ) { $pscmd = "ps -f -u $ENV{USER}"; } elsif ( exists $ENV{USERNAME} ) { $pscmd = "ps -f -u $ENV{USERNAME}"; } else { $pscmd = "ps -f"; } $pid_position = 1; # offset of PID in output of pscmd; first item is 0. if ( $^O eq "linux" ) { # Ps on Redhat (at least v. 7.2) appears to truncate its output # at 80 cols, so that a long command string is truncated. # Fix this with the --width option. This option works under # other versions of linux even if not necessary (at least # for SUSE 7.2). # However the option is not available under other UNIX-type # systems, e.g., Solaris 8. # But (19 Aug 2010), the truncation doesn't happen on RHEL4 and 5, # unless the output is written to a terminal. So the --width # option is now unnecessary # $pscmd = "ps --width 200 -f -u $ENV{USER}"; } elsif ( $^O eq "darwin" ) { # OS-X on Macintosh # open starts command associated with a file. # For pdf, this is set by default to OS-X's preview, which is suitable. # Manual update is simply by clicking on window etc, which is OK. # For ps, this is set also to preview. This works, but since it # converts the file to pdf and views the pdf file, it doesn't # see updates, and a refresh cannot be done. This is far from # optimal. # For a full installation of MacTeX, which is probably the most common # on OS-X, an association is created between dvi files and TeXShop. # This also converts the file to pdf, so again while it works, it # does not deal with changed dvi files, as far as I can see. $pdf_previewer = 'open %S'; $pdf_update_method = 1; # manual $hnt_previewer = 'open %S'; $hnt_update_method = 1; # manual $dvi_previewer = $dvi_previewer_landscape = 'NONE'; $ps_previewer = $ps_previewer_landscape = 'NONE'; # Others $lpr_pdf = 'lpr %O %S'; $pscmd = "ps -ww -u $ENV{USER}"; } } ## default parameters our $auto_rc_use = 1; # Whether to read rc files automatically our $user_deleted_file_treated_as_changed = 0; # Whether when testing for changed # files, a user file that changes status from existing # to non-existing should be regarded as changed. # Value 1: only in non-preview-continuous mode. # Value 2: always. # Primary purpose is to cover cases where behavior of # compilation of .tex file tests for file existence and # adjusts behavior accordingly, instead of simply giving an # error. our $max_repeat = 5; # Maximum times I repeat latex. Normally # 3 would be sufficient: 1st run generates aux file, # 2nd run picks up aux file, and maybe toc, lof which # contain out-of-date information, e.g., wrong page # references in toc, lof and index, and unresolved # references in the middle of lines. But the # formatting is more-or-less correct. On the 3rd # run, the page refs etc in toc, lof, etc are about # correct, but some slight formatting changes may # occur, which mess up page numbers in the toc and lof, # Hence a 4th run is conceivably necessary. # At least one document class (JHEP.cls) works # in such a way that a 4th run is needed. # We allow an extra run for safety for a # maximum of 5. Needing further runs is # usually an indication of a problem; further # runs may not resolve the problem, and # instead could cause an infinite loop. our @cus_dep_list = (); # Custom dependency list our @default_files = ( '*.tex' ); # Array of LaTeX files to process when # no files are specified on the command line. # Wildcards allowed # Best used for project specific files. our @default_excluded_files = ( ); # Array of LaTeX files to exclude when using # @default_files, i.e., when no files are specified # on the command line. # Wildcards allowed # Best used for project specific files. our $texfile_search = ""; # Specification for extra files to search for # when no files are specified on the command line # and the @default_files variable is empty. # Space separated, and wildcards allowed. # These files are IN ADDITION to *.tex in current # directory. # This variable is obsolete, and only in here for # backward compatibility. our $jobname = ''; # Jobname: as with current tex, etc indicates # basename of generated files. Defined so # that --jobname=STRING on latexmk's command # line has same effect as with current tex, # etc, with the exception listed below. (If # $jobname is non-empty, then the # --jobname=... option is used on tex.) # Extension: $jobname is allowed to contain # placeholder(s) (currently only %A), # which allows construction of jobnames # dependent on name of main TeX file; this is # useful when a jobname is used and latexmk is # invoked on multiple files. our $out2_dir = ''; # Directory for final output files. our $out_dir = ''; # Directory for output files. # Cf. --output-directory of current *latex # Blank means default, i.e., cwd. our $aux_dir = ''; # Directory for aux files (log, aux, etc). # Cf. --aux-directory of current *latex in MiKTeX. # Blank means default, i.e., same as $out_dir. # Note that these values get modified when # processing a .tex file. # Corresponding forms that can be concatenated (e.g., when $aux_dir is '.', $aux_dir1 is './'). our $aux_dir1 = ''; our $out_dir1 = ''; our $out2_dir1 = ''; # Use the following for saving original values, before directories are normalized. our ( $aux_dir_requested, $out_dir_requested, $out2_dir_requested ); # Extensions for files to be copied to $out2_dir. # Specify as for @generated_exts: I.e., extension w/o period # or string including %R to be substituted by basename. our @out2_exts = ( 'hnt', 'pdf', 'ps', 'synctex', 'synctex.gz' ); ## default flag settings. our $recorder = 1; # Whether to use recorder option on latex/pdflatex our $silent = 0; # Whether fo silence latex's messages (and others) our $warnings_as_errors = 0;# Treat warnings as errors and exit with non-zero exit code our $silence_logfile_warnings = 0; # Do list warnings in log file # The warnings reported are those about undefined refs # and citations, and the like. our $max_logfile_warnings = 7; # Max. # number of log file warnings to report our $rc_report = 1; # Whether to report on rc files read our $aux_out_dir_report = 0; # Whether to report on aux_dir & out_dir after # initialization and normalization. # When $aux_out_dir_report is set to 2, latexmk # does no further processing after the report of # the aux and out directories. our $report_cwd_mismatch = 0; # Whether to report mismatch of name of cwd # between report by .fls and from Perl. our $kpsewhich_show = 0; # Show calls to and results from kpsewhich our $analyze_input_log_always = 1; # Always analyze .log for input files in the # <...> and (...) constructions. Otherwise, only # do the analysis when fls file doesn't exist or is # out of date. # Under normal circumstances, the data in the fls file # is reliable, and the test of the log file gets lots # of false positives; usually $analyze_input_log_always # is best set to zero. But the test of the log file # is needed at least in the following situation: # When a user needs to persuade latexmk that a certain # file is a source file, and latexmk doesn't otherwise # find it. User code causes line with (...) to be # written to log file. One important case is for # lualatex, which doesn't always generate lines in the # .fls file for input lua files. (The situation with # lualatex is HIGHLY version dependent, e.g., between # 2016 and 2017.) # To keep backward compatibility with older versions # of latexmk, the default is to set # $analyze_input_log_always to 1. our $fls_uses_out_dir = 0; # Whether fls file is to be in out directory (as with # pre-Oct-2020 MiKTeX), or in aux directory (as with # newer versions of MiKTeX). # If the implementation of *latex puts the fls file in # the other directory, I will copy it to the directory # I am configured to use. # Which kinds of file do I have requests to make? our ($dvi_mode, $hnt_mode, $pdf_mode, $postscript_mode, $xdv_mode, $landscape_mode ); # If no requests at all are made, then I will make dvi file # If particular requests are made then other files may also have to be # made. E.g., ps file requires a dvi file $dvi_mode = 0; # No dvi file requested. # Possible values: # 0: no request for dvi file # 1: use latex to make dvi file # 2: use dvilualatex to make dvi file $hnt_mode = 0; # No hnt file requested $postscript_mode = 0; # No postscript file requested $pdf_mode = 0; # No pdf file requested to be made by pdflatex # Possible values: # 0 don't create pdf file # 1 to create pdf file by pdflatex # 2 to create pdf file by compile-to-dvi+dvips+ps2pdf # 3 to create pdf file by compile-to-dvi+dvipdf # 4 to create pdf file by lualatex # 5 to create pdf file by xelatex + xdvipdfmx $xdv_mode = 0; # No xdv file requested $landscape_mode = 0; # default to portrait mode our $view = 'default'; # Default preview is of highest of dvi, ps, pdf our $min_sleep_time = 0.01; # Minimum non-zero sleep time our $sleep_time = 2; # time to sleep b/w checks for file changes in -pvc mode # The following banner variables are no longer used by latexmk itself # (since v. 3.21) . They are left here for backward compatibility, in # case any user configurations use them. our $banner = 0; # Non-zero if we have a banner to insert our $banner_scale = 220; # Original default scale our $banner_intensity = 0.95; # Darkness of the banner message our $banner_message = 'DRAFT'; # Original default message our $do_cd = 0; # Do not do cd to directory of source file. # Thus behave like latex. our $dependents_list = 0; # Whether to display list(s) of dependencies our $dependents_phony = 0; # Whether list(s) of dependencies includes phony targets # (as with 'gcc -MP'). our $deps_file = '-'; # File for dependency list output. Default stdout. our $rules_list = 0; # Whether to display list(s) of dependencies # Kind of escaping in names of files written to deps file. our $deps_escape = 'none'; # Allowed kinds of escape: our %deps_escape_kinds = ( 'none' => ' ', 'unix' => '\ ', 'nmake' => '^ '); our @dir_stack = (); # Stack of pushed directories, each of form of # pointer to array [ cwd, good_cwd ], where # good_cwd differs from cwd by being converted # to native MSWin path when cygwin is used. our $cleanup_mode = 0; # No cleanup of nonessential LaTex-related files. # $cleanup_mode = 0: no cleanup # $cleanup_mode = 1: full cleanup # $cleanup_mode = 2: cleanup except for dvi, # dviF, pdf, ps, psF & xdv our $cleanup_fdb = 0; # On normal run, no removal of file for latexmk's file-database our $cleanup_only = 0; # When doing cleanup, do not go on to making files our $cleanup_includes_generated = 0; # Determines whether cleanup deletes files generated by # *latex (found from \openout lines in log file). # It's more than that. BUG our $cleanup_includes_cusdep_generated = 0; # Determines whether cleanup deletes files generated by # custom dependencies our $diagnostics = 0; our $dvi_filter = ''; # DVI filter command our $ps_filter = ''; # Postscript filter command our $force_mode = 0; # =1: to force processing past errors our $go_mode = 0; # =1: to force processing regardless of time-stamps # =2: full clean-up first # =3: Just force primary rule(s) to run our $preview_mode = 0; our $preview_continuous_mode = 0; our $printout_mode = 0; # Don't print the file ## Control pvc inactivity timeout: our $pvc_timeout = 0; our $pvc_timeout_mins = 30; # Timing information # Whether to report processing time: our $show_time = 0; # Whether times computed are clock times (HiRes) since Epoch, or are # processing times for this process and child processes, as reported by # times(). Second is the best, if accurate. But on MSWin32, times() # appears not to include subprocess times, so we use clock time instead. our $times_are_clock = ($^O eq "MSWin32" ? 1 : 0); # Data for 1 run and global (ending in '0'): our ( $clock1, $processing_time1, $processing_time0, @timings1, @timings0); &init_timing_all; our $use_make_for_missing_files = 0; # Whether to use make to try to make missing files. # Do we make view file in temporary then move to final destination? # (To avoid premature updating by viewer). our $always_view_file_via_temporary = 0; # Set to 1 if viewed file is always # made through a temporary. our $pvc_view_file_via_temporary = 1; # Set to 1 if only in -pvc mode is viewed # file made through a temporary. # State variables initialized here: our $updated = 0; # Flags whether something has been remade in this round # of compilation. our $failure = 0; # Set nonzero to indicate failure at some point of # a make. Use value as exit code if I exit. our $failure_msg = ''; # Indicate reason for failure our $waiting = 0; # Flags whether we are in loop waiting for an event # Used to avoid unnecessary repeated o/p in wait loop # The following are used for some results of parsing log file # Global variables, so results can be reported in main program. our $reference_changed = 0; our $mult_defined = 0; our $bad_reference = 0; our $bad_character = 0; our $bad_citation = 0; our @primary_warning_summary = (); # Cache of expensive-to-compute state variables, e.g., cwd in form # fixed to deal with cygwin issues. our %cache = (); &cache_good_cwd; # Set search paths for includes. # Set them early so that they can be overridden our $BIBINPUTS = $ENV{'BIBINPUTS'}; if (!$BIBINPUTS) { $BIBINPUTS = '.'; } # ???!!! # Old configuration variable @BIBINPUTS to be equivalent to environment # variable BIBINPUTS. It was to be easier to work with inside latexmk. But # under present conditions, it's better to manipulate $ENV{BIBINPUTS}. # ??? Need to explain better. # Why only for BIBINPUTS, not TEXINPUTS. # # But retain @BIBINPUTS for backward compatibility, since users may have # configured it. We'll save the values, allow for possible user changes in # @BIBINPUTS or $ENV{BIBINPUTS} in rc files and from command line # arguments. Then funnel changes back to $ENV{BIBINPUTS}, ... # # Convert search paths to arrays: # If any of the paths end in '//' then recursively search the # directory. After these operations, @BIBINPUTS should # have all the directories that need to be searched # our @BIBINPUTS = find_dirs1( $BIBINPUTS ); our @BIBINPUTS_SAVE = @BIBINPUTS; our $BIBINPUTS_ENV_SAVE = $ENV{BIBINPUTS}; ###################################################################### ###################################################################### # # ??? UPDATE THE FOLLOWING!! # # We will need to determine whether source files for runs of various # programs are out of date. In a normal situation, this is done by # asking whether the times of the source files are later than the # destination files. But this won't work for us, since a common # situation is that a file is written on one run of latex, for # example, and read back in on the next run (e.g., an .aux file). # Some situations of this kind are standard in latex generally; others # occur with particular macro packages or with particular # postprocessors. # # The correct criterion for whether a source is out-of-date is # therefore NOT that its modification time is later than the # destination file, but whether the contents of the source file have # changed since the last successful run. This also handles the case # that the user undoes some changes to a source file by replacing the # source file by reverting to an earlier version, which may well have # an older time stamp. Since a direct comparison of old and new files # would involve storage and access of a large number of backup files, # we instead use the md5 signature of the files. (Previous versions # of latexmk used the backup file method, but restricted to the case # of .aux and .idx files, sufficient for most, but not all, # situations.) # # We will have a database of (time, size, md5) for the relevant # files. If the time and size of a file haven't changed, then the file # is assumed not to have changed; this saves us from having to # determine its md5 signature, which would involve reading the whole # file, which is naturally time-consuming, especially if network file # access to a server is needed, and many files are involved, when most # of them don't change. It is of course possible to change a file # without changing its size, but then to adjust its timestamp # to what it was previously; this requires a certain amount of # perversity. We can safely assume that if the user edits a file or # changes its contents, then the file's timestamp changes. The # interesting case is that the timestamp does change, because the file # has actually been written to, but that the contents do not change; # it is for this that we use the md5 signature. However, since # computing the md5 signature involves reading the whole file, which # may be large, we should avoid computing it more than necessary. # # So we get the following structure: # # 1. For each relevant run (latex, pdflatex, each instance of a # custom dependency) we have a database of the state of the # source files that were last used by the run. # 2. On an initial startup, the database for a primary tex file # is read that was created by a previous run of latex or # pdflatex, if this exists. # 3. If the file doesn't exist, then the criterion for # out-of-dateness for an initial run is that it goes by file # timestamps, as in previous versions of latexmk, with due # (dis)regard to those files that are known to be generated by # latex and re-read on the next run. # 4. Immediately before a run, the database is updated to # represent the current conditions of the run's source files. # 5. After the run, it is determined whether any of the source # files have changed. This covers both files written by the # run, which are therefore in a dependency loop, and files that # the user may have updated during the run. (The last often # happens when latex takes a long time, for a big document, # and the user makes edits before latex has finished. This is # particularly prevalent when latexmk is used with # preview-continuous mode.) # 6. In the case of latex or pdflatex, the custom dependencies # must also be checked and redone if out-of-date. # 7. If any source files have changed, the run is redone, # starting at step 1. # 8. There is naturally a limit on the number of reruns, to avoid # infinite loops from bugs and from pathological or unforeseen # conditions. # 9. After the run is done, the run's file database is updated. # (By hypothesis, the sizes and md5s are correct, if the run # is successful.) # 10. To allow reuse of data from previous runs, the file database # is written to a file after every complete set of passes # through latex or pdflatex. (Note that there is separate # information for latex and pdflatex; the necessary # information won't coincide: Out-of-dateness for the files # for each program concerns the properties of the files when # the other program was run, and the set of source files could # be different, e.g., for graphics files.) # # We therefore maintain the following data structures.: # # a. For each run (latex, pdflatex, each custom dependency) a # database is maintained. This is a hash from filenames to a # reference to an array: [time, size, md5]. The semantics of # the database is that it represents the state of the source # files used in the run. During a run it represents the state # immediately before the run; after a run, with all reruns, it # represents the state of the files used, modified by having # the latest timestamps for generated files. # b. There is a global database for all files, which represents # the current state. This saves having to recompute the md5 # signatures of a changed file used in more than one run # (e.g., latex and pdflatex). # c. Each of latex and pdflatex has a list of the relevant custom # dependencies. # # In all the following a fdb-hash is a hash of the form: # filename -> [time, size, md5] # If a file is found to disappear, its entry is removed from the hash. # In returns from fdb access routines, a size entry of -1 indicates a # non-existent file. # Hashes, whose keys give names of particular kinds of rule, and targets. # We use hashes for ease of lookup. our %possible_one_time = ( 'view' => 1, 'print' => 1, 'update_view' => 1, ); our %target_files = (); # Hash for target files. # The keys are the filenames and the value is # currently irrelevant. our %target_rules = (); # Hash for target rules beyond those corresponding to files. # The keys are the rule names and the value is # currently irrelevant. # The target **files** can only be set inside the FILE loop. our $current_primary = 'latex';# Rule to compile .tex file. # It will be overridden at rule-initialization time, and # is subject to document-dependent override if .tex document # uses metcommands and obeying them is implemented/enabled. our $pdf_method = ''; # How to make pdf file. '' if not requested, # else 'ps2pdf', 'dvipdf', 'pdflatex', 'lualatex' or 'xelatex' # Subject to document-dependent override if .tex document #uses \pdfoutput or c. our %requested_filetypes = (); # Hash of requested file types (dvi, dviF, etc) our %one_time = (); # Hash for requested one-time-only rules, currently # possible values 'print' and 'view'. our %actives = (); # Hash of active rules our $allow_switch = 1; # Allow switch of rule structure to accommodate # changed output file name of primary. Even if # this flag is set on, the switch may be # prohibited by other issues. our %rule_db = (); # Database of all rules: # Hash: rulename -> [array of rule data] # Rule data: # 0: [ cmd_type, ext_cmd, int_cmd, no_history, # source, dest, base, # out_of_date, out_of_date_user, # time_of_last_run, time_of_last_file_check, # changed # last_result, last_result_info, last_message, # default_extra_generated, # ] # where # cmd_type is 'primary', 'external', or 'cusdep' # ext_cmd is string for associated external command # with substitutions (%D for destination, %S # for source, %B for base of current rule, # %R for base of primary tex file, %T for # texfile name, %O for options, # %V=$aux_dir, %W=$out_dir, # %X for $out2_dir1 # %Y for $aux_dir1, and %Z for $out_dir1 # int_cmd specifies any internal command to be # used to implement the application of the # rule. If this is present, it overrides # **direct** execution of the external command, and # it is the responsibility of the perl subroutine # specified in intcmd to execute the specified # external command if this is appropriate. # This variable intcmd is a reference to an array, # $$intcmd[0] = internal routine # $$intcmd[1...] = its arguments (if any) # no_history being true indicates that there was no # data on the file state from a previous run. In # this case the implication is that when the next # test for whether a run of the rule is needed, # the file-contents criterion won't be useful. # Then a time-based criterion (as in normal make) # is used, i.e., if a source file is newer than # the destination file, then a rerun is needed. # After that first test for a rerun has been # done, a run or no run is made according as # appropriate. After that the file-change # criterion works, and no_history is turned off. # source = name of primary source file, if any # dest = name of primary destination file, # if any # base = base name, if any, of files for # this rule # out_of_date = 1 if it has been detected that # this rule needs to be run # (typically because a source # file has changed). # Other values may be used for special cases. # 0 otherwise # out_of_date_user is like out_of_date, except # that the detection of out-of-dateness # has been made from a change of a # putative user file, i.e., one that is # not a generated file (e.g., aux). This # kind of out-of-dateness should provoke a # rerun whether or not there was an error # during a run of *LaTeX. Normally, # if there is an error, one should wait # for the user to correct the error. But # it is possible the error condition is # already corrected during the run, e.g., # by the user changing a source file in # response to an error message. # time_of_last_run = time that this rule was # last applied. (In standard units # from perl, to be directly compared # with file modification times.) # time_of_last_file_check = last time that a check # was made for changes in source files. # changed flags whether special changes have been made # that require file-existence status to be ignored # last_result is # -1 if no run has been made # 0 if the last run was successful # 1 if last run was successful, but # failed to create an output file # 2 if last run failed # 200 if last run gave a warning that is # important enough to be reported with # the error summary. The warning # message is stored in last_message. # last_result_info is info about run that gave # code in last_result. Currently used values: # '' No record of this rule being run # 'CURR' Run of rule was in current # round of compilation. # 'PREV' Run of rule was in a previous # round of compilation (as with # -pvc), but in current invocation # of latexmk. # 'CACHE' Run of rule was in a previous # invocation of latexmk, with # last_result having been read # from fdb_latexmk file. # last_message is error message for last run # default_extra_generated is a reference to an array # of specifications of extra generated files (beyond # the main dest file. Standard place holders are used. # 1: {Hash sourcefile -> [source-file data] } # Source-file data array: # 0: time # 1: size # 2: md5 # 3: DUMMY. Not used any more. ?? Lots of code depends # on array structure, Let's not change things now. # 4: whether the file is of the kind made by epstopdf.sty # during a primary run. It will have been read during # the run, so that even though the file changes during # a primary run, there is no need to trigger another # run because of this. # Size and md5 correspond to the values at the last run. # But time may be updated to correspond to the time # for the file, if the file is otherwise unchanged. # This saves excessive md5 calculations, which would # otherwise be done everytime the file is checked, # in the following situation: # When the file has been rewritten after a run # has started (commonly aux, bbl files etc), # but the actual file contents haven't # changed. Then because the filetime has # changed, on every file-change check latexmk # would normally redo the md5 calculation to # test for actual changes. Once one such # check is done, and the contents are # unchanged, later checks are superfluous, and # can be avoided by changing the file's time # in the source-file list. # 2: {Hash generated_file -> 1 } # This lists all generated files. # The values for the hash are currently unused, only the keys. # 3: {Hash rewritten_before_read_file -> 1 } # This lists all files that are only read after being # written **and** that existed before being # written, i.e., that existed at the beginning of # the run. These are listed in both the source- # and generated-file hashes, but do not need # to be checked for changes in testing whether # another run is needed, i.e., they aren't true # source files. **IMPORTANT NOTE:** If a file is # read only after being written, but the file didn't # exist at the beginning of the run, it is # possible (and often true) that on a subsequent # run the file would be read, then written, and # perhaps read again. That is, it can be that # before the file is written, there is a test for # file existence, and the file is read, but only # if it exists. Examples: .aux and .toc # files. Such files are true dependencies and must # be checked for changes. Only when the file # existed at the start of the run and was then # written before being read, do we know that # write-before-read shows that the file is not a # true source-dependency. # This issue is significant: under some situations, # like the use of latexmk and tex4ht, the file may # be changed by other software before the next run # of the current rule. That must not trigger # another run. # The values for the hash are currently unused, only the keys. # (Some packages that exhibit the # rewrite-before-read behavior: pythontex, showexpl.) # 4: {Hash source_rule -> last_pass } # This lists rules that are to be considered source # rules for the current rule, separately from the # source_rules of the source files. Its main use # (the only one at present) is when the list of # known source files, at item 1, is/may be # incomplete. This is notably the case for rules # applied to dvi and xdv files when graphics files # are involved. Their names are coded inside the # dvi/xdv file, but not the contents. It would # need parsing of the contents of the file to # determine the actual source files. In the case # of rules that process dvi and xdv files, the # source_rule is the *latex rule that generates # the dvi or xdv file. # # In determining whether a rerun of the current # rule is needed at some stage in a round of # compilation, the following is added to the # basic source-file-change criterion. # The value that a source rule in this hash maps # to is its pass number when the current rule was # last run. The current rule is flagged # out-of-date if the saved last_pass for a source # rule is less than the current pass number for # that source rule (as known to the compilation # process). # An implication of using a source_rule in this # way is that the source_rule passes files (or # other information) to the current rule, and that # the current rule is to be rerun whenever the # source_rule has been run. # 5: {Hash keys -> values} # Used for any extra information needed for a specific # rule. The first one I'll set up is for cached # datasource information for the biber rule. The # key is 'bcf_datasources', and the value is a # reference to a hash mapping filename # specifications in the bcf file to actual files # (if found). # The aim of this item is for flexible # rule-dependent add-ons. our %fdb_current = (); # Hash of information for all files used. # It maps filename to a reference to an array # (time, size, md5_checksum). our @nofile = (0,-1,0); # What we use for initializing a new entry in fdb # or flagging non-existent file. # The following are variables which are set by the routine rdb_set_rule_net. # They are **derived** from information in %rule_db, and provide information # about the structure of the network of rules and files. This derived # information is in a form useful for using the network of rules. # For recursing backwards through the network of rules: our %from_rules = (); # This maps file names to rule names. # $from_rules{'File'} is the name of the rule that # generates file 'File'. If there is no rule to # generate the file, then $from_rules{'File'} is # not defined (or possibly the null string ''). # Classification of rules, for determining order of application our @pre_primary = (); # Array of rules that are thought of as pre-primary, # Should be in an appropriate order for invoking # them, to optimize making. our @post_primary = (); # Array of rules that are thought of as post-primary. # In suitable order for invocation our @unusual_one_time = ();# Array of rules that are special cases of # one-time rules. # Currently not used. # Variables set in applying rules: our ($rule, $PA_extra_gen, $PAint_cmd, $PArule_data, $Pbase, $Pchanged, $Pcheck_time, $Pcmd_type, $Pdest, $Pext_cmd, $PHdest, $PHextra, $PHrewritten_before_read, $PHsource, $PHsource_rules, $Plast_message, $Plast_result, $Plast_result_info, $Pno_history, $Pout_of_date, $Pout_of_date_user, $Prun_time, $Psource, $file, $PAfile_data, $Ptime, $Psize, $Pmd5, $DUMMY, $Pcorrect_after_primary ); # User's home directory our $HOME = ''; if (exists $ENV{'HOME'} ) { $HOME = $ENV{'HOME'}; } elsif (exists $ENV{'USERPROFILE'} ) { $HOME = $ENV{'USERPROFILE'}; } # XDG configuration home our $XDG_CONFIG_HOME = ''; if (exists $ENV{'XDG_CONFIG_HOME'} ) { $XDG_CONFIG_HOME = $ENV{'XDG_CONFIG_HOME'}; } elsif ($HOME ne '') { if ( -d "$HOME/.config") { $XDG_CONFIG_HOME = "$HOME/.config"; } } #================================================== # Which rc files did I read? our @rc_files_read = (); # In order of reading our %rc_files_read2 = (); # Map **abs** filename to 1; used to check duplicate reads. # Options that are to be obeyed before rc files are read: # Also under MSWin32 and msys, CL arguments sometimes get quotes in them. # (Specific example: TeXLive 2023 with msys's perl and arguments containing # both non-ASCII character, when latexmk.exe invoked from cmd.exe. In some # other situations (powershell and msys's terminal+bash), it seems that both # space and non-ASCII character are needed to trigger a problem.) # Recently (June 2025), I've not been able to reproduce this. foreach $_ ( @ARGV ) { if ( ($^O eq "MSWin32") || ($^O eq 'msys') ) { # "arg" -> arg. # -..="arg" -> -..=arg. # In both cases, only do this if there are no other ". Otherwise I # my run afoul of " that are intended to be there. s/^\"([^\"]+)\"$/$1/; s/^(-[^\"=]+=)\"([^\"]+)\"$/$1$2/; } if (/^-{1,2}norc$/ ) { $auto_rc_use = 0; } } #================================================== ## Read rc files with this subroutine sub read_first_rc_file_in_list { foreach my $rc_file ( @_ ) { if ( -d $rc_file ) { warn "$My_name: I have found a DIRECTORY named \"$rc_file\".\n", " Have you perhaps misunderstood latexmk's documentation?\n", " This name is normally used for a latexmk configuration (rc) file,\n", " and in that case it should be a regular text file, not a directory.\n"; } elsif ( -e $rc_file ) { process_rc_file( $rc_file ); return; } } } # Note that each rc file may unset $auto_rc_use to # prevent lower-level rc files from being read. # So test on $auto_rc_use in each case. if ( $auto_rc_use ) { # System rc file: if (exists $ENV{LATEXMKRCSYS} ) { unshift @rc_system_files, $ENV{LATEXMKRCSYS}; if ( !-e $ENV{LATEXMKRCSYS} ) { warn "$My_name: you've specified a system rc file `$ENV{LATEXMKRCSYS}`\n", " in environment variable LATEXMKRCSYS, but the file doesn't exist.\n", " I won't read any system rc file.\n"; } else { process_rc_file( $ENV{LATEXMKRCSYS} ); } } else { read_first_rc_file_in_list( @rc_system_files ); } } if ( $auto_rc_use && ($HOME ne "" ) ) { # User rc file: my @user_rc = (); if ( $XDG_CONFIG_HOME ) { push @user_rc, "$XDG_CONFIG_HOME/latexmk/latexmkrc"; } # N.B. $HOME equals "" if latexmk couldn't determine a home directory. # In that case, we shouldn't look for an rc file there. if ( $HOME ) { push @user_rc, "$HOME/.latexmkrc"; } read_first_rc_file_in_list( @user_rc ); } if ( $auto_rc_use ) { # Rc file in current directory: read_first_rc_file_in_list( ".latexmkrc", "latexmkrc" ); } ## Process command line args. our @command_line_file_list = (); our $bad_options = 0; while (defined(local $_ = $ARGV[0])) { # Make -- and - equivalent at beginning of option, # but save original for possible use in *latex command line my $original = $_; s/^--/-/; shift; if ( /^-aux-directory=(.*)$/ || /^-auxdir=(.*)$/ ) { $aux_dir = $1; } elsif (/^-bib(tex|)fudge$/) { $bibtex_fudge = 1; } elsif (/^-bib(tex|)fudge-$/) { $bibtex_fudge = 0; } elsif (/^-bibtex$/) { $bibtex_use = 2; } elsif (/^-bibtex-$/) { $bibtex_use = 0; } elsif (/^-nobibtex$/) { $bibtex_use = 0; } elsif (/^-bibtex-cond$/) { $bibtex_use = 1; } elsif (/^-bibtex-cond1$/) { $bibtex_use = 1.5; } elsif (/^-c$/) { $cleanup_mode = 2; $cleanup_only = 1; } elsif (/^-C$/ || /^-CA$/ ) { $cleanup_mode = 1; $cleanup_only = 1; } elsif (/^-CF$/) { $cleanup_fdb = 1; } elsif (/^-cd$/) { $do_cd = 1; } elsif (/^-cd-$/) { $do_cd = 0; } elsif (/^-commands$/) { &print_commands; exit; } elsif (/^-d$/) { warn "$My_name: Option -d is no longer used by latexmk.\n"; $banner = 1; } elsif (/^-dependents$/ || /^-deps$/ || /^-M$/ ) { $dependents_list = 1; } elsif (/^-nodependents$/ || /^-dependents-$/ || /^-deps-$/) { $dependents_list = 0; } elsif (/^-deps-escape=(.*)$/) { if ( $deps_escape_kinds{$1} ) { $deps_escape = $1; } else { warn "$My_name: In '$_', kind of escape is not one of those I know, which are\n", " ", join( ' ', sort( keys %deps_escape_kinds )), "\n"; } } elsif (/^-deps-out=(.*)$/) { $deps_file = $1; $dependents_list = 1; } elsif (/^-diagnostics/) { $diagnostics = 1; } elsif (/^-dir-report-only$/) { $aux_out_dir_report = 2; } elsif (/^-dir-report$/) { $aux_out_dir_report = 1; } elsif (/^-dir-report-$/) { $aux_out_dir_report = 0; } elsif (/^-dvi$/) { $dvi_mode = 1; $hnt_mode = $xdv_mode = 0; # Postscript mode OK if ( ($pdf_mode != 2) && ($pdf_mode != 3) ) { # if pdf_mode is not via dvi or ps, turn it off $pdf_mode = 0; } } elsif (/^-dvilua$/) { $dvi_mode = 2; $hnt_mode = $xdv_mode = 0; # Postscript mode OK if ( ($pdf_mode != 2) && ($pdf_mode != 3) ) { # if pdf_mode is not via dvi or ps, turn it off $pdf_mode = 0; } } elsif (/^-dvi-$/) { $dvi_mode = 0; } elsif ( /^-dvilualatex=(.*)$/ ) { $dvilualatex = $1; } elsif (/^-emulate-aux-dir$/) { $emulate_aux = 1; } elsif (/^-emulate-aux-dir-$/) { $emulate_aux = 0; } elsif (/^-f$/) { $force_mode = 1; } elsif (/^-f-$/) { $force_mode = 0; } elsif (/^-g$/) { $go_mode = 1; } elsif (/^-g-$/) { $go_mode = 0; } elsif (/^-gg$/) { $go_mode = 2; } elsif (/^-gt$/) { $go_mode = 3; } elsif ( /^-h$/ || /^-help$/ ) { &print_help; exit;} elsif (/^-hnt$/) { $hnt_mode = 1; $dvi_mode = $postscript_mode = $pdf_mode = $xdv_mode = 0; } elsif (/^-jobname=(.*)$/) { $jobname = $1; } elsif (/^-l$/) { $landscape_mode = 1; } elsif (/^-l-$/) { $landscape_mode = 0; } elsif ( /^-latex$/ ) { $dvi_mode = 1; $hnt_mode = $postscript_mode = $xdv_mode = 0; # Postscript mode OK if ( ($pdf_mode != 2) && ($pdf_mode != 3) ) { # if pdf_mode is not via dvi or ps, turn it off $pdf_mode = 0; } } elsif (/^-latex=(.*)$/) { $latex = $1; } elsif (/^-latexoption=(.*)$/) { push @extra_dvilualatex_options, $1; push @extra_latex_options, $1; push @extra_pdflatex_options, $1; push @extra_lualatex_options, $1; push @extra_xelatex_options, $1; } elsif ( /^-logfilewarninglist$/ || /^-logfilewarnings$/ ) { $silence_logfile_warnings = 0; } elsif ( /^-logfilewarninglist-$/ || /^-logfilewarnings-$/ ) { $silence_logfile_warnings = 1; } elsif ( /^-lualatex$/ || /^-pdflualatex$/ ) { $pdf_mode = 4; $dvi_mode = $hnt_mode = $postscript_mode = $xdv_mode = 0; } # See below for -lualatex=... # See above for -M elsif (/^-MF$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No file name specified after -MF switch"); } $deps_file = $ARGV[0]; shift; } elsif ( /^-MP$/ ) { $dependents_phony = 1; } elsif (/^-(make|)indexfudge$/) { $makeindex_fudge = 1; } elsif (/^-(make|)indexfudge-$/) { $makeindex_fudge = 0; } elsif ( /-MSWinBackSlash$/ ) { $MSWin_back_slash = 1; } elsif ( /-MSWinBackSlash-$/ ) { $MSWin_back_slash = 0; } elsif (/^-new-viewer$/) { $new_viewer_always = 1; } elsif (/^-new-viewer-$/) { $new_viewer_always = 0; } elsif (/^-norc$/ ) { $auto_rc_use = 0; # N.B. This has already been obeyed. } elsif (/^-nobib(tex|)fudge$/) { $bibtex_fudge = 0; } elsif (/^-noemulate-aux-dir$/) { $emulate_aux = 0; } elsif (/^-no(make|)indexfudge$/) { $makeindex_fudge = 0; } elsif ( /^-output-directory=(.*)$/ ||/^-outdir=(.*)$/ ) { $out_dir = $1; } elsif ( /^-out2dir=(.*)$/ ) { $out2_dir = $1; } elsif ( /^-output-format=(.*)$/ ) { my $format = $1; if ($format eq 'dvi' ) { $dvi_mode = 1; $hnt_mode = $xdv_mode = 0; # Postscript mode OK if ( ($pdf_mode != 2) && ($pdf_mode != 3) ) { # if pdf_mode is not via dvi or ps, turn it off $pdf_mode = 0; } } elsif ($format eq 'pdf' ) { $pdf_mode = 1; $dvi_mode = $hnt_mode = $postscript_mode = $xdv_mode = 0; } else { warn "$My_name: unknown format in option '$_'\n"; $bad_options++; } } elsif (/^-p$/) { $printout_mode = 1; $preview_continuous_mode = 0; # to avoid conflicts $preview_mode = 0; } elsif (/^-p-$/) { $printout_mode = 0; } elsif (/^-pdf$/) { $pdf_mode = 1; $dvi_mode = $hnt_mode = $postscript_mode = $xdv_mode = 0; } elsif (/^-pdf-$/) { $pdf_mode = 0; } elsif (/^-pdfdvi$/){ $pdf_mode = 3; $hnt_mode = $xdv_mode = 0; } elsif (/^-pdflua$/){ $pdf_mode = 4; $dvi_mode = $hnt_mode = $postscript_mode = $xdv_mode = 0; } elsif (/^-pdfps$/) { $pdf_mode = 2; $hnt_mode = $xdv_mode = 0; } elsif (/^-pdfxe$/) { $pdf_mode = 5; $dvi_mode = $hnt_mode = $postscript_mode = 0; } elsif (/^-pdflatex$/) { $pdf_mode = 1; $dvi_mode = $hnt_mode = $postscript_mode = $xdv_mode = 0; } elsif (/^-pdflatex=(.*)$/) { $pdflatex = $1; } elsif ( /^-pdflualatex=(.*)$/ || /^-lualatex=(.*)$/ ) { $lualatex = $1; } elsif ( /^-pdfxelatex=(.*)$/ || /^-xelatex=(.*)$/ ) { $xelatex = $1; } elsif (/^-pretex=(.*)$/) { $pre_tex_code = $1; } elsif (/^-print=(.*)$/) { my $value = $1; if ( $value =~ /^dvi$|^ps$|^pdf$|^auto$/ ) { $print_type = $value; $printout_mode = 1; } else { &exit_help("$My_name: unknown print type '$value' in option '$_'"); } } elsif (/^-ps$/) { $postscript_mode = 1; # dvi mode OK $hnt_mode = $xdv_mode = 0; if ( ($pdf_mode != 2) && ($pdf_mode != 3) ) { # if pdf_mode is not via dvi or pdf, turn it off $pdf_mode = 0; } } elsif (/^-ps-$/) { $postscript_mode = 0; } elsif (/^-pv$/) { $preview_mode = 1; $preview_continuous_mode = 0; # to avoid conflicts $printout_mode = 0; } elsif (/^-pv-$/) { $preview_mode = 0; } elsif (/^-pvc$/) { $preview_continuous_mode = 1; $force_mode = 0; # So that errors do not cause loops $preview_mode = 0; # to avoid conflicts $printout_mode = 0; } elsif (/^-pvc-$/) { $preview_continuous_mode = 0; } elsif (/^-pvctimeout$/) { $pvc_timeout = 1; } elsif (/^-pvctimeout-$/) { $pvc_timeout = 0; } elsif (/^-pvctimeoutmins=(.*)$/) { $pvc_timeout_mins = $1; } elsif (/^-rc-report$/) { $rc_report = 1; } elsif (/^-rc-report-$/) { $rc_report = 0; } elsif (/^-recorder$/ ){ $recorder = 1; } elsif (/^-recorder-$/ ){ $recorder = 0; } elsif (/^-rules$/ ) { $rules_list = 1; } elsif (/^-norules$/ || /^-rules-$/ ) { $rules_list = 0; } elsif (/^-showextraoptions$/) { print "List of extra latex and pdflatex options recognized by $my_name.\n", "These are passed as is to *latex. They may not be recognized by\n", "particular versions of *latex. This list is a combination of those\n", "for TeXLive and MikTeX.\n", "\n", "Note that in addition to the options in this list, there are several\n", "options known to the *latex programs that are also recognized by\n", "latexmk and trigger special behavior by latexmk. Since these options\n", "appear in the main list given by running 'latexmk --help', they do not\n", "appear in the following list\n", "NOTE ALSO: Not all of these options are supported by all versions of *latex.\n", "\n"; foreach my $option ( sort( keys %allowed_latex_options, keys %allowed_latex_options_with_arg ) ) { if (exists $allowed_latex_options{$option} ) { print " $allowed_latex_options{$option}\n"; } if (exists $allowed_latex_options_with_arg{$option} ) { print " $allowed_latex_options_with_arg{$option}\n"; } } exit; } elsif (/^-silent$/ || /^-quiet$/ ){ $silent = 1; } elsif (/^-stdtexcmds$/) { &std_tex_cmds; } elsif (/^-time$/) { $show_time = 1;} elsif (/^-time-$/) { $show_time = 0;} elsif (/^-use-make$/) { $use_make_for_missing_files = 1; } elsif (/^-use-make-$/) { $use_make_for_missing_files = 0; } elsif (/^-usepretex$/) { &alt_tex_cmds; } elsif (/^-usepretex=(.*)$/) { &alt_tex_cmds; $pre_tex_code = $1; } elsif (/^-v$/ || /^-version$/) { print "$version_details\n"; exit; } elsif (/^-verbose$/) { $silent = 0; } elsif (/^-view=default$/) { $view = "default";} elsif (/^-view=dvi$/) { $view = "dvi";} elsif (/^-view=hnt$/) { $view = "hnt";} elsif (/^-view=none$/) { $view = "none";} elsif (/^-view=ps$/) { $view = "ps";} elsif (/^-view=pdf$/) { $view = "pdf"; } elsif (/^-Werror$/){ $warnings_as_errors = 1; } elsif (/^-xdv$/) { $xdv_mode = 1; $dvi_mode = $hnt_mode = $postscript_mode = 0; if ( $pdf_mode != 5 ) { # if pdf_mode is not by xelatex $pdf_mode = 0; } } elsif (/^-xdv-$/) { $xdv_mode = 0; } elsif ( /^-xelatex$/ || /^-pdfxelatex$/ ) { $pdf_mode = 5; # Xdv mode OK, since use xelatex to make xdv file $dvi_mode = $hnt_mode = $postscript_mode = 0; } # See above for -xelatex=... elsif (/^-e$/) { if ( $#ARGV < 0 ) { &exit_help( "No code to execute specified after -e switch"); } execute_code_string( $ARGV[0] ); shift; } elsif (/^-r$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No RC file specified after -r switch"); } if ( -e $ARGV[0] ) { # Give process_rc_file a non-zero argument so that there is a warning # if $ARGV[0] has already been processed as an rc file: process_rc_file( $ARGV[0], 1 ); } else { die "$My_name: RC file [$ARGV[0]] does not exist\n"; } shift; } elsif (/^-bm$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No message specified after -bm switch"); } warn "$My_name: Option -bm is no longer used by latexmk.\n"; $banner = 1; $banner_message = $ARGV[0]; shift; } elsif (/^-bi$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No intensity specified after -bi switch"); } warn "$My_name: Option -bi is no longer used by latexmk.\n"; $banner_intensity = $ARGV[0]; shift; } elsif (/^-bs$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No scale specified after -bs switch"); } warn "$My_name: Option -bs is no longer used by latexmk.\n"; $banner_scale = $ARGV[0]; shift; } elsif (/^-dF$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No dvi filter specified after -dF switch"); } $dvi_filter = $ARGV[0]; shift; } elsif (/^-pF$/) { if ( $ARGV[0] eq '' ) { &exit_help( "No ps filter specified after -pF switch"); } $ps_filter = $ARGV[0]; shift; } elsif ( ( exists( $allowed_latex_options{$_} ) ) || ( /^(-[^=]+)=/ && exists( $allowed_latex_options_with_arg{$1} ) ) ) { push @extra_dvilualatex_options, $original; push @extra_hilatex_options, $original; push @extra_latex_options, $original; push @extra_pdflatex_options, $original; push @extra_lualatex_options, $original; push @extra_xelatex_options, $original; } elsif (/^-/) { warn "$My_name: $_ unknown option\n"; $bad_options++; } else { push @command_line_file_list, $_ ; } } if ( $diagnostics || $rc_report ) { show_array( "Rc files read:", @rc_files_read ); } if ( $bad_options > 0 ) { &exit_help( "Bad options specified" ); } print "$My_name: This is $version_details.\n", unless $silent; &config_to_mine; # Save original values for use in diagnositics. # We may change $aux_dir and $out_dir after a detection # of results of misconfiguration. $aux_dir_requested = $aux_dir; $out_dir_requested = $out_dir; $out2_dir_requested = $out2_dir; if ($out_dir eq '' ){ # Default to cwd $out_dir = '.'; } if ($out2_dir eq '' ){ # Default to cwd $out2_dir = $out_dir; } if ( $aux_dir eq '' ){ # Default to out_dir $aux_dir = $out_dir; } if ($bibtex_use > 1) { push @generated_exts, 'bbl'; } # For backward compatibility, convert $texfile_search to @default_files # Since $texfile_search is initialized to "", a nonzero value indicates # that an initialization file has set it. if ( $texfile_search ne "" ) { @default_files = split /\s+/, "*.tex $texfile_search"; } #Glob the filenames command line if the script was not invoked under a # UNIX-like environment. # Cases: (1) MS/MSwin native Glob # (OS detected as MSWin32) # (2) MS/MSwin cygwin Glob [because we do not know whether # the cmd interpreter is UNIXy (and does glob) or is # native MS-Win (and does not glob).] # (OS detected as cygwin) # (3) UNIX Don't glob (cmd interpreter does it) # (Currently, I assume this is everything else) our @file_list; if ( ($^O eq "MSWin32") || ($^O eq "cygwin") ) { # Preserve ordering of files @file_list = glob_list1(@command_line_file_list); #print "A1:File list:\n"; #for ($i = 0; $i <= $#file_list; $i++ ) { print "$i: '$file_list[$i]'\n"; } } else { @file_list = @command_line_file_list; } @file_list = uniq1( @file_list ); # Check we haven't selected mutually exclusive modes. # Note that -c overrides all other options, but doesn't cause # an error if they are selected. if (($printout_mode && ( $preview_mode || $preview_continuous_mode )) || ( $preview_mode && $preview_continuous_mode )) { # Each of the options -p, -pv, -pvc turns the other off. # So the only reason to arrive here is an incorrect inititalization # file, or a bug. &exit_help( "Conflicting options (print, preview, preview_continuous) selected"); } if ( @command_line_file_list ) { # At least one file specified on command line (before possible globbing). if ( !@file_list ) { &exit_help( "Wildcards in file names didn't match any files"); } } else { # No files specified on command line, try and find some # Evaluate in order specified. The user may have some special # for wanting processing in a particular order, especially # if there are no wild cards. # Preserve ordering of files my @file_list1 = uniq1( glob_list1(@default_files) ); my @excluded_file_list = uniq1( glob_list1(@default_excluded_files) ); # Make hash of excluded files, for easy checking: my %excl = (); foreach my $file (@excluded_file_list) { $excl{$file} = ''; } foreach my $file (@file_list1) { push( @file_list, $file) unless ( exists $excl{$file} ); } if ( !@file_list ) { &exit_help( "No file name(s) specified on command line, and no files match the\n". "patterns in the default list." ); } } our $num_files = $#file_list + 1; our $num_specified = $#command_line_file_list + 1; #print "Command line file list:\n"; #for ($i = 0; $i <= $#command_line_file_list; $i++ ) { print "$i: '$command_line_file_list[$i]'\n"; } #print "File list:\n"; #for ($i = 0; $i <= $#file_list; $i++ ) { print "$i: '$file_list[$i]'\n"; } # If selected a preview-continuous mode, make sure exactly one filename was specified if ($preview_continuous_mode && ($num_files != 1) ) { if ($num_specified > 1) { &exit_help( "Need to specify exactly one filename for ". "preview-continuous mode\n". " but $num_specified were specified" ); } elsif ($num_specified == 1) { &exit_help( "Need to specify exactly one filename for ". "preview-continuous mode\n". " but wildcarding produced $num_files files" ); } else { &exit_help( "Need to specify exactly one filename for ". "preview-continuous mode.\n". " Since none were specified on the command line, I looked for \n". " files in '@default_files'.\n". " But I found $num_files files, not 1." ); } } # If selected jobname, can only apply that to one file: if ( ($jobname ne '') && ($jobname !~ /%A/) && ($num_files > 1) ) { &exit_help( "Need to specify at most one filename if ". "jobname specified without a %A, \n". " but $num_files were found (after defaults and wildcarding)." ); } if ( $jobname =~ /%[^A]/ ) { &exit_help( "Jobname '$jobname' contains placeholder other than %A." ); } # Normalize the commands, to have place-holders for source, dest etc: &fix_cmds; # Add common options add_option( $dvilualatex_default_switches, \$dvilualatex ); add_option( $hilatex_default_switches, \$hilatex ); add_option( $latex_default_switches, \$latex ); add_option( $pdflatex_default_switches, \$pdflatex ); add_option( $lualatex_default_switches, \$lualatex ); add_option( $xelatex_default_switches, \$xelatex ); foreach (@extra_dvilualatex_options) { add_option( $_, \$dvilualatex ); } foreach (@extra_hilatex_options) { add_option( $_, \$hilatex ); } foreach (@extra_latex_options) { add_option( $_, \$latex ); } foreach (@extra_pdflatex_options) { add_option( $_, \$pdflatex ); } foreach (@extra_lualatex_options) { add_option( $_, \$lualatex ); } foreach (@extra_xelatex_options) { add_option( $_, \$xelatex ); } # If landscape mode, change dvips processor, and the previewers: if ( $landscape_mode ) { $dvips = $dvips_landscape; $dvi_previewer = $dvi_previewer_landscape; $ps_previewer = $ps_previewer_landscape; } { my $array_changed = 0; if ($#BIBINPUTS != $#BIBINPUTS_SAVE) { $array_changed = 1; } else { for( my $i = 0; $i <= $#BIBINPUTS; $i++ ) { if ($BIBINPUTS[$i] ne $BIBINPUTS_SAVE[$i]) { $array_changed = 1; last; } } } if ($array_changed) { foreach (@BIBINPUTS) { ensure_path( 'BIBINPUTS', $_ ); } } } if ( $silent ) { add_option( "$dvilualatex_silent_switch", \$dvilualatex ); add_option( "$hilatex_silent_switch", \$hilatex ); add_option( "$latex_silent_switch", \$latex ); add_option( "$pdflatex_silent_switch", \$pdflatex ); add_option( "$lualatex_silent_switch", \$lualatex ); add_option( "$xelatex_silent_switch", \$xelatex ); add_option( "$biber_silent_switch", \$biber ); add_option( "$bibtex_silent_switch", \$bibtex ); add_option( "$makeindex_silent_switch", \$makeindex ); add_option( "$dvipdf_silent_switch", \$dvipdf ); add_option( "$dvips_silent_switch", \$dvips ); add_option( "$xdvipdfmx_silent_switch", \$xdvipdfmx ); } if ( $recorder ) { add_option( "-recorder", \$dvilualatex, \$hilatex, \$latex, \$pdflatex, \$lualatex, \$xelatex ); } # If the output and/or aux directories are specified, fix the *latex # commands to use them. # N.B. We'll ensure that the directories actually exist only after a # possible cd to the document directory, since the directories can be # relative to the document. if ( $jobname ne '' ) { # Since $jobname may include placeholder(s), put %R placeholder # in option, and let %R be substituted by actual jobname at runtime. add_option( "--jobname=%R", \$dvilualatex, \$hilatex, \$latex, \$lualatex, \$pdflatex, \$xelatex ); } # Make sure we make the kind of file we want to view: if ( ($view eq 'dvi') && ($dvi_mode == 0) ) { $dvi_mode = 1; } if ( ($view eq 'hnt') && ($hnt_mode == 0) ) { $hnt_mode = 1; } if ( $view eq 'ps' ) { $postscript_mode = 1; } if ( ($view eq 'pdf') && ($pdf_mode == 0) ) { warn "$my_name: Viewing of pdf requested, but pdf_mode off, so I'll turn it on.\n"; $pdf_mode = 1; } # Make sure that we make something if all requests are turned off unless ( $dvi_mode || $hnt_mode || $pdf_mode || $postscript_mode || $printout_mode || $xdv_mode ) { print "No specific requests made, so using default for $invoked_name.\n"; ($dvi_mode, $hnt_mode, $postscript_mode, $pdf_mode, $xdv_mode ) = @{$compilation_defaults{$invoked_name}}; } # Which kind of file do we preview? if ( $view eq "default" ) { # If default viewer requested, use "highest" of dvi, ps and pdf # that was requested by user. # No explicit request means view dvi. if ( $pdf_mode ) { $view = "pdf"; } elsif ( $postscript_mode ) { $view = "ps"; } elsif ( $xdv_mode ) { $view = "none"; } elsif ( $hnt_mode ) { $view = "hnt"; } else { $view = "dvi"; } } # Determine and normalize requests for actions: if ($go_mode == 2) { $cleanup_mode = 1; $cleanup_only = 0; } if ( $banner ) { $postscript_mode = 1; } if ( $dvi_mode ) { $requested_filetypes{'dvi'} = 1; if ( length($dvi_filter) != 0 ) { $requested_filetypes{'dviF'} = 1; } } if ( $postscript_mode ) { $requested_filetypes{'ps'} = 1; if ( length($ps_filter) != 0 ) { $requested_filetypes{'psF'} = 1; } } if ($pdf_mode > 5) { warn "$My_name: Non-allowed value of \$pdf_mode = $pdf_mode,", " replaced by 1.\n"; $pdf_mode = 1; } if ( ($dvi_mode || $postscript_mode) && $pdf_mode ) { my %disallowed = (); foreach (1,4,5) { $disallowed{$_} = 1; } if ($disallowed{$pdf_mode}) { warn "$My_name: \$pdf_mode = $pdf_mode is incompatible with dvi and postscript modes\n", " which are required by other requests.\n", " Some requests may be implicit in the kind of file to view: '$view'.\n"; if ($postscript_mode) { $pdf_mode = 2; } else { $pdf_mode = 3; } warn " I set pdf_mode to $pdf_mode, to be compatible with those other requests.\n"; } } if ( $xdv_mode && $pdf_mode ) { my %disallowed = (); foreach (1,2,3,4) { $disallowed{$_} = 1; } if ($disallowed{$pdf_mode}) { warn "$My_name: \$pdf_mode = $pdf_mode is incompatible with dvi and postscript modes\n", " which are required by other requests.\n"; if ($postscript_mode) { $pdf_mode = 2; } else { $pdf_mode = 3; } warn " I replaced it by $pdf_mode, to be compatible with those other requests.\n"; } } if ( $pdf_mode == 0 ) { $pdf_method = ''; } elsif ( $pdf_mode == 1 ) { $requested_filetypes{'pdf'} = 1; $pdf_method = 'pdflatex'; } elsif ( $pdf_mode == 2 ) { $requested_filetypes{'pdf'} = 1; $pdf_method = 'ps2pdf'; } elsif ( $pdf_mode == 3 ) { $requested_filetypes{'pdf'} = 1; $pdf_method = 'dvipdf'; } elsif ( $pdf_mode == 4 ) { $requested_filetypes{'pdf'} = 1; $pdf_method = 'lualatex'; } elsif ( $pdf_mode == 5 ) { $requested_filetypes{'pdf'} = 1; $pdf_method = 'xelatex'; } if ($print_type eq 'auto') { if ( $postscript_mode ) { $print_type = 'ps'; } elsif ( $pdf_mode ) { $print_type = 'pdf'; } elsif ( $dvi_mode ) { $print_type = 'dvi'; } else { $print_type = 'none'; } } if ( $printout_mode ) { $one_time{'print'} = 1; if ($print_type eq 'none'){ warn "$My_name: You have requested printout, but \$print_type is set to 'none'\n"; } } if ( $preview_continuous_mode || $preview_mode ) { $one_time{'view'} = 1; } our $can_switch = $allow_switch; if ( $dvi_mode || $hnt_mode || $postscript_mode || $xdv_mode || ( $printout_mode && ($print_type eq 'ps') || ($print_type eq 'dvi') ) || ( ($preview_mode || $preview_continuous_mode) && ( ($view eq 'ps') || ($view eq 'dvi') ) ) ) { # Automatic switching (e.g., pdf<->dvi o/p) requires pdf files to be # the only destinations. So if ps or dvi files needed, we cannot # allow switching. (There will then be an error condition if a TeX # engine fails to produce the correct type of output file.) if ($diagnostics) { warn "$My_name: Disallowing switch of output file as incompatible\n", " with file requests.\n"; } $can_switch = 0; } if ( $pdf_mode == 2 ) { # We generate pdf from ps. Make sure we have the correct kind of ps. add_option( "$dvips_pdf_switch", \$dvips ); } # Note that 100% CPU usage may not be terribly bad with a multi-core CPU, # and an SSD, especially when the OS caches file metadata reliably. if ( $sleep_time == 0 ) { warn "$My_name: sleep_time was configured to zero.\n", " Do you really want to do this? It can give 100% CPU usage.\n"; } elsif ( $sleep_time < $min_sleep_time ) { warn "$My_name: Correcting nonzero sleep_time of less than $min_sleep_time sec to $min_sleep_time sec.\n"; $sleep_time = $min_sleep_time; } # Standardize specifications for generated file extensions: # # Remove leading and trailing space in the following space-separated lists, # and collapse multiple spaces to one, # to avoid getting incorrect blank items when they are split. foreach ($clean_ext, $clean_full_ext) { s/^\s+//; s/\s+$//; s/\s+/ /g; } # Put everything in the arrays: push @generated_exts, split('\s+',$clean_ext); push @final_output_exts, split('\s+',$clean_full_ext); # Convert the arrays to hashes, for ease of deletion: # Keep extension without period! our %generated_exts = (); foreach (@generated_exts ) { $generated_exts{$_} = 1; } our $quell_uptodate_msgs = $silent; # Whether to quell informational messages when files are uptodate # Will turn off in -pvc mode our $failure_count = 0; our @failed_primaries = (); if ($deps_file eq '' ) { # Standardize name used for stdout $deps_file = '-'; } # Since deps_file is global (common to all processed files), we must # delete it here when doing a clean up, and not in the FILE loop, where # per-file processing (including clean-up) is done if ( ($cleanup_mode > 0) && $dependents_list && ( $deps_file ne '-' ) ) { unlink_or_move( $deps_file ); } # In non-pvc mode, the dependency list is global to all processed TeX files, # so we open a single file here, and add items to it after processing # each file. But in -pvc mode, the dependency list should be written # after round of processing the single TeX file (as if each round were # a separate run of latexmk). # If we are cleaning up ($cleanup_mode != 0) AND NOT continuing to # make files (--gg option and $go_mode == 2), deps_file should not be # created. # I will use definedness of $deps_handle as flag for global deps file having # been opened and therefore being available to be written to after # compiling a file. our $deps_handle = undef; if ( $dependents_list && ! $preview_continuous_mode && ( ($cleanup_mode == 0) || ($go_mode == 2) ) ) { open( $deps_handle, ">$deps_file" ); if (! $deps_handle ) { die "Cannot open '$deps_file' for output of dependency information\n"; } } # Deal with illegal and problematic characters in filename: test_fix_texnames( @file_list ); our $quote = $quote_filenames ? '"' : ''; # Primary filename and path are variables of overall context, and hence global. our $filename; our $path; # Other globals our ( @default_includes, $texfile_name, $root_filename, $log_name, $tex_basename, $bcf_name, $fls_name, $fls_name_alt, $fdb_name, $aux_main, $dvi_name, $dviF_name, $hnt_name, $ps_name, $psF_name, $pdf_name, $xdv_name, $dvi_final, $hnt_final, $ps_final, $pdf_final, $xdv_final, $dvi_final2, $hnt_final2, $ps_final2, $pdf_final2, $view_file, %rule_list, $missing_dvi_pdf, $switched_primary_output ); # Defaults for when rule-using subroutines are used outside a rule: $rule = ''; $Pbase = \$root_filename; $Psource = \$texfile_name; my $start_time = time(); $Prun_time = \$start_time; FILE: foreach $filename ( @file_list ) { # Global variables for making of current file: $updated = 0; $failure = 0; # Set nonzero to indicate failure at some point of # a make. Use value as exit code if I exit. $failure_msg = ''; # Indicate reason for failure my $path = ''; if ( $do_cd ) { # Use my fileparse routine rather than the built-in one, otherwise # under msys, a directory separator \ won't be recognized by fileparse. # My routines fix that. At this point, $filename ought to have had its # \s changed to /s. But I won't leave boobytrapped code. # I use fileparseB rather than fileparseA, because fileparseA changes # path './' to '', but fileparseB keeps the fileparse behavior there. # I have to supply an explicit pattern of '' to keep extension in $filename. ($filename, $path) = fileparseB( $filename, '' ); print "$My_name: Changing directory to '$path'\n" if !$silent; pushd( dirname_no_tail( $path ) ); } # Localize the following, because they may get changed because of # conditions specific to the current tex file, notably: # Change of emulation state of aux_dir # Use of $do_cd, which can affect how $aux_dir and $out_dir get normalized. local $aux_dir = $aux_dir; local $out_dir = $out_dir; local $out2_dir = $out2_dir; local $dvilualatex = $dvilualatex; local $hilatex = $hilatex; local $latex = $latex; local $lualatex = $lualatex; local $pdflatex = $pdflatex; local $xelatex = $xelatex; &normalize_aux_out_ETC; # Set -output-directory and -aux-directory options for *latex here, # since at least: Their method of use depends on the dynamically # set $emulate_aux, and the exact strings for the directory names are # not known until after the call to normalize_aux_out_ETC: &set_aux_out_options; &set_names; # Names of standard files if ($diagnostics || $aux_out_dir_report ) { print "$My_name: Cwd: '", good_cwd(), "'\n"; print "$My_name: Normalized aux dir, out dir, out2 dir:\n", " '$aux_dir', '$out_dir', '$out2_dir'\n"; print "$My_name: Combining forms of aux dir, out dir, out2 dir:\n", " '$aux_dir1', '$out_dir1', '$out2_dir1'\n"; print "$My_name: Base name of generated files:\n", " '$root_filename'\n"; if ($aux_out_dir_report == 2) { next FILE; } } # For use under error conditions: @default_includes = ($texfile_name, $aux_main); # Set rules here for current conditions &rdb_initialize_rules; $view_file = ''; rdb_one_rule( 'view', sub{ $view_file = $$Psource; } ); if ( $diagnostics ) { print "$My_name: Rules after start up for '$texfile_name'\n"; rdb_show(); } if ($cleanup_fdb) { print "$My_name: Deleting '$fdb_name' (file of cached information)\n"; unlink_or_move( $fdb_name ); } # Set rules from fdb_latexmk file, if possible. # Allow adaptation of output extension for primary rule to cached # value, but not if we are doing a cleanup (since then the rules # will all be reset after the cleanup). if ( -e $fdb_name ) { if (0 != rdb_read( $fdb_name, $cleanup_mode ) ) { # There were some problems with the file of cached rules, so # the resulting set of rules may be problematic: file status # data may be incorrect. # So use filetime criterion for make instead of file change from # previous run, until we have done our own make. # ???!!! CHECK: WHY ONLY PRIMARIES???? rdb_recurse( [$current_primary], sub{ $$Pno_history = 1; } ); } } elsif ( -e $log_name ) { # At least we can use dependency information from previous run of # *latex, which may not have been under latexmk control, otherwise # the fdb_latexmk file would have been made. rdb_for_some( [$current_primary], sub{ rdb_set_latex_deps($cleanup_mode) } ); &rdb_set_rule_net; } # At this point, the file and rule databases are correctly initialized # either from the fdb_latexmk database (corresponding to the state at # the end of the previous run of latexmk), or from default initialization, # assisted by dependency information from log files about previous # run, if the log file exists. if ( $cleanup_mode ) { do_cleanup( $cleanup_mode ); } if ($cleanup_only) { next FILE; } if ( ! -e $aux_main ) { # No aux file => set up trivial aux file # and corresponding fdb_file. Arrange them to provoke one run # as minimum, but no more if actual aux file is trivial. # (Useful on short simple files.) # If aux file doesn't exist, then any fdb file is surely # wrong. So updating it to current state is sensible. print( "No existing .aux file, so I'll make a simple one, and require run of *latex.\n") unless $silent; &set_trivial_aux_fdb; } if ($go_mode == 3) { # Force primaries to be remade. if (!$silent) { print "Force *latex to be remade.\n"; } rdb_for_some( [keys %possible_primaries], sub{$$Pout_of_date = 'go_mode=3';} ); } elsif ($go_mode) { # Force everything to be remade. if (!$silent) { print "Force everything to be remade.\n"; } rdb_recurse( [ &rdb_target_array], sub{$$Pout_of_date = 'go_mode';} ); } if ( $diagnostics ) { print "$My_name: Rules after initialization\n"; rdb_show(); } #************************************************************ if ( $preview_continuous_mode ) { &make_preview_continuous; next FILE; } ## Handling of failures: ## Variable $failure is set to indicate a failure, with information ## put in $failure_msg. ## These variables should be set to 0 and '' at any point at which it ## should be assumed that no failures have occurred. ## When after a routine is called it is found that $failure is set, then ## processing should normally be aborted, e.g., by return. ## Then there is a cascade of returns back to the outermost level whose ## responsibility is to handle the error. ## Exception: An outer level routine may reset $failure and $failure_msg ## after initial processing, when the error condition may get ## ameliorated later. #Initialize failure flags now. $failure = 0; $failure_msg = ''; &init_timing1; $failure = rdb_make(); if ( ( $failure <= 0 ) || $force_mode ) { rdb_for_some( [keys %one_time], \&rdb_run1 ); } if ($#primary_warning_summary > -1) { # N.B. $mult_defined, $bad_reference, $bad_character, $bad_citation also available here. if ($warnings_as_errors) { $failure = 1; $failure_msg = "Warning(s) from latex (or c.) for '$filename'; treated as error"; } } if ($failure > 0) { if ($failure_cmd) { Run_subst( $failure_cmd ); } next FILE; } else { if ($success_cmd) { Run_subst( $success_cmd ); } } } # end FILE continue { if ($deps_handle) { deps_list($deps_handle); } # If requested, print the list of rules. But don't do this in -pvc # mode, since the rules list has already been printed. if ($rules_list && ! $preview_continuous_mode) { rdb_list(); } # Handle any errors my $error_message_count = rdb_show_rule_errors(); if ( ($error_message_count == 0) || ($failure > 0) ) { if ( $failure_msg ) { #Remove trailing space $failure_msg =~ s/\s*$//; warn "----------------------\n"; warn "This message may duplicate earlier message.\n"; warn "$My_name: Failure in processing file '$filename':\n", " $failure_msg\n"; warn "----------------------\n"; $failure = 1; } } if ( ($failure > 0) || ($error_message_count > 0) ) { $failure_count ++; push @failed_primaries, $filename; } &ifcd_popd; if ($show_time && ! $preview_continuous_mode) { &show_timing1; }; print "\n"; } close($deps_handle) if ( $deps_handle ); if ( $show_time && ( ($#file_list > 0) || $preview_continuous_mode ) ) { print "\n"; show_timing_grand(); } # If we get here without going through the continue section: if ( $do_cd && ($#dir_stack > -1) ) { # Just in case we did an abnormal exit from the loop warn "$My_name: Potential bug: dir_stack not yet unwound, undoing all directory changes now\n"; &finish_dir_stack; } if ($filetime_offset_measured) { if ( (abs($filetime_offset) >= $filetime_offset_report_threshold) && ($diagnostics || ! $silent) ) { warn "$My_name: I am working around an offset relative to my system time by\n", " $filetime_offset secs for file times in directory '$aux_dir1'.\n", " This **probably** indicates that \n", " (a) I ($my_name) am running on one computer, while the filesystem is\n", " hosted on a different computer/\n", " (b) There is a substantial time offset between system times on the two\n", " computers.\n", " (c) Therefore at least one of the computers has a misconfigured operating\n", " system such that its system time is not correctly synchronized with a\n", " time server.\n", " These issues are likely to cause problems with other software, and any\n", " such operating-system misconfigurations should be corrected. By default\n", " current operating systems are configured to correctly synchronize system\n", " time when they are connected to the Internet\n"; } } if ($failure_count > 0) { if ( $#file_list > 0 ) { # Error occured, but multiple files were processed, so # user may not have seen all the error messages warn "\n------------\n"; warn_array( "$My_name: Some operations failed, for the following tex file(s)", @failed_primaries); } if ( !$force_mode ) { warn "$My_name: Sometimes, the -f option can be used to get latexmk\n", " to try to force complete processing.\n", " But normally, you will need to correct the file(s) that caused the\n", " error, and then rerun latexmk.\n", " In some cases, it is best to clean out generated files before rerunning\n", " latexmk after you've corrected the files.\n"; } exit 12; } if ( $emulate_aux_switched ) { warn "$My_name: I had to switch emulate-aux-dir on after it was initially off,\n", " because your *latex program appeared not to support -aux-directory. You\n", " probably should either use the option -emulate-aux-dir, or in a\n", " latexmkrc file set \$emulate_aux = 1;\n"; } # end MAIN PROGRAM ############################################################# ############################################################# # Subroutines for working with processing time ############################ sub add_timing { # Usage: add_timing( time_for_run, rule ); # Adds time_for_run to @timings1, @timings0 my ( $time, $rule ) = @_; push @timings1, "'$rule': time = " . sprintf('%.2f',$time) . "\n"; push @timings0, "'$rule': time = " . sprintf('%.2f',$time) . "\n"; } ############################ sub init_timing1 { # Initialize timing for one run. @timings1 = (); $processing_time1 = processing_time(); $clock1 = time(); } ############################ sub init_timing_all { # Initialize timing for totals and for one run: @timings0 = (); $processing_time0 = processing_time(); &init_timing1; } ############################ sub show_timing1 { # Show timing for one run. my $processing_time = processing_time() - $processing_time1; my $invoked_time = 0; for (@timings1) { if (/: time = (.*)\s$/) { $invoked_time += $1; }} print @timings1, "Processing time = ", sprintf('%.2f', $processing_time), ", of which invoked processes = $invoked_time, other = ", sprintf( '%.2f', $processing_time-$invoked_time ), ".\n"; print "Elapsed clock time = ", sprintf( '%.2f', time()-$clock1 ), ".\n"; print "Number of rules run = ", 1+$#timings1, "\n"; } ############################ sub show_timing_grand { # Show grand total timing. my $processing_time = processing_time() - $processing_time0; print # @timings0, "Grand total processing time = ", sprintf('%.2f', $processing_time), "\n"; print "Total number of rules run = ", 1+$#timings0, "\n"; } ############################################################# ############################################################# sub set_tex_cmds { # Usage, e.g., set_tex_cmds( '%O %S' ) # or set_tex_cmds( '%C-dev %O %S' ) my $args = $_[0]; no strict "refs"; foreach my $cmd ( keys %possible_primaries ) { my $spec = $args; if ( $spec =~ /%C/ ) { $spec =~ s/%C/$cmd/g; } else { $spec = "$cmd $args"; } ${$cmd} = $spec; } # N.B. See setting of $latex_default_switches, ..., # $xelatex_default_switches, etc, for any special options needed. } sub std_tex_cmds { set_tex_cmds( '%O %S' ); } sub alt_tex_cmds { set_tex_cmds( '%O %P' ); } #======================== sub test_fix_texnames { my $illegal_char = 0; my $unbalanced_quote = 0; my $balanced_quote = 0; foreach (@_) { if ( ($^O eq "MSWin32") || ($^O eq "msys") ) { # On MS-Win, change directory separator '\' to '/', as needed # by the TeX engines, for which '\' introduces a macro name. # Remember that '/' is a valid directory separator in MS-Win. s[\\][/]g; } if ($do_cd) { my ($filename, $path) = fileparse( $_ ); if ($filename =~ /[\Q$illegal_in_texname\E]/ ) { $illegal_char++; warn "$My_name: Filename '$filename' contains character not allowed for TeX file.\n"; } if ($filename =~ /^&/) { $illegal_char++; warn "$My_name: Filename '$filename' contains initial '&', which is\n", " not allowed for TeX file.\n"; } } else { if ( /[\Q$illegal_in_texname\E]/ ) { $illegal_char++; warn "$My_name: Filename '$_' contains character not allowed for TeX file.\n"; } if (/^&/ ) { $illegal_char++; warn "$My_name: Filename '$_' contains initial '&', which is not allowed\n", " for TeX file.\n"; } } my $count_q = ($_ =~ tr/\"//); if ( ($count_q % 2) != 0 ) { warn "$My_name: Filename '$_' contains unbalanced quotes, not allowed.\n"; $unbalanced_quote++; } elsif ( $count_q > 0 ) { print "$My_name: Removed (balanced quotes) from filename '$_',\n"; s/\"//g; print " and obtained '$_'.\n"; $balanced_quote++; } } if ($illegal_char || $unbalanced_quote) { die "$My_name: Stopping because of bad filename(s).\n"; } } ############################################################# sub ensure_path { # Usage: ensure_path( var, values ...) # $ENV{var} is an environment variable (e.g. $ENV{TEXINPUTS}. # Ensure the values are in it, prepending them if not, and # creating the environment variable if it doesn't already exist. my $var = shift; my %cmpts = (); if ( exists $ENV{$var} ) { foreach ( split $search_path_separator, $ENV{$var} ) { if ($_ ne '') { $cmpts{$_} = 1; } } } foreach (@_) { next if ( ($_ eq '') || (exists $cmpts{$_}) ); if (exists $ENV{$var}) { $ENV{$var} = $_ . $search_path_separator . $ENV{$var}; } else { $ENV{$var} = $_ . $search_path_separator; } if ($diagnostics) { print "Set environment variable $var='$ENV{$var}'\n"; } } } #END ensure_path ############################################################# sub path_fudge { # Usage: path_fudge( var1[, var2 ...]) # For each argument, $ENV{var} is an environment variable # (e.g. $ENV{BIBINPUTS}, that is a search path. # Adjust each of these environment variables so that it is # appropriately set for use when a program is run with a changed wd, # as with bibtex when $bibtex_fudge is set. # Specifically: # 1. Prepend current wd to each $ENV{var}, if it exists; otherwise # set $ENV{var} to current wd followed by search-path separator, # so that search path is cwd and then default. # Hence files in cwd are found by a program run in another # directory. # 2. For each item in $ENV{var} that isn't an absolute path, i.e., # that is relative, replace it by itself followed by the same path # converted to an absolute path, with the relative path being # assumed to be relative to the current wd. # Hence a program run in another directory finds files that were # originally intended to be in a directory relative to the orginal # cwd. In addition, in the conceivable case that the item in the # search path is actually intended to be relative to the directory # in which the program is run (normally the aux dir), it also # works correctly. my $cwd = good_cwd(); foreach my $var ( @_ ) { if ( exists $ENV{$var} ) { $ENV{$var} = $cwd.$search_path_separator.$ENV{$var}; } else { $ENV{$var} = $cwd.$search_path_separator; } my @items = split_search_path( $search_path_separator, '', $ENV{$var} ); my $changed = 0; foreach (@items) { if ($_ eq '' ) { # Empty item => std search path => nothing to do. } elsif ( ! file_name_is_absolute($_) ) { my $abs = rel2abs($_); $_ .= $search_path_separator.$abs; $changed = 1; } } if ($changed) { # Correct the env. var. $ENV{$var} = join( $search_path_separator, @items ); print "====== ENV{$var} changed to '$ENV{$var}'\n"; } } # END loop over env. vars. } #END path_fudge ############################################################# sub normalize_aux_out_ETC { # 1. Normalize $out_dir and $aux_dir, so that if they have a non-trivial last # component, any trailing '/' is removed. # 2. They should be non-empty. # 3. Set $out_dir1 and $aux_dir1 to have a directory separator character # '/' added if needed to give forms suitable for direct concatenation with # a filename. These are needed for substitutions like %Y%R. # Nasty cases of dir_name: "/" on all systems, "A:", "A:/" etc on MS-Win # 4. Set some TeX-related environment variables. # 5. Ensure the aux and out directories exist # Ensure the output/auxiliary directories exist, if need be, **with error checking**. my $ret1 = 0; my $ret2 = 0; my $ret3 = 0; eval { if ( $out_dir ) { $ret1 = make_path_mod( $out_dir, 'output' ); } if ( $out2_dir ) { $ret2 = make_path_mod( $out2_dir, 'final output' ); } if ( $aux_dir && ($aux_dir ne $out_dir) ) { $ret3 = make_path_mod( $aux_dir, 'auxiliary' ); } }; if ($ret1 || $ret2 || $ret3 || $@ ) { if ($@) { print "Error message:\n $@"; } die "$My_name: Since there was trouble making the output (and aux) dirs, I'll stop\n" } if ($normalize_names) { foreach ( $aux_dir, $out_dir, $out2_dir ) { $_ = normalize_filename_abs($_); } } $aux_dir1 = $aux_dir; $out_dir1 = $out_dir; $out2_dir1 = $out2_dir; foreach ( $aux_dir1, $out_dir1, $out2_dir1 ) { if ($_ eq '.') {$_ = '';} if ( ($_ ne '') && ! m([\\/\:]$) ) { # Add a trailing '/' if necessary to give a string that can be # correctly concatenated with a filename: $_ .= '/'; } } if ($aux_dir) { # Ensure $aux_dir is in BIBINPUTS and TEXINPUTS search paths. # TEXINPUTS is used by dvips for files generated by mpost. # For BIBINPUTS, # at least one widely package (revtex4-1) generates a bib file # (which is used in revtex4-1 for putting footnotes in the reference # list), and bibtex must be run to use it. But latexmk needs to # determine the existence of the bib file by use of kpsewhich, otherwise # there is an error. So cope with this situation (and any analogous # cases by adding the aux_dir to the relevant path search environment # variables. BIBINPUTS seems to be the only one currently affected. # Convert $aux_dir to absolute path to make the search path invariant # under change of directory. foreach ( 'BIBINPUTS', 'TEXINPUTS' ) { ensure_path( $_, $aux_dir ); } # Set TEXMFOUTPUT so that when the aux_dir is not a subdirectory # of the cwd (or below), bibtex and makeindex can write to it. # Otherwise, security precautions in these programs will prevent # them from writing there, on TeXLive. MiKTeX is different: see # below. # The security issues concern **document-controlled** writing of # files, when bibtex or makeindex is invoked directly by a # document. In contrast, here $aux_dir is set by latexmk, not by # the document. (See the main texmf.cnf file in a TeXLive # distribution for some information on security issues.) # # PROPERTIES: # 1. In TeXLive, the use of TEXMFOUTPUT works if # (a) the directory given is an an absolute path, # AND (b) the path contains no .. pieces # AND (c) the directory component of the filename(s) on the command # line for makeindex and bibtex is exactly the same string as # for the directory named in TEXMFOUTPUT. # 2. In MiKTeX, bibtex has none of the security restrictions; but # makeindex has, and the use of TEXMFOUTPUT has no effect. # So the following is only needed for TeXLive. $ENV{TEXMFOUTPUT} = $aux_dir; } } #END normalize_aux_out_ETC ############################################################# sub set_aux_out_options { # Set -output-directory and -aux-directory options for *latex. Use # placeholders for substitutions so that correct value is put in at # runtime. # N.B. At this point, $aux_dir and $out_dir should be non-empty, unlike the # case after the reading of latexmkrc files, where empty string means # use default. Let's be certain, however: if ($out_dir eq '') { $out_dir = '.'; $out_dir1 = ''; } if ($aux_dir eq '') { $aux_dir = $out_dir; $aux_dir1 = $out_dir1; } if ($emulate_aux) { if ( $aux_dir ne '.' ) { # N.B. Set **output** directory to **aux_dir**, rather than # out_dir. If aux and out dirs are are different, then we'll move # the relevant files (.pdf, .ps, .dvi, .xdv, .fls to the output # directory after running *latex. add_option( "-output-directory=%V", \$dvilualatex, \$hilatex, \$latex, \$pdflatex, \$lualatex, \$xelatex ); } } else { if ( $out_dir && ($out_dir ne '.') ) { add_option( "-output-directory=%W", \$dvilualatex, \$hilatex, \$latex, \$pdflatex, \$lualatex, \$xelatex ); } if ( $aux_dir ne $out_dir ) { # N.B. If $aux_dir and $out_dir are the same, then the # -output-directory option is sufficient, especially because # the -aux-directory exists only in MiKTeX, not in TeXLive. add_option( "-aux-directory=%V", \$dvilualatex, \$hilatex, \$latex, \$pdflatex, \$lualatex, \$xelatex ); } } } #END set_aux_out_options ############################################################# sub fix_cmds { # If commands do not have placeholders for %S etc, put them in foreach ($hilatex, $latex, $lualatex, $pdflatex, $xelatex, $lpr, $lpr_dvi, $lpr_pdf, $pdf_previewer, $ps_previewer, $ps_previewer_landscape, $dvi_previewer, $dvi_previewer_landscape, $kpsewhich ) { # Source only if ( $_ && ! /%/ ) { $_ .= " %O %S"; } } foreach ($pdf_previewer, $ps_previewer, $ps_previewer_landscape, $dvi_previewer, $dvi_previewer_landscape, ) { # Run previewers detached if ( $_ && ! /^(nostart|NONE|internal) / ) { $_ = "start $_"; } } foreach ($biber, $bibtex) { # Base only if ( $_ && ! /%/ ) { $_ .= " %O %B"; } } foreach ($dvipdf, $ps2pdf) { # Source and dest without flag for destination if ( $_ && ! /%/ ) { $_ .= " %O %S %D"; } } foreach ($dvips, $makeindex) { # Source and dest with -o dest before source if ( $_ && ! /%/ ) { $_ .= " %O -o %D %S"; } } foreach ($dvi_filter, $ps_filter) { # Source and dest, but as filters if ( $_ && ! /%/ ) { $_ .= " %O <%S >%D"; } } } #END fix_cmds ############################################################# sub add_option { # Call add_option( $opt, \$cmd ... ) # Add option to one or more commands no strict "refs"; my $option = shift; while (@_) { if ( ${$_[0]} !~ /%/ ) { &fix_cmds; } ${$_[0]} =~ s/%O/$option %O/; shift; } } #END add_option ############################################################# sub rdb_initialize_rules { # Initialize rule database. # (The rule database may get overridden/extended after the fdb_latexmk # file is read, and after running commands to adjust to dependencies # determined from document. %rule_db = (); %target_rules = (); %target_files = (); %actives = (); %from_rules = (); local %rule_list = (); &rdb_set_rule_templates; my %rule_template = %rule_list; while ( my ($key, $value) = each %extra_rule_spec ) { $rule_template{$key} = $value; } # ???!!! REVISE foreach my $rule ( keys %rule_template ) { my ( $cmd_type, $ext_cmd, $int_cmd, $source, $dest, $base, $DUMMY, $PA_extra_gen, $PA_extra_source ) = @{$rule_template{$rule}}; if ( ! $PA_extra_gen ) { $PA_extra_gen = []; } if ( ! $PA_extra_source ) { $PA_extra_source = []; } my $needs_making = 0; # Substitute in the filename variables, since we will use # those for determining filenames. But delay expanding $cmd # until run time, in case of changes. foreach ($base, $source, $dest, @$PA_extra_gen, @$PA_extra_source ) { s/%R/$root_filename/g; s/%X/$out2_dir1/; s/%Y/$aux_dir1/; s/%Z/$out_dir1/; } foreach ($source, $dest ) { s/%B/$base/; s/%T/$texfile_name/; } rdb_create_rule( $rule, $cmd_type, $ext_cmd, $int_cmd, $DUMMY, $source, $dest, $base, $needs_making, undef, undef, 1, $PA_extra_gen, $PA_extra_source ); } # End rule iteration # At this point, all the rules are active. # The rules that are used are determined by starting with the desired # final files and going backwards in the rule network to find what rules # have to be run to make the final files. # The only problem in doing this is if there is more than one way of making # a given file. This arises only for rules that make pdf or dvi files, # since we have multiple rules for making them. # Ensure we only have one way to make pdf file, and only one active primary: # Deactivate pdf-making rules and primary rules, # then reactivating only one pdf producing rule and current primary, # setting $current_primary as side-effect. rdb_deactivate( 'dvipdf', 'ps2pdf', 'xdvipdfmx', keys %possible_primaries ); $current_primary = 'latex'; # # Activate needed non-primary pdf-making rules, set current primary (if # it isn't latex, and activate the current primary: if ($pdf_mode == 1) { $current_primary = 'pdflatex'; } elsif ($pdf_mode == 2) { rdb_activate( 'ps2pdf' ); } elsif ($pdf_mode == 3) { rdb_activate( 'dvipdf' ); } elsif ($pdf_mode == 4) { $current_primary = 'lualatex'; } elsif ($pdf_mode == 5) { rdb_activate( 'xdvipdfmx' ); $current_primary = 'xelatex'; } if ($dvi_mode == 2) { $current_primary = 'dvilualatex'; } if ($hnt_mode) { $current_primary = 'hilatex'; } if ($xdv_mode) { $current_primary = 'xelatex'; } rdb_activate( $current_primary ); if ($dvi_mode) { $target_files{$dvi_final} = 1; } if ($hnt_mode) { $target_files{$hnt_final} = 1; } if ($postscript_mode) { $target_files{$ps_final} = 1; } if ($pdf_mode) { $target_files{$pdf_final} = 1; } if ($xdv_mode) { $target_files{$xdv_final} = 1; } &rdb_set_rule_net; } # END rdb_initialize_rules #************************************************************ sub rdb_set_rule_templates { # Set up specifications for standard rules, adjusted to current conditions # Substitutions: %S = source, %D = dest, %B = this rule's base # %T = texfile, %R = root = base for latex. # %X for $out2_dir1, # %Y for $aux_dir1, %Z for $out_dir1 my $print_file = ''; my $print_cmd = 'NONE'; if ( $print_type eq 'dvi' ) { $print_file = $dvi_final2; $print_cmd = $lpr_dvi; } elsif ( $print_type eq 'pdf' ) { $print_file = $pdf_final2; $print_cmd = $lpr_pdf; } elsif ( $print_type eq 'ps' ) { $print_file = $ps_final2; $print_cmd = $lpr; } elsif ( $print_type eq 'none' ) { $print_cmd = 'NONE echo NO PRINTING CONFIGURED'; } my $view_file = ''; my $viewer = ''; my $viewer_update_method = 0; my $viewer_update_signal = undef; my $viewer_update_command = undef; if ( ($view eq 'dvi') || ($view eq 'hnt') || ($view eq 'pdf') || ($view eq 'ps') ) { no strict "refs"; $view_file = ${$view.'_final2'}; $viewer = ${$view.'_previewer'}; $viewer_update_method = ${$view.'_update_method'}; $viewer_update_signal = ${$view.'_update_signal'}; if (defined ${$view.'_update_command'}) { $viewer_update_command = ${$view.'_update_command'}; } } # Specification of internal command for viewer update: my $PA_update = ['do_update_view', $viewer_update_method, $viewer_update_signal, 0, 1]; # Base name is to be without path for *latex-type rules # With path for others. %rule_list = ( 'dvilualatex' => [ 'primary', "$dvilualatex", '', "%T", $dvi_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'hilatex' => [ 'primary', "$hilatex", '', "%T", $hnt_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'latex' => [ 'primary', "$latex", '', "%T", $dvi_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'lualatex' => [ 'primary', "$lualatex", '', "%T", $pdf_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'pdflatex' => [ 'primary', "$pdflatex", '', "%T", $pdf_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'xelatex' => [ 'primary', "$xelatex", '', "%T", $xdv_name, "%R", 1, [$aux_main, $log_name], [$aux_main] ], 'dvipdf' => [ 'external', "$dvipdf", 'do_viewfile', $dvi_final, $pdf_name, "%Z%R", 1 ], 'xdvipdfmx' => [ 'external', "$xdvipdfmx", 'do_viewfile', $xdv_final, $pdf_name, "%Z%R", 1 ], 'dvips' => [ 'external', "$dvips", 'do_viewfile', $dvi_final, $ps_name, "%Z%R", 1 ], 'dvifilter' => [ 'external', $dvi_filter, 'do_viewfile', $dvi_name, $dviF_name, "%Z%R", 1 ], 'ps2pdf' => [ 'external', "$ps2pdf", 'do_viewfile', $ps_final, $pdf_name, "%Z%R", 1 ], 'psfilter' => [ 'external', $ps_filter, 'do_viewfile', $ps_name, $psF_name, "%Z%R", 1 ], 'print' => [ 'external', "$print_cmd", 'if_source', $print_file, "", "", 1 ], 'update_view' => [ 'external', $viewer_update_command, $PA_update, $view_file, "", "", 2 ], 'view' => [ 'external', "$viewer", 'if_source', $view_file, "", "", 2 ], ); } # END rdb_set_rule_templates #************************************************************ sub rdb_set_rule_net { # Set network of rules, including links and classifications. # # ?? Problem if there are multiple rules for getting a file. Notably pdf. # Which one to choose? # ?? Problem: what if a rule is inactive, # e.g., bibtex because biber is in use, # or xelatex when pdflatex is in use # or bibtex when $bibtex_use is 0. # What if both latex and pdflatex are being used? # That has been allowed. But .aux file (also # .log file) are made by both. # Other case: package (like bibtopic) creates bbl or other file when # it doesn't exist. Later a rule is created by latexmk to make that # file. Then the rule's main destination file should have priority # over non-main generated files from other rules. our %from_rules_old; local %from_rules_old = %from_rules; %from_rules = (); # File to rule. rdb_for_actives( \&set_file_links_for_rule ); rdb_for_actives( \&rdb_set_source_rules ); &rdb_classify_rules; } #------------ sub set_file_links_for_rule { foreach my $dest ( @$PA_extra_gen, keys %$PHdest ) { if ( exists $from_rules{$dest} ) { my $old_rule = $from_rules{$dest}; if ( $old_rule eq $rule ) { # OK } elsif ( exists($possible_primaries{$old_rule}) && exists($possible_primaries{$rule}) ) { # This could be problematic. But we'll let it go, # because it is a common case for .aux and .log files # (etc), and these cases do not appear to mess up # anything (by experience). # Once we allow an active flag for rules and only # examine active rules, the only case of this that # will appear (in the absence of other problems) will # be where two primary rules are active, notably a # latex rule to make dvi and a pdflatex (or other # rule) to make pdf. } else { warn "$My_name: Possible bug:\n", " In linking rules I already set source_rules{$dest} to '$old_rule'\n", " But now I want to set it to '$rule'\n"; } } $from_rules{$dest} = $rule; } } # END set_file_links_for_rule #------------ sub rdb_set_source_rules { # This assumes rule context, and sets explicit source rules in the hash # %$PHsource_rules. These are to be rules on which the current rule # depends, but that aren't determined by using the known set of source # files of the current rule together with the known sets of destination # files for other rules. # # The standard case, and the only one used at the moment is for rules # whose **main** source file is a dvi or xdv file. These programs used # by these rules (dvips etc) do not provide easily accessible # information on the set of graphics files that they read in. # So such rules are given a source rule that is the *latex that # generates them. # # These cases need special treatment coded here and in the algorithms # in rdb_make etc. # my ($base, $path, $ext) = fileparseA( $$Psource ); our %from_rules_old; if ( ($ext eq '.dvi') || ($ext eq '.dviF') || ($ext eq '.xdv') ) { # Rules that use .dvi, .dviF, .xdv don't get all dependencies, # notably about included graphics files. # So use a pass criterion instead. my $old_rule = $from_rules_old{$$Psource}; my $new_rule = $from_rules{$$Psource}; if ( defined $old_rule && defined $new_rule && ($old_rule eq $new_rule) && defined $$PHsource_rules{$new_rule} ) { # Nothing to do: source rule is correct. } else { if ( defined $old_rule ) { delete $$PHsource_rules{$old_rule}; } if ( defined $new_rule ) { $$PHsource_rules{$new_rule} = 0; } } } } # END rdb_set_source_rules #------------ sub rdb_classify_rules { # Usage: &rdb_classify_rules # Assume the following variables are available (global or local): # Input: # %target_rules # Set to target rules # %target_files # Set to target files # %possible_primaries # Output: # @pre_primary # Array of rules # @post_primary # Array of rules # @unusual_one_time # Array of rules # @pre_primary and @post_primary are in natural order of application. my @requested_targets = &rdb_target_array; our (@classify_stack, $state); local $state = 0; # Post-primary local @classify_stack = (); @pre_primary = (); @post_primary = (); @unusual_one_time = (); rdb_recurse( \@requested_targets, \&rdb_classify1, 0,0, \&rdb_classify2 ); # Reverse, as tendency is to find last rules first. @pre_primary = reverse @pre_primary; @post_primary = reverse @post_primary; if ($diagnostics) { print "Rule classification: \n"; show_array( " Requested rules:", @requested_targets ); show_array( " Pre-primaries:", @pre_primary ); show_array( " Primary:", $current_primary ); show_array( " Post-primaries:", @post_primary ); show_array( " Inner-level one_time rules:", @unusual_one_time ); show_array( " Outer-level one_time rules:", keys %one_time ); } #end diagnostics } #END rdb_classify_rules #------------------- sub rdb_classify1 { # Helper routine for rdb_classify_rules # Applied as rule_act1 in recursion over rules # Assumes rule context, and local variables from rdb_classify_rules our (@classify_stack, $state, $depth); push @classify_stack, [$state]; if ( exists $possible_one_time{$rule} ) { # Normally, we will have already extracted the one_time rules, # and they will never be accessed here. But just in case of # problems or generalizations, we will cover all possibilities: if ($depth > 1) { warn "ONE TIME rule not at outer level '$rule'\n"; } push @unusual_one_time, $rule; } elsif ($state == 0) { if ( exists $possible_primaries{$rule} ) { $state = 1; # In primary rule } else { push @post_primary, $rule; } } else { $state = 2; # in post-primary rule push @pre_primary, $rule; } } #END rdb_classify1 #------------------- sub rdb_classify2 { # Helper routine for rdb_classify_rules # Applied as rule_act2 in recursion over rules # Assumes rule context our (@classify_stack, $state); ($state) = @{ pop @classify_stack }; } #END rdb_classify2 #================================ #************************************************************ sub set_trivial_aux_fdb { # 1. Write aux file as would be written if the tex file had no cross # cross references, etc. i.e., a minimal .aux file, as would be # written by latex with a simple document. # That saves a run of latex on such simple documents. # Before about 2020, latex only wrote one line, containing '\relax ' # in the aux file. After that a reference to the last page was # added. So now I write what is written for a one page document. # But shift file time to past, so that test_gen_file distinguishes # whether the .aux file got written during the following run of # *latex or was the one written here. # 2. Write a corresponding fdb file # 3. Provoke a run of *latex (actually of all primaries). # Use raw mode for writing aux file, so that line endings are \n. # Otherwise on Windows, the aux file file will have \r\n line endings. # Since both TeXLive and MiKTeX write \n rather than \r\n, latexmk will # unnecessarily detect a change in the aux file because of the changed # line endings, and thereby provoke a superfluous extra *latex run. open( my $aux_file, '> :raw', $aux_main ) or die "Cannot write file '$aux_main'\n"; fprint8( $aux_file, "\\relax \n" ); # The following is added by recent versions of latex for a # one page document fprint8( $aux_file, "\\gdef \\\@abspage\@last{1}\n" ); close($aux_file); # Shift aux time, so that file appears to have been generated in past, # and not in current run. Shift enough so that test_gen_file's # causality threshold doesn't cause misdiagnosis. my $aux_time = get_mtime( $aux_main ) - $filetime_causality_threshold - 3; utime $aux_time, $aux_time, $aux_main; foreach my $rule (keys %possible_primaries ) { rdb_one_rule( $rule, sub{ $$Pout_of_date = 'Initial setup'; } ); } &rdb_write( $fdb_name ); } #END set_trivial_aux_fdb #************************************************************ #### Particular actions #************************************************************ #************************************************************ sub do_cleanup { my $kind = $_[0]; if (! $kind ) { return; } my @files_to_delete = (); # Set @dirs to list of directories for generated files. # Use trick with hash to avoid duplicates. my %dirs = (); foreach ($aux_dir1, $out_dir1, $out2_dir1) { $dirs{$_} = 1; } my @dirs = keys %dirs; if (! $silent) { if ($kind == 1) { print "$My_name: Doing full clean up for '$texfile_name'\n"; } else { print "$My_name: Doing main clean up for '$texfile_name'\n", " (all but extensions @final_output_exts).\n"; } } push @files_to_delete, &get_small_cleanup; if ($kind == 1) { foreach my $dir1 (@dirs) { push @files_to_delete, cleanup_get1( $dir1, @final_output_exts ); } } # Run the hooks first, since to determine what custom deletions they # are to make, the hook subroutines may need access to files that # cleanup later deletes (log, aux, ...). run_hooks( 'cleanup' ); if ($kind == 1) { run_hooks( 'cleanup_extra_full' ); } # Names of contents of directory are longer than the name of the # directory, but contain the directory name as an initial segment. # Therefore deleting files and directories in the order given by # reverse sort deletes contents of directory before attempting to # delete the directory: unlink_or_move( reverse sort @files_to_delete ); # If the fdb file (or log, fls and/or aux files) exist, it/they will # have been used to make a changed rule database. But a cleanup # implies that we need a virgin rule database, corresponding to # current state of files (after cleanup) so we reset the rule # database and rule net: &rdb_initialize_rules; } #---------------------------------------- sub cleanup_get1 { # Usage: cleanup_get1( directory, patterns_or_exts_without_period, ... ) # Return array of files obeying the specification in the given directory. # Specifications are either extensions to be appended to root_filename # or are patterns containing %R for root_filename of job, with possible # wildcards. # Directory name must include directory separator, e.g., './' or 'output/', # or be blank, i.e., suitable for prepending to file name. # The directory and the root file name are fixed names, so I must escape # any glob metacharacters in them: my $dir = fix_pattern( shift ); my $root_fixed = fix_pattern( $root_filename ); my @files = (); foreach (@_) { my $name = ( /%R/ ? $_ : "%R.$_" ); $name =~ s/%R/${root_fixed}/; $name = $dir.$name; push @files, my_glob( "$name" ); } return @files; } #END cleanup_get1 #---------------------------------------- sub get_small_cleanup { # Get list of files to be deleted in a small cleanup. # Assume dependency information from previous run has been obtained. my @files = (); my %other_generated = (); my %cusdep_generated = (); my @index_bibtex_generated = (); my @aux_files = (); my @missing_bib_files = (); my $bibs_all_exist = 0; my %final_output_files = (); foreach (@final_output_exts) { $final_output_files{"$out_dir1$root_filename.$_"} = 1; } rdb_for_actives( sub { # Find generated files at rule level my ($base, $path, $ext) = fileparseA( $$Psource ); $base = $path.$base; if ( $rule =~ /^makeindex/ ) { push @index_bibtex_generated, $$Psource, $$Pdest, "$base.ilg"; } elsif ( $rule =~ /^(bibtex|biber)/ ) { push @index_bibtex_generated, $$Pdest, "$base.blg"; push @aux_files, $$Psource; if ( $bibtex_use == 1.5) { foreach ( keys %$PHsource ) { if ( ( /\.bib$/ ) && (! -e $_) ) { push @missing_bib_files, $_; } } } } elsif ( exists $possible_primaries{$rule} ) { foreach my $key (keys %$PHdest) { $other_generated{$key} = 1; } } elsif ( ($rule =~ /^cusdep/) && (-e $$Psource) ) { # N.B. Deleting cusdep generated files is wrong if source file doesn't exist. # But that will be taken care of in the rule-network setup. # So just have a test for safety in the elsif line, without diagnostics. foreach my $key (keys %$PHdest) { $cusdep_generated{$key} = 1; } } }, sub { # Find generated files at source file level if ( $file =~ /\.aux$/ ) { push @aux_files, $file; } } ); if ($#missing_bib_files == -1) { $bibs_all_exist = 1; } my $keep_bbl = 1; if ( ($bibtex_use > 1.6) || ( ($bibtex_use == 1.5) && ($bibs_all_exist) ) ) { $keep_bbl = 0; } if ($keep_bbl) { delete $generated_exts{'bbl'}; } # Convert some arrays to hashes, since deletions are easier to handle: my %index_bibtex_generated = (); my %aux_files = (); my %aux_files_to_save = (); foreach (@index_bibtex_generated) { $index_bibtex_generated{$_} = 1 unless ( /\.bbl$/ && ($keep_bbl) ); delete( $other_generated{$_} ); } foreach (@aux_files) { if (exists $other_generated{$_} ) { $aux_files{$_} = 1; } else { $aux_files_to_save{$_} = 1; } } foreach (keys %final_output_files) { delete $other_generated{$_}; } if ($diagnostics) { print "For deletion, files are as follows. Lists are non-exclusive.\n"; show_array( " Files specified by patterns\n" ." (explicit pattern with %R or root-filename.extension):", sort keys %generated_exts ); show_array( " Files determined from fdb file or log file that were generated by makeindex\n" ." or bibtex:", sort keys %index_bibtex_generated ); show_array( " Aux files (from analysis of rules):", keys %aux_files ); show_array( " Aux files to SAVE and not delete:", keys %aux_files_to_save ); show_array( " Other non-cusdep generated files from *latex:\n" ." (only deleted if \$cleanup_includes_generated is set and file\n" ." doesn't appear in another list):", sort keys %other_generated ); show_array( " Cusdep generated files:\n" ." (only deleted if \$cleanup_includes_cusdep_generated is set and file\n" ." doesn't appear in another list):", sort keys %cusdep_generated ); } my @clean_args = keys %generated_exts; push @files, cleanup_get1( $aux_dir1, @clean_args ); if ( $out_dir1 ne $aux_dir1 ) { push @files, cleanup_get1( $out_dir1, @clean_args ); } push @files, @std_small_cleanup_files; foreach my $file (@std_small_cleanup_files) { foreach my $dir ($aux_dir1, $out_dir1 ) { if ($dir) { push @files, "$dir$file"; } } } push @files, keys %index_bibtex_generated, keys %aux_files; if ($cleanup_includes_generated) { push @files, keys %other_generated; } if ( $cleanup_includes_cusdep_generated) { push @files, keys %cusdep_generated; } push @files, $fdb_name; return @files; } # END get_small_cleanup #************************************************************ sub do_cusdep { # Unconditional application of custom-dependency # except that rule is not applied if the source file source # does not exist, and an error is returned if the dest is not made. # # Assumes rule context for the custom-dependency, and that my first # argument is the name of the subroutine to apply my $func_name = $_[0]; my $return = 0; no strict "refs"; if ( !-e $$Psource ) { # Source does not exist. Users of this rule will need to turn # it off when custom dependencies are reset if ( !$silent ) { print "$My_name: In trying to apply custom-dependency rule\n", " to make '$$Pdest' from '$$Psource'\n", " the source file has disappeared since the last run\n"; } # Treat as successful } elsif ( !$func_name ) { warn "$My_name: Possible misconfiguration or bug:\n", " In trying to apply custom-dependency rule\n", " to make '$$Pdest' from '$$Psource'\n", " the function name is blank.\n"; } elsif ( ! defined &$func_name ) { warn "$My_name: Misconfiguration or bug,", " in trying to apply custom-dependency rule\n", " to make '$$Pdest' from '$$Psource'\n", " function name '$func_name' does not exists.\n"; } else { my $cusdep_ret = &$func_name( $$Pbase ); if ( defined $cusdep_ret && ($cusdep_ret != 0) ) { $return = $cusdep_ret; if ($return) { warn "Rule '$rule', function '$func_name'\n", " failed with return code = $return\n"; } } elsif ( !-e $$Pdest ) { # Destination non-existent, but routine failed to give an error warn "$My_name: In running custom-dependency rule\n", " to make '$$Pdest' from '$$Psource'\n", " function '$func_name' did not make the destination.\n"; $return = -1; } } return $return; } # END do_cusdep #************************************************************ sub do_viewfile { # Unconditionally make file for viewing, going through temporary file if # Assumes rule context my $return = 0; my ($base, $path, $ext) = fileparseA( $$Pdest ); if ( &view_file_via_temporary ) { if ( $$Pext_cmd =~ /%D/ ) { my $tmpfile = tempfile1( "${root_filename}_tmp", $ext ); print "$My_name: Making '$$Pdest' via temporary '$tmpfile'...\n"; $return = &Run_subst( undef, undef, undef, undef, $tmpfile ); move( $tmpfile, $$Pdest ); } else { warn "$My_name is configured to make '$$Pdest' via a temporary file\n", " but the command template '$$Pext_cmd' does not have a slot\n", " to set the destination file, so I won't use a temporary file\n"; $return = &Run_subst(); } } else { $return = &Run_subst(); } return $return; } #END do_viewfile #************************************************************ sub do_update_view { # Update viewer # Assumes rule context # Arguments: (method, signal, viewer_process) my $return = 0; # Although the process is passed as an argument, we'll need to update it. # So (FUDGE??) bypass the standard interface for the process. # We might as well do this for all the arguments. my $viewer_update_method = ${$PAint_cmd}[1]; my $viewer_update_signal = ${$PAint_cmd}[2]; my $Pviewer_process = \${$PAint_cmd}[3]; my $Pneed_to_get_viewer_process = \${$PAint_cmd}[4]; if ($viewer_update_method == 2) { if ($$Pneed_to_get_viewer_process) { $$Pviewer_process = &find_process_id( $$Psource ); if ($$Pviewer_process != 0) { $$Pneed_to_get_viewer_process = 0; } } if ($$Pviewer_process == 0) { print "$My_name: need to signal viewer for file '$$Psource', but didn't get \n", " process ID for some reason, e.g., no viewer, bad configuration, bug\n" if $diagnostics; } elsif ( defined $viewer_update_signal) { print "$My_name: signalling viewer, process ID $$Pviewer_process ", "with signal $viewer_update_signal\n" if $diagnostics; kill $viewer_update_signal, $$Pviewer_process; } else { warn "$My_name: viewer is supposed to be sent a signal\n", " but no signal is defined. Misconfiguration or bug?\n"; $return = 1; } } elsif ($viewer_update_method == 4) { if (defined $$Pext_cmd) { $return = &Run_subst(); } else { warn "$My_name: viewer is supposed to be updated by running a command,\n", " but no command is defined. Misconfiguration or bug?\n"; } } return $return; } #END do_update_view #************************************************************ sub if_source { # Unconditionally apply rule if source file exists. # Assumes rule context if ( -e $$Psource ) { return &Run_subst(); } else { warn "Needed source file '$$Psource' does not exist.\n"; return -1; } } #END if_source #************************************************************ #### Subroutines #************************************************************ #************************************************************ sub find_basename { # Finds the basename of the root file # Arguments: # 1 - Filename to breakdown # 2 - Where to place base file # 3 - Where to place tex file # Returns non-zero if tex file does not exist my $fail = 0; my ( $given_name, $base_name, $ext, $path, $tex_name, $source_name ); $given_name = $_[0]; $source_name = ''; $tex_name = $given_name; # Default name if I don't find the tex file ($base_name, $path, $ext) = fileparseB( $given_name ); # Treatment of extensions (in TeXLive 2019), with omission of path search: # Exists: always means exists as a file, i.e., not as a directory. # A. Finding of tex file: # 1. If extension is .tex and given_name exists, use it. # 2. Else if given_name.tex exists, use it. # 3. Else if given_name exists, use it. # B. The base filename is obtained by deleting the path # component and the extension. # C. The names of generated files (log, aux) are obtained by appending # .log, .aux, etc to the basename. Note that these are all in the # CURRENT directory (or the output or aux directory, as appropriate). # The drive/path part of the originally given filename is ignored. # Here we'll do: # 1. Find the tex file by the above method, if possible. # 2. If not, find a custom dependency with a source file that exists to # make the tex file so that after the tex file is made, the above # rules find the tex file. # 3. If that also fails, use kpsewhich on given_name to find the tex # file # 4. If that also fails, report non-existent tex file. if ( ($ext eq '.tex') && (-f $given_name) ) { $tex_name = "$given_name"; } elsif ( -f "$given_name.tex" ) { $tex_name = "$given_name.tex"; $base_name .= $ext; } elsif ( -f $given_name ) { $tex_name = $given_name; } elsif ( ($ext eq '.tex') && find_cus_dep( $given_name, $source_name ) ) { $tex_name = $given_name; } elsif ( find_cus_dep( "$given_name.tex", $source_name ) ) { $tex_name = "$given_name.tex"; $base_name .= $ext; } elsif ( ($ext =~ /^\..+/) && find_cus_dep( $given_name, $source_name ) ) { $tex_name = $given_name; } else { my @kpse_result = kpsewhich( $given_name ); if ($#kpse_result < 0) { $fail = 1; } else { $tex_name = $kpse_result[0]; ($base_name) = fileparseB( $tex_name ); } } $_[1] = $base_name; $_[2] = $tex_name; if ($diagnostics) { print "Given='$given_name', tex='$tex_name', base='$base_name', ext= $ext"; if ($source_name) { print ", source='$source_name'"; } print "\n"; } return $fail; } #END find_basename #************************************************************ sub make_preview_continuous { local $failure = 0; local $updated = 0; # ???!!! print "======= Need to update make_preview_continuous for target files\n"; $quell_uptodate_msgs = 1; if ( ($view eq 'dvi') || ($view eq 'hnt') || ($view eq 'pdf') || ($view eq 'ps') ) { print "Viewing $view\n"; } elsif ( $view eq 'none' ) { print "Not using a previewer\n"; $view_file = ''; } else { warn "$My_name: BUG: Invalid preview method '$view'\n"; exit 20; } my $viewer_running = 0; # No viewer known to be running yet # Get information from update_view rule my $viewer_update_method = 0; # Pointers so we can update the following: my $Pviewer_process = undef; my $Pneed_to_get_viewer_process = undef; rdb_one_rule( 'update_view', sub{ $viewer_update_method = $$PAint_cmd[1]; $Pviewer_process = \$$PAint_cmd[3]; $Pneed_to_get_viewer_process = \$$PAint_cmd[4]; } ); # Note that we don't get the previewer process number from the program # that starts it; that might only be a script to get things set up and the # actual previewer could be (and sometimes **is**) another process. if ( ($view_file ne '') && (-e $view_file) && !$new_viewer_always ) { # Is a viewer already running? # (We'll save starting up another viewer.) $$Pviewer_process = &find_process_id( $view_file ); if ( $$Pviewer_process ) { print "$My_name: Previewer is already running\n" if !$silent; $viewer_running = 1; $$Pneed_to_get_viewer_process = 0; } } # Loop forever, rebuilding .dvi and .ps as necessary. # Set $first_time to flag first run (to save unnecessary diagnostics) my $last_action_time = time(); my $timed_out = 0; CHANGE: for (my $first_time = 1; 1; $first_time = 0 ) { my %rules_to_watch = array_to_hash( &rdb_accessible ); &init_timing1; $updated = 0; $failure = 0; $failure_msg = ''; if ( $MSWin_fudge_break && ($^O eq "MSWin32") ) { # Fudge under MSWin32 ONLY, to stop perl/latexmk from # catching ctrl/C and ctrl/break, and let it only reach # downstream programs. See comments at first definition of # $MSWin_fudge_break. $SIG{BREAK} = $SIG{INT} = 'IGNORE'; } $failure = rdb_make(); if ( $MSWin_fudge_break && ($^O eq "MSWin32") ) { $SIG{BREAK} = $SIG{INT} = 'DEFAULT'; } # Start viewer if needed. if ( ($failure > 0) && (! $force_mode) ) { # No viewer yet } elsif ( ($view_file ne '') && (-e $view_file) && $updated && $viewer_running ) { # A viewer is running. Explicitly get it to update screen if we have to do it: rdb_one_rule( 'update_view', \&rdb_run1 ); } elsif ( ($view_file ne '') && (-e $view_file) && !$viewer_running ) { # Start the viewer if ( !$silent ) { if ($new_viewer_always) { print "$My_name: starting previewer for '$view_file'\n", "------------\n"; } else { print "$My_name: I have not found a previewer that ", "is already running. \n", " So I will start it for '$view_file'\n", "------------\n"; } } my $retcode = 0; rdb_one_rule( 'view', sub { $retcode = &rdb_run1;} ); if ( $retcode != 0 ) { if ($force_mode) { warn "$My_name: I could not run previewer\n"; } else { &exit_msg1( "I could not run previewer", $retcode); } } else { $viewer_running = 1; $$Pneed_to_get_viewer_process = 1; } # end analyze result of trying to run viewer } # end start viewer # Updated rule collection, and the set of rules whose source files # the WAIT loop examines for changes: &rdb_set_rule_net; %rules_to_watch = array_to_hash( &rdb_accessible ); if ( $failure > 0 ) { if ( !$failure_msg ) { $failure_msg = 'Failure to make the files correctly'; } $failure_msg =~ s/\s*$//; #Remove trailing space warn "$My_name: $failure_msg\n", " ==> You will need to change a source file before I do another run <==\n"; if ($failure_cmd) { Run_subst( $failure_cmd ); } # In the WAIT loop, we will test for changes in source files # that trigger a remake. Special considerations after an error: # 1. State of **user** source files for a rule is that before # the last run of the rule. Any changes since trigger # rerun. # 2. .aux files etc may have changed during an error run of a # rule, but no further runs were made to get them # stabilized. So they can have changed since start of # run. To avoid triggering an incorrect remake, rdb_make # has updated generated source files to their current state # after the whole make. User changes (e.g., deletion of aux # file) are still able to trigger a remake. # 3. Post_primary rules may not have been run (e.g., to make ps # and pdf from dvi). Depending on the criterion for rerun, # they may be out-of-date by some criterion, but they should # not be run until after another *latex run. Such rules # must be excluded from the rules whose source files the # WAIT loop scans for changes. # Set this up as follows: foreach (@post_primary) { delete $rules_to_watch{$_}; } } else { if ( ($#primary_warning_summary > -1) && $warning_cmd ) { Run_subst( $warning_cmd ); } elsif ( ($#primary_warning_summary > -1) && $warnings_as_errors && $failure_cmd ) { Run_subst( $failure_cmd ); } elsif ($success_cmd) { Run_subst( $success_cmd ); } } rdb_show_rule_errors(); if ($rules_list) { rdb_list(); } if ( $dependents_list && ($updated || $failure) ) { if ( open( my $deps_handle, ">$deps_file" ) ) { deps_list($deps_handle); close($deps_handle); } else { warn "Cannot open '$deps_file' for output of dependency information\n"; } } if ($show_time) { &show_timing1; }; # Now wait for a file to change... # During waiting for file changes, handle ctrl/C and ctrl/break here, # rather than letting system handle them by terminating script (and # code in the following command line to work: any script that calls # it). This allows, for example, the command cleanup in the following # command line to work: # latexmk -pvc foo; cleanup; &catch_break; our $have_break; local $have_break = 0; $last_action_time = time(); $waiting = 1; rdb_for_some( [keys %rule_db], sub{ if ($$Plast_result_info eq 'CURR') { $$Plast_result_info = 'PREV'; } } ); print "\n=== Watching for updated files. Use ctrl/C to stop ...\n"; WAIT: while (1) { sleep( $sleep_time ); if ($have_break) { last WAIT; } my %changes = (); if ( rdb_remake_needed(\%changes, 1, keys %rules_to_watch) ) { if (!$silent) { print "\n$My_name: Need to remake files.\n"; &rdb_diagnose_changes2( \%changes, "", 1 ); print "\n"; } last WAIT; } # Don't count waiting time in processing: $processing_time1 = processing_time(); # Does this do this job????!!! my $new_files = 0; rdb_for_some( [$current_primary], sub{ $new_files += &rdb_find_new_files } ); if ($new_files > 0) { print "$My_name: New file(s) found.\n"; last WAIT; } if ($have_break) { last WAIT; } if ($pvc_timeout && ( time() > $last_action_time+60*$pvc_timeout_mins ) ) { $timed_out = 1; last WAIT; } } # end WAIT: &default_break; if ($have_break) { print "$My_name: User typed ctrl/C or ctrl/break. I'll finish.\n"; return; } if ($timed_out) { print "$My_name: More than $pvc_timeout_mins mins of inactivity. I'll finish.\n"; return; } $waiting = 0; if ($diagnostics) { print "NOT WAITING\n"; } } #end infinite_loop CHANGE: } #END sub make_preview_continuous #************************************************************ sub process_rc_file { # Usage process_rc_file( rc_file, [repeat_reaction] ) # 2nd argument controls action if the the file rc_file has already been # processed: # Omitted, undef, or 0: Silently ignore. Used for processing # standard rc files (system, user, current # directory) since this situation legitimately # occurs when cwd is one of the directories # for the previously processed file. # other: Give a warning, and don't process the file # # Run rc_file whose name is given in first argument # Exit with code 0 on success # Exit with code 1 if file cannot be read or does not exist. # Stop if there is a syntax error or other problem. # PREVIOUSLY: # Exit with code 2 if is a syntax error or other problem. my ($rc_file, $repeat_reaction) = @_; my $abs_rc = abs_path($rc_file); my $ret_code = 0; if ( (!-e $rc_file) || ( ! defined $abs_rc ) ) { warn "$My_name: The rc-file '$rc_file' does not exist\n"; return 1; } elsif ( -d $rc_file ) { warn "$My_name: The supposed rc-file '$rc_file' is a directory; but it\n", " should be a normal text file\n"; return 1; } elsif ( exists $rc_files_read2{$abs_rc} ) { if ( $repeat_reaction ) { warn "$My_name: A user -r option asked me to process an rc file an extra time.\n", " Name of file = '$rc_file'\n", ( ($rc_file ne $abs_rc) ? " Abs. path = '$abs_rc'\n": ""), " I'll not process it\n"; } return 0; } else { $rc_files_read2{$abs_rc} = 1; } push @rc_files_read, $rc_file; # I could use the do function of perl, but: # 1. The preceeding -r test (in an earlier version of latexmk) to get # good diagnostics gets the wrong result under cygwin (e.g., on # /cygdrive/c/latexmk/LatexMk). I forget now (Nov. 2022) what the # problem was exactly. # 2. The do function searches directories in @INC, which is not wanted # here, where the aim is to execute code in a specific file in a # specific directory. In addition, '.' isn't in the default @INC in # current versions of Perl (Nov. 2022), so "do latexmkrc;" for # latexmkrc in cwd fails. # So I'll read the rc file and eval its contents. if ( open( my $RCH, "<", $rc_file ) ) { my $code = ''; # Read all contents of file into $code: { local $/ = undef; $code = <$RCH>;} close $RCH; if (! is_valid_utf8($code) ) { die "$My_name: Rc-file '$rc_file' is not in UTF-8 coding. You should save\n", " it in UTF-8 coding for use with current latexmk.\n"; } my $BOM = Encode::encode( 'UTF-8', "\N{U+FEFF}" ); $code =~ s/^$BOM//; no strict; # !!!??? For backward compatibility, turn off strictness for evaluating rc files. eval $code; } else { warn "$My_name: I cannot read the rc-file '$rc_file'\n"; return 1; } if ( $@ ) { # Indent each line of possibly multiline message: my $message = prefix( $@, " " ); warn "$My_name: Initialization file '$rc_file' gave an error:\n", "$message\n"; die "$My_name: Stopping because of problem with rc file\n"; # Use the following if want non-fatal error. return 2; } return 0; } #END process_rc_file #************************************************************ sub execute_code_string { # Usage execute_code_string( string_of_code ) # Run the perl code contained in first argument # Halt if there is a syntax error or other problem. # ???Should I leave the exiting to the caller (perhaps as an option)? # But I can always catch it with an eval if necessary. # That confuses ctrl/C and ctrl/break handling. my $code = $_[0]; print "$My_name: Executing initialization code specified by -e:\n", " '$code'...\n" if $diagnostics; { no strict; eval $code; } # The return value from the eval is not useful, since it is the value of # the last expression evaluated, which could be anything. # The correct test of errors is on the value of $@. if ( $@ ) { # Indent each line of possibly multiline message: my $message = prefix( $@, " " ); die "$My_name: ", "Stopping because executing following code from command line\n", " $code\n", "gave an error:\n", "$message\n"; } } #END execute_code_string #************************************************************ sub cleanup_cusdep_generated { # Remove files generated by custom dependencies rdb_for_actives( \&cleanup_one_cusdep_generated ); } #END cleanup_cusdep_generated #************************************************************ sub cleanup_one_cusdep_generated { # Remove destination file generated by one custom dependency # Assume rule context, but not that the rule is a custom dependency. # Only delete destination file if source file exists (so destination # file can be recreated) if ( $$Pcmd_type ne 'cusdep' ) { # NOT cusdep return; } if ( ! -e $$Psource ) { print "$My_name: For custom dependency '$rule',\n", " I won't delete destination file '$$Pdest'\n", " and any other generated files,\n", " because the source file '$$Psource' doesn't exist,\n", " so the destination file may not be able to be recreated\n"; return; } unlink_or_move( $$Pdest, keys %$PHdest ); } #END cleanup_one_cusdep_generated #************************************************************ #************************************************************ #************************************************************ # Error handling routines, warning routines, help #************************************************************ sub die_trace { # Call: die_trace( message ); &traceback; # argument(s) passed unchanged die "\n"; } #END die_trace #************************************************************ sub traceback { # Call: traceback() # or traceback( message ) # NOT &traceback, normally!!! my $msg = shift; if ($msg) { warn "$msg\n"; } warn "Traceback:\n"; my $i=0; # Start with immediate caller while ( my ($pack, $file, $line, $func) = caller($i++) ) { if ($func eq 'die_trace') { next; } warn " $func called from line $line\n"; } } #END traceback #************************************************************ sub exit_msg1 { # exit_msg1( error_message, retcode ) # 1. display error message # 2. exit with retcode warn "\n------------\n"; warn "$My_name: $_[0].\n"; warn "-- Use the -f option to force complete processing.\n"; my $retcode = $_[1]; if ($retcode >= 256) { # Retcode is the kind returned by system from an external command # which is 256 * command's_retcode $retcode /= 256; } exit $retcode; } #END exit_msg1 #************************************************************ sub warn_running { # Message about running program: if ( $silent ) { print "$My_name: @_\n"; } else { print "------------\n@_\n------------\n"; } } #END warn_running #************************************************************ sub exit_help # Exit giving diagnostic from arguments and how to get help. { print "\n$My_name: @_\n", "Use\n", " $my_name -help\nto get usage information\n"; exit 10; } #END exit_help #************************************************************ sub print_help { print "$My_name $version_num: Automatic LaTeX document generation routine\n\n", "Usage: $my_name [latexmk_options] [filename ...]\n\n", " Latexmk_options:\n", " -aux-directory=dir or -auxdir=dir \n", " - set name of directory for auxiliary files (aux, log)\n", " - See also the -emulate-aux-dir option\n", " -bibtex - use bibtex when needed (default)\n", " -bibtex- - never use bibtex\n", " -bibtex-cond - use bibtex when needed, but only if the bib file exists\n", " -bibtex-cond1 - use bibtex when needed, but only if the bib file exists;\n", " on cleanup delete bbl file only if bib file exists\n", " -bibfudge or -bibtexfudge - change directory to output directory when\n", " running bibtex\n", " -bibfudge- or -bibtexfudge- - don't change directory when running bibtex\n", " -commands - list commands used by $my_name for processing files\n", " -c - clean up (remove) all nonessential files, except\n", " dvi, ps and pdf files.\n", " This and the other clean-ups are instead of a regular make.\n", " -C - clean up (remove) all nonessential files\n", " including aux, dep, dvi, postscript and pdf files\n", " and file of database of file information\n", " -CA - clean up (remove) all nonessential files.\n", " Equivalent to -C option.\n", " -CF - Remove file of database of file information before doing \n", " other actions\n", " -cd - Change to directory of source file when processing it\n", " -cd- - Do NOT change to directory of source file when processing it\n", " -dependents or -deps - Show list of dependent files after processing\n", " -dependents- or -deps- - Do not show list of dependent files\n", " -deps-escape= - Set kind of escaping of spaces in names in deps file\n", " (Possible values: ", join( ' ', sort keys %deps_escape_kinds ), ")\n", " -deps-out=file - Set name of output file for dependency list,\n", " and turn on showing of dependency list\n", " -dF - Filter to apply to dvi file\n", " -dir-report - Before processing a tex file, report aux and out dir settings\n", " Report includes cwd and basename of output files\n", " -dir-report- - Before processing a tex file, do not report aux and out dir\n", " settings\n", " -dir-report-only - Report aux and out dir settings after initialization for\n", " each tex file, without compiling it\n", " -dvi - generate dvi by latex\n", " -dvilua - generate dvi by dvilualatex\n", " -dvi- - turn off required dvi\n", " -dvilualatex= - set program used for dvilualatex.\n", " (replace '' by the program name)\n", " -e - Execute specified Perl code (as part of latexmk start-up\n", " code)\n", " -emulate-aux-dir - emulate -aux-directory option for *latex\n", " This enables the -aux-directory option to work properly with TeX\n", " Live as well as MiKTeX\n", " -emulate-aux-dir- - use -aux-directory option with *latex\n", " -f - force continued processing past errors\n", " -f- - turn off forced continuing processing past errors\n", " -g - process at least one run of all rules\n", " -g- - Turn off -g and -gg\n", " -gg - Super go mode: clean out generated files (-CA), and then\n", " process files regardless of file timestamps\n", " -gt - Require at least one run of *latex independently of file state\n", " -h - print help\n", " -hnt - generate hnt by hilatex\n", " -help - print help\n", " -indexfudge or -makeindexfudge - change directory to output directory when\n", " running makeindex\n", " -indexfudge- or -makeindexfudge- - don't change directory when running\n", " makeindex\n", " -jobname=STRING - set basename of output file(s) to STRING.\n", " (Like --jobname=STRING on command line for many current\n", " implementations of latex/pdflatex.)\n", " -l - force landscape mode\n", " -l- - turn off -l\n", " -latex= - set program used for latex.\n", " (replace '' by the program name)\n", " -latexoption=