X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=a479b2803ec885382374c6c7d3f325270b06aa9e;hb=72a488d7e6b56432263c80dd92cd6acc565e03a7;hp=c14e8eea418798e1984a4662a3aa26f25dab4f2b;hpb=b24664b0ac7e41f4e3b636acf613c7fa804d36eb;p=lyx.git

diff --git a/src/output_latex.cpp b/src/output_latex.cpp
index c14e8eea41..a479b2803e 100644
--- a/src/output_latex.cpp
+++ b/src/output_latex.cpp
@@ -23,22 +23,26 @@
 #include "OutputParams.h"
 #include "Paragraph.h"
 #include "ParagraphParameters.h"
+#include "texstream.h"
 #include "TextClass.h"
-#include "TexRow.h"
 
 #include "insets/InsetBibitem.h"
 #include "insets/InsetArgument.h"
 
+#include "frontends/alert.h"
+
 #include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/lstrings.h"
 #include "support/lyxalgo.h"
 #include "support/textutils.h"
+#include "support/gettext.h"
 
 #include <QThreadStorage>
 
 #include <list>
+#include <stack>
 
 using namespace std;
 using namespace lyx::support;
@@ -58,13 +62,15 @@ enum OpenEncoding {
 struct OutputState
 {
 	OutputState() : open_encoding_(none), cjk_inherited_(0),
-		        prev_env_language_(0), open_polyglossia_lang_("")
+		        prev_env_language_(0), nest_level_(0)
 	{
 	}
-	int open_encoding_;
+	OpenEncoding open_encoding_;
 	int cjk_inherited_;
 	Language const * prev_env_language_;
-	string open_polyglossia_lang_;
+	int nest_level_;
+	stack<int> lang_switch_depth_;          // Both are always empty when
+	stack<string> open_polyglossia_lang_;   // not using polyglossia
 };
 
 
@@ -79,6 +85,50 @@ OutputState * getOutputState()
 }
 
 
