Editors like BaKoMa TeX and texpad seem to be able to recompile individual pages. I'm interested in how to makes this happen myself, but have been unable to find out how to do this.
I'm hoping that someone more knowledgeable might be able to provide some answers here, what I'm ideally looking for is a step by step process, ideally the sort that could be integrated into an editor (I assist with the development of the LaTeX Workshop VSCode extension).
AucTeX, Emacs most famous major-mode for *TeX has a TeX-command-region function, that will run a compiler on whatever part of the file previously selected with the mouse (of course you can do it with the keyboard too). You can easily check this function code within Emacs if you want to implement it.
As I am no longer an Emacs user, I just run my not-so-elegant-but-working external shell script. Should work with any texlive installation and ksh, maybe any other shell. This should certainly not be implemented in any editor.
#!/bin/ksh
#tex_region.sh first_line last_line file [master file]
#where am I?
ousuisje=$(pwd)
#is there a master file?
if [[ -s $4 ]];
then
maitre=$4;
else
maitre=$3;
fi
#copy the preamble
sed -e '/maketitle/,$d' $maitre > /tmp/$maitre ;
#copy file from line $2 to line $3
head -n $2 $3 |tail -n $(( $2 - $1 + 1 )) |\
#absolute path to graphic files
sed "/includegraphics/s:{\([^}]\+}\):{$ousuisje/\1:">> /tmp/$maitre
#add \end{document} to temporary file
echo -E "\end{document}" >> /tmp/$maitre
#goes to /tmp
cd /tmp
#checks which *latex has to be called then compile
laoulualatex=$(grep -c '^\\\usepackage{polyglossia}' $maitre)
if (( $laoulualatex == 1 )) ;
then
# if your distro is texlive, binaries should be in $TEXDIR/bin
lualatex $maitre ;
else
pdflatex $maitre ;
fi
######read the pdf with mupdf (code inspired by Vincent Lozano's framabook
###### "pour aller plus loin avec la ligne de commande")
#checks whether the pdf is opened with mupdf
pidpdf=$(ps -U dthiriet | grep mupdf | grep ${maitre%tex}pdf | cut -d' ' -f1)
if test -z $pidpdf ;
#if not, calls mupdf
then
mupdf ${maitre%tex}pdf &
else
#send a SIGHUP signal to mupdf to actualize the pdf
kill -s HUP $pidpdf ;
fi ;
#####back to my file
cd $ousuisje
PS it is better to call programs with their absolute path in a script, but I deleted them when copying my script to make this script a bit more portable.
Just to make sure: You know about having a main document and including as many parts as you wish using \include, \input, \includeonly, for details see here: When should I use \input vs. \include? . This makes recompilation rather fast.
You can even speed up compilation by using a precompiled format, see the package mylatexformat.
And you can boost that if you let latexmk compile in the background.
Maybe your editor allows an automatic saving, e.g. two seconds after you stopped typing. latexmk notices the saving and starts compiling with the precompiled format.
In the end you get an almost instantenous picture of the page where you have changed something.
To get to a real online compilation other software such as BaKoMa TeX use a modified (La-)TeX. With the newer LuaTeX it is easier to hook deep into the internals, maybe this is a route that you can investigate.
As a workaround what can be done though is to start the compilation with LaTeX up to the point of the current cursor position in your editor. Let's say your complete document looks as follows:
\documentclass{article}
\begin{document}
$1$
\newpage
$2$
[cursor position]
Some more example text.
Instead of continuing, end input here and abort the compilation, the DVI file will still get written up to this point.
\newpage
$3$
\newpage
$4$
\end{document}
It is possible to input and compile the first block with LaTeX. Then when the user takes a short break the compilation can continue and can be aborted for example at the next page. The DVI document is then almost immediately available. In the background you can then start the compilation process up to the point of the cursor again so that it does not interrupt user workflow.
With a modified LaTeX executable the first optimization would be recording the compilation process in a kind of cache, so that the part before the current page does not need to be compiled again ever unless it changes. That makes this approach also somewhat feasible, there is no programmatic way to influence the content of a previous page with code on the later pages. This sets a LaTeX file apart from e.g. a C source file where at the end of the file previous parts can be changed.
My answer may be very late. You can put % and enclose all that need not be compiled in a curly bracket. This will not be compiled
I know this is not exactly what you are looking for, but there are plugins for VIM that provide a live preview of the document.
With vim-latex-live-preview you can obtain that effect. Of course, this will only work while using VIM as your editor. I'm not an EMACS user, but I'm sure there are similar capabilities there too.
I hope this can guide you in the right direction.
\dumpcommand you are referring to is used to create new TeX format files. Beside the performance impact of dumping the format after each page, the\dumpcommand is only avaiable in the IniTeX version of TeX. So you'd first need to preload the LaTeX format to be able to process your document (if that will even work). – siracusa Aug 17 '19 at 04:46