+string const & openPolyglossiaLang(OutputState const * state)
+{
+	// Return a reference to the last active language opened with
+	// polyglossia. If none or when using babel, return a reference
+	// to an empty string.
+
+	static string const empty;
+
+	return state->open_polyglossia_lang_.empty()
+		? empty
+		: state->open_polyglossia_lang_.top();
+}
+
+
+bool atSameLastLangSwitchDepth(OutputState const * state)
+{
+	// Return true if the actual nest level is the same at which the
+	// language was switched when using polyglossia. Instead, return
+	// always true when using babel.
+
+	return state->lang_switch_depth_.size() == 0
+			? true
+			: abs(state->lang_switch_depth_.top()) == state->nest_level_;
+}
+
+
+bool isLocalSwitch(OutputState const * state)
+{
+	// Return true if the language was opened by the \text<lang> command.
+
+	return state->lang_switch_depth_.size()
+		&& state->lang_switch_depth_.top() < 0;
+}
+
+
+bool langOpenedAtThisLevel(OutputState const * state)
+{
+	// Return true if the language was opened at the current nesting level.
+
+	return state->lang_switch_depth_.size()
+		&& abs(state->lang_switch_depth_.top()) == state->nest_level_;
+}
+
+
 string const getPolyglossiaEnvName(Language const * lang)
 {
 	string result = lang->polyglossia();
@@ -160,9 +210,11 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 	string const lang_end_command = use_polyglossia ?
 		"\\end{$$lang}" : lyxrc.language_command_end;
 
+	// For polyglossia, switch language outside of environment, if possible.
 	if (par_lang != prev_par_lang) {
 		if (!lang_end_command.empty() &&
 		    prev_par_lang != doc_lang &&
+		    atSameLastLangSwitchDepth(state) &&
 		    !prev_par_lang.empty()) {
 			os << from_ascii(subst(
 				lang_end_command,
@@ -170,10 +222,21 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 				prev_par_lang))
 			  // the '%' is necessary to prevent unwanted whitespace
 			  << "%\n";
+			if (use_polyglossia)
+				popPolyglossiaLang();
 		}
 
+		// If no language was explicitly opened and we are using
+		// polyglossia, then the current polyglossia language is
+		// the document language.
+		string const & pol_lang = use_polyglossia
+					  && state->lang_switch_depth_.size()
+						  ? openPolyglossiaLang(state)
+						  : doc_lang;
+
 		if ((lang_end_command.empty() ||
-		    par_lang != doc_lang) &&
+		    par_lang != doc_lang ||
+		    par_lang != pol_lang) &&
 		    !par_lang.empty()) {
 			    string bc = use_polyglossia ?
 					getPolyglossiaBegin(lang_begin_command, par_lang,
@@ -182,6 +245,8 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 			    os << bc;
 			    // the '%' is necessary to prevent unwanted whitespace
 			    os << "%\n";
+			    if (use_polyglossia)
+				    pushPolyglossiaLang(par_lang);
 		}
 	}
 
@@ -194,8 +259,7 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 	}
 
 	if (style.isEnvironment()) {
-		if (par_lang != doc_lang)
-			state->open_polyglossia_lang_ = par_lang;
+		state->nest_level_ += 1;
 		os << "\\begin{" << from_ascii(style.latexname()) << '}';
 		if (!style.latexargs().empty()) {
 			OutputParams rp = runparams;
@@ -236,6 +300,7 @@ static void finishEnvironment(otexstream & os, OutputParams const & runparams,
 			      TeXEnvironmentData const & data)
 {
 	OutputState * state = getOutputState();
+	// BufferParams const & bparams = buf.params(); // FIXME: for speedup shortcut below, would require passing of "buf" as argument
 	if (state->open_encoding_ == CJK && data.cjk_nested) {
 		// We need to close the encoding even if it does not change
 		// to do correct environment nesting
@@ -244,13 +309,26 @@ static void finishEnvironment(otexstream & os, OutputParams const & runparams,
 	}
 
 	if (data.style->isEnvironment()) {
-		os << breakln
-		   << "\\end{" << from_ascii(data.style->latexname()) << "}\n";
+		os << breakln;
+		// Close any polyglossia language opened at this nest level
+		if (runparams.use_polyglossia) {
+			while (langOpenedAtThisLevel(state)) {
+				if (isLocalSwitch(state)) {
+					os << "}";
+				} else {
+					os << "\\end{"
+					   << openPolyglossiaLang(state)
+					   << "}%\n";
+				}
+				popPolyglossiaLang();
+			}
+		}
+		state->nest_level_ -= 1;
+		os << "\\end{" << from_ascii(data.style->latexname()) << "}\n";
 		state->prev_env_language_ = data.par_language;
 		if (runparams.encoding != data.prev_encoding) {
 			runparams.encoding = data.prev_encoding;
-			if (!runparams.isFullUnicode())
-				os << setEncoding(data.prev_encoding->iconvName());
+			os << setEncoding(data.prev_encoding->iconvName());
 		}
 	}
 
@@ -259,8 +337,7 @@ static void finishEnvironment(otexstream & os, OutputParams const & runparams,
 		state->prev_env_language_ = data.par_language;
 		if (runparams.encoding != data.prev_encoding) {
 			runparams.encoding = data.prev_encoding;
-			if (!runparams.isFullUnicode())
-				os << setEncoding(data.prev_encoding->iconvName());
+			os << setEncoding(data.prev_encoding->iconvName());
 		}
 	}
 
@@ -425,6 +502,25 @@ void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeX
 } // namespace anon
 
 
+void pushPolyglossiaLang(string const & lang_name, bool localswitch)
+{
+	OutputState * state = getOutputState();
+
+	int nest_level = localswitch ? -state->nest_level_ : state->nest_level_;
+	state->lang_switch_depth_.push(nest_level);
+	state->open_polyglossia_lang_.push(lang_name);
+}
+
+
+void popPolyglossiaLang()
+{
+	OutputState * state = getOutputState();
+
+	state->lang_switch_depth_.pop();
+	state->open_polyglossia_lang_.pop();
+}
+
+
 void latexArgInsets(Paragraph const & par, otexstream & os,
 	OutputParams const & runparams, Layout::LaTeXArgMap const & latexargs, string const & prefix)
 {
@@ -472,9 +568,9 @@ void latexArgInsets(ParagraphList const & pars, ParagraphList::const_iterator pi
 	// get the first paragraph in sequence with this layout and depth
 	pit_type offset = 0;
 	while (true) {
-		if (prev(pit, offset) == pars.begin())
+		if (lyx::prev(pit, offset) == pars.begin())
 			break;
-		ParagraphList::const_iterator priorpit = prev(pit, offset + 1);
+		ParagraphList::const_iterator priorpit = lyx::prev(pit, offset + 1);
 		if (priorpit->layout() == current_layout
 		    && priorpit->params().depth() == current_depth)
 			++offset;
@@ -482,7 +578,7 @@ void latexArgInsets(ParagraphList const & pars, ParagraphList::const_iterator pi
 			break;
 	}
 
-	ParagraphList::const_iterator spit = prev(pit, offset);
+	ParagraphList::const_iterator spit = lyx::prev(pit, offset);
 
 	for (; spit != pars.end(); ++spit) {
 		if (spit->layout() != current_layout || spit->params().depth() < current_depth)
@@ -638,6 +734,8 @@ void TeXOnePar(Buffer const & buf,
 
 	// This paragraph's language
 	Language const * const par_language = par.getParLanguage(bparams);
+	Language const * const nextpar_language = nextpar ?
+		nextpar->getParLanguage(bparams) : 0;
 	// The document's language
 	Language const * const doc_language = bparams.language;
 	// The language that was in effect when the environment this paragraph is
@@ -673,6 +771,9 @@ void TeXOnePar(Buffer const & buf,
 		getPolyglossiaEnvName(prev_language) : prev_language->babel();
 	string const outer_lang = use_polyglossia ?
 		getPolyglossiaEnvName(outer_language) : outer_language->babel();
+	string const nextpar_lang = nextpar_language ? (use_polyglossia ?
+		getPolyglossiaEnvName(nextpar_language) :
+		nextpar_language->babel()) : string();
 	string lang_begin_command = use_polyglossia ?
 		"\\begin{$$lang}$$opts" : lyxrc.language_command_begin;
 	string lang_end_command = use_polyglossia ?
@@ -681,7 +782,8 @@ void TeXOnePar(Buffer const & buf,
 	string lang_command_termination = "%\n";
 
 	// In some insets (such as Arguments), we cannot use \selectlanguage
-	bool const localswitch = text.inset().forceLocalFontSwitch();
+	bool const localswitch = text.inset().forceLocalFontSwitch()
+			|| (use_polyglossia && text.inset().forcePlainLayout());
 	if (localswitch) {
 		lang_begin_command = use_polyglossia ?
 			    "\\text$$lang$$opts{" : lyxrc.language_command_local;
@@ -698,12 +800,15 @@ void TeXOnePar(Buffer const & buf,
 	{
 		if (!lang_end_command.empty() &&
 		    prev_lang != outer_lang &&
-		    !prev_lang.empty())
+		    !prev_lang.empty() &&
+		    (!use_polyglossia || !style.isEnvironment()))
 		{
 			os << from_ascii(subst(lang_end_command,
 				"$$lang",
 				prev_lang))
 			   << lang_command_termination;
+			if (use_polyglossia)
+				popPolyglossiaLang();
 		}
 
 		// We need to open a new language if we couldn't close the previous
@@ -711,7 +816,9 @@ void TeXOnePar(Buffer const & buf,
 		// the previous one, if the current language is different than the
 		// outer_language (which is currently in effect once the previous one
 		// is closed).
-		if ((lang_end_command.empty() || par_lang != outer_lang)
+		if ((lang_end_command.empty() || par_lang != outer_lang
+		     || (!use_polyglossia
+			 || (style.isEnvironment() && par_lang != prev_lang)))
 			&& !par_lang.empty()) {
 			// If we're inside an inset, and that inset is within an \L or \R
 			// (or equivalents), then within the inset, too, any opposite
@@ -751,12 +858,15 @@ void TeXOnePar(Buffer const & buf,
 			}
 			// With CJK, the CJK tag has to be closed first (see below)
 			if (runparams.encoding->package() != Encoding::CJK
+			    && par_lang != openPolyglossiaLang(state)
 			    && !par_lang.empty()) {
 				string bc = use_polyglossia ?
 					  getPolyglossiaBegin(lang_begin_command, par_lang, par_language->polyglossiaOpts())
 					  : subst(lang_begin_command, "$$lang", par_lang);
 				os << bc;
 				os << lang_command_termination;
+				if (use_polyglossia)
+					pushPolyglossiaLang(par_lang, localswitch);
 			}
 		}
 	}
@@ -765,6 +875,7 @@ void TeXOnePar(Buffer const & buf,
 	// encoding, since this only affects the position of the outputted
 	// \inputencoding command; the encoding switch will occur when necessary
 	if (bparams.inputenc == "auto"
+		&& !runparams.isFullUnicode() // Xe/LuaTeX use one document-wide encoding  (see also switchEncoding())
 		&& runparams.encoding->package() != Encoding::none) {
 		// Look ahead for future encoding changes.
 		// We try to output them at the beginning of the paragraph,
@@ -807,12 +918,15 @@ void TeXOnePar(Buffer const & buf,
 				}
 				// With CJK, the CJK tag had to be closed first (see above)
 				if (runparams.encoding->package() == Encoding::CJK
+				    && par_lang != openPolyglossiaLang(state)
 				    && !par_lang.empty()) {
 					os << from_ascii(subst(
 						lang_begin_command,
 						"$$lang",
 						par_lang))
 					<< lang_command_termination;
+					if (use_polyglossia)
+						pushPolyglossiaLang(par_lang, localswitch);
 				}
 				runparams.encoding = encoding;
 			}
@@ -877,16 +991,21 @@ void TeXOnePar(Buffer const & buf,
 			latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
 		if (runparams.encoding != prev_encoding) {
 			runparams.encoding = prev_encoding;
-			if (!runparams.isFullUnicode())
-				os << setEncoding(prev_encoding->iconvName());
+			os << setEncoding(prev_encoding->iconvName());
 		}
 	}
 
 	bool pending_newline = false;
 	bool unskip_newline = false;
+	bool close_lang_switch = false;
 	switch (style.latextype) {
 	case LATEX_ITEM_ENVIRONMENT:
 	case LATEX_LIST_ENVIRONMENT:
+		if ((nextpar && par_lang != nextpar_lang
+			     && nextpar->getDepth() == par.getDepth())
+		    || (atSameLastLangSwitchDepth(state) && nextpar
+			    && nextpar->getDepth() < par.getDepth()))
+			close_lang_switch = use_polyglossia;
 		if (nextpar && par.params().depth() < nextpar->params().depth())
 			pending_newline = true;
 		break;
@@ -894,9 +1013,13 @@ void TeXOnePar(Buffer const & buf,
 		// if its the last paragraph of the current environment
 		// skip it otherwise fall through
 		if (nextpar
-			&& (nextpar->layout() != par.layout()
-		        || nextpar->params().depth() != par.params().depth()))
+		    && ((nextpar->layout() != par.layout()
+			   || nextpar->params().depth() != par.params().depth())
+			|| (!use_polyglossia || par_lang != nextpar_lang)))
+		{
+			close_lang_switch = use_polyglossia;
 			break;
+		}
 	}
 
 	// fall through possible
@@ -933,18 +1056,19 @@ void TeXOnePar(Buffer const & buf,
 		&& runparams.local_font != 0
 		&& runparams.local_font->isRightToLeft() != par_language->rightToLeft()
 		// are we about to close the language?
-		&&((nextpar && par_language->babel() != (nextpar->getParLanguage(bparams))->babel())
-		   || (runparams.isLastPar && par_language->babel() != outer_language->babel()));
+		&&((nextpar && par_lang != nextpar_lang)
+		   || (runparams.isLastPar && par_lang != outer_lang));
 
 	if (closing_rtl_ltr_environment
-	    || (runparams.isLastPar
-	        && ((!use_polyglossia && par_language->babel() != outer_language->babel())
-		    || (use_polyglossia && par_language->polyglossia() != outer_language->polyglossia())))) {
+	    || ((runparams.isLastPar || close_lang_switch)
+	        && (par_lang != outer_lang || (use_polyglossia
+						&& style.isEnvironment()
+						&& par_lang != nextpar_lang)))) {
 		// Since \selectlanguage write the language to the aux file,
 		// we need to reset the language at the end of footnote or
 		// float.
 
-		if (pending_newline)
+		if (pending_newline || close_lang_switch)
 			os << '\n';
 
 		// when the paragraph uses CJK, the language has to be closed earlier
@@ -959,7 +1083,8 @@ void TeXOnePar(Buffer const & buf,
 				string const current_lang = use_polyglossia
 					? getPolyglossiaEnvName(current_language)
 					: current_language->babel();
-				if (!current_lang.empty()) {
+				if (!current_lang.empty()
+				    && current_lang != openPolyglossiaLang(state)) {
 					string bc = use_polyglossia ?
 						    getPolyglossiaBegin(lang_begin_command, current_lang,
 									current_language->polyglossiaOpts())
@@ -967,16 +1092,34 @@ void TeXOnePar(Buffer const & buf,
 					os << bc;
 					pending_newline = !localswitch;
 					unskip_newline = !localswitch;
+					if (use_polyglossia)
+						pushPolyglossiaLang(current_lang, localswitch);
 				}
 			} else if (!par_lang.empty()) {
 				// If we are in an environment, we have to close the "outer" language afterwards
-				if (!style.isEnvironment() || state->open_polyglossia_lang_ != par_lang) {
+				string const & pol_lang = openPolyglossiaLang(state);
+				if (!style.isEnvironment()
+				    || (close_lang_switch
+					&& atSameLastLangSwitchDepth(state)
+					&& par_lang != outer_lang
+					&& (par_lang != pol_lang
+					    || (pol_lang != outer_lang
+						&& nextpar
+						&& style != nextpar->layout())))
+				    || (atSameLastLangSwitchDepth(state)
+					&& state->lang_switch_depth_.size()
+					&& pol_lang != par_lang))
+				{
+					if (use_polyglossia && !localswitch)
+						os << breakln;
 					os << from_ascii(subst(
 						lang_end_command,
 						"$$lang",
 						par_lang));
 					pending_newline = !localswitch;
 					unskip_newline = !localswitch;
+					if (use_polyglossia)
+						popPolyglossiaLang();
 				}
 			}
 		}
@@ -992,14 +1135,14 @@ void TeXOnePar(Buffer const & buf,
 			// prevent unwanted whitespace
 			os << '%';
 		if (!os.afterParbreak() && !last_was_separator)
-			os << '\n';
+			os << breakln;
 	}
 
 	// if this is a CJK-paragraph and the next isn't, close CJK
 	// also if the next paragraph is a multilingual environment (because of nesting)
 	if (nextpar
 		&& state->open_encoding_ == CJK
-		&& (nextpar->getParLanguage(bparams)->encoding()->package() != Encoding::CJK
+		&& (nextpar_language->encoding()->package() != Encoding::CJK
 		   || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams)))
 		// inbetween environments, CJK has to be closed later (nesting!)
 		&& (!style.isEnvironment() || !nextpar->layout().isEnvironment())) {
@@ -1037,14 +1180,14 @@ void TeXOnePar(Buffer const & buf,
 	}
 
 	// If this is the last paragraph, and a local_font was set upon entering
-	// the inset, and we're using "auto" or "default" encoding, the encoding
+	// the inset, and we're using "auto" or "default" encoding, and not
+	// compiling with XeTeX or LuaTeX, the encoding
 	// should be set back to that local_font's encoding.
-	// However, do not change the encoding when a fully unicode aware backend
-	// such as XeTeX is used.
 	if (runparams.isLastPar && runparams_in.local_font != 0
 	    && runparams_in.encoding != runparams_in.local_font->language()->encoding()
 	    && (bparams.inputenc == "auto" || bparams.inputenc == "default")
-	    && (!runparams.isFullUnicode())) {
+		&& !runparams.isFullUnicode()
+	   ) {
 		runparams_in.encoding = runparams_in.local_font->language()->encoding();
 		os << setEncoding(runparams_in.encoding->iconvName());
 	}
@@ -1123,9 +1266,19 @@ void latexParagraphs(Buffer const & buf,
 		{ os << "% LaTeX Output Error\n"; return; } );
 
 	BufferParams const & bparams = buf.params();
+	BufferParams const & mparams = buf.masterParams();
 
 	bool const maintext = text.isMainText();
 	bool const is_child = buf.masterBuffer() != &buf;
+	bool const multibib_child = maintext && is_child
+			&& mparams.multibib == "child";
+
+	if (multibib_child && mparams.useBiblatex())
+		os << "\\newrefsection";
+	else if (multibib_child && mparams.useBibtopic()) {
+		os << "\\begin{btUnit}\n";
+		runparams.openbtUnit = true;
+	}
 
 	// Open a CJK environment at the beginning of the main buffer
 	// if the document's language is a CJK language
@@ -1154,6 +1307,8 @@ void latexParagraphs(Buffer const & buf,
 			  : subst(lang_begin_command, "$$lang", mainlang);
 		os << bc;
 		os << '\n';
+		if (runparams.use_polyglossia)
+			pushPolyglossiaLang(mainlang);
 	}
 
 	ParagraphList const & paragraphs = text.paragraphs();
@@ -1173,6 +1328,8 @@ void latexParagraphs(Buffer const & buf,
 	bool already_title = false;
 	DocumentClass const & tclass = bparams.documentClass();
 
+	// Did we already warn about inTitle layout mixing? (we only warn once)
+	bool gave_layout_warning = false;
 	for (; pit < runparams.par_end; ++pit) {
 		lastpit = pit;
 		ParagraphList::const_iterator par = paragraphs.constIterator(pit);
@@ -1184,9 +1341,15 @@ void latexParagraphs(Buffer const & buf,
 
 		if (layout.intitle) {
 			if (already_title) {
-				LYXERR0("Error in latexParagraphs: You"
-					" should not mix title layouts"
-					" with normal ones.");
+				if (!gave_layout_warning) {
+					gave_layout_warning = true;
+					frontend::Alert::warning(_("Error in latexParagraphs"),
+							bformat(_("You are using at least one "
+							  "layout (%1$s) intended for the title, "
+							  "after using non-title layouts. This "
+							  "could lead to missing or incorrect output."
+							  ), layout.name()));
+				}
 			} else if (!was_title) {
 				was_title = true;
 				if (tclass.titletype() == TITLE_ENVIRONMENT) {
@@ -1208,6 +1371,15 @@ void latexParagraphs(Buffer const & buf,
 			was_title = false;
 		}
 
+		if (layout.isCommand() && !layout.latexname().empty()
+		    && layout.latexname() == bparams.multibib) {
+			if (runparams.openbtUnit)
+				os << "\\end{btUnit}\n";
+			if (!bparams.useBiblatex()) {
+				os << '\n' << "\\begin{btUnit}\n";
+				runparams.openbtUnit = true;
+			}
+		}
 
 		if (!layout.isEnvironment() && par->params().leftIndent().zero()) {
 			// This is a standard top level paragraph, TeX it and continue.
@@ -1240,8 +1412,11 @@ void latexParagraphs(Buffer const & buf,
 		}
 	}
 
+	if (maintext && !is_child && runparams.openbtUnit)
+		os << "\\end{btUnit}\n";
+
 	// if "auto end" is switched off, explicitly close the language at the end
-	// but only if the last par is in a babel language
+	// but only if the last par is in a babel or polyglossia language
 	string const lang_end_command = runparams.use_polyglossia ?
 		"\\end{$$lang}" : lyxrc.language_command_end;
 	if (maintext && !lyxrc.language_auto_end && !mainlang.empty() &&
@@ -1250,6 +1425,8 @@ void latexParagraphs(Buffer const & buf,
 					"$$lang",
 					mainlang))
 			<< '\n';
+		if (runparams.use_polyglossia)
+			popPolyglossiaLang();
 	}
 
 	// If the last paragraph is an environment, we'll have to close
@@ -1259,9 +1436,14 @@ void latexParagraphs(Buffer const & buf,
 		state->open_encoding_ = none;
 	}
 	// Likewise for polyglossia
-	if (maintext && !is_child && state->open_polyglossia_lang_ != "") {
-		os << "\\end{" << state->open_polyglossia_lang_ << "}\n";
-		state->open_polyglossia_lang_ = "";
+	string const & pol_lang = openPolyglossiaLang(state);
+	if (maintext && !is_child && !pol_lang.empty()) {
+		os << from_utf8(subst(lang_end_command,
+					"$$lang",
+					pol_lang))
+		   << '\n';
+		if (runparams.use_polyglossia)
+			popPolyglossiaLang();
 	}
 
 	// reset inherited encoding
@@ -1270,6 +1452,11 @@ void latexParagraphs(Buffer const & buf,
 		if (state->cjk_inherited_ == 0)
 			state->open_encoding_ = CJK;
 	}
+
+	if (multibib_child && mparams.useBibtopic()) {
+		os << "\\end{btUnit}\n";
+		runparams.openbtUnit = false;
+	}
 }
 
 
@@ -1277,6 +1464,13 @@ pair<bool, int> switchEncoding(odocstream & os, BufferParams const & bparams,
 		   OutputParams const & runparams, Encoding const & newEnc,
 		   bool force)
 {
+	// XeTeX/LuaTeX use only one encoding per document:
+	// * with useNonTeXFonts: "utf8plain",
+	// * with XeTeX and TeX fonts: "ascii" (inputenc fails),
+	// * with LuaTeX and TeX fonts: only one encoding accepted by luainputenc.
+	if (runparams.isFullUnicode())
+		return make_pair(false, 0);
+
 	Encoding const & oldEnc = *runparams.encoding;
 	bool moving_arg = runparams.moving_arg;
 	// If we switch from/to CJK, we need to switch anyway, despite custom inputenc