X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=4124d2dd1c92fde9f5cf08cb62ca29808ed1277f;hb=b5722962fb0393299e02df0b146522770e98aef6;hp=3489a11bb69221570c6542fa1631014c68a5702c;hpb=45e0ce2372467516355d81bbba4a5852d9569f98;p=lyx.git diff --git a/src/output_latex.cpp b/src/output_latex.cpp index 3489a11bb6..4124d2dd1c 100644 --- a/src/output_latex.cpp +++ b/src/output_latex.cpp @@ -12,6 +12,7 @@ #include "output_latex.h" +#include "BiblioInfo.h" #include "Buffer.h" #include "BufferParams.h" #include "Encoding.h" @@ -63,7 +64,7 @@ enum OpenEncoding { struct OutputState { OutputState() : open_encoding_(none), cjk_inherited_(0), - prev_env_language_(0), nest_level_(0) + prev_env_language_(nullptr), nest_level_(0) { } OpenEncoding open_encoding_; @@ -191,7 +192,7 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf, pit == paragraphs.begin() ? pit : prev(pit, 1); OutputState * state = getOutputState(); - bool const use_prev_env_language = state->prev_env_language_ != 0 + bool const use_prev_env_language = state->prev_env_language_ != nullptr && priorpit->layout().isEnvironment() && (priorpit->getDepth() > pit->getDepth() || (priorpit->getDepth() == pit->getDepth() @@ -304,8 +305,11 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf, // in multilingual environments, the CJK tags have to be nested properly data.cjk_nested = false; - if (data.par_language->encoding()->package() == Encoding::CJK && - state->open_encoding_ != CJK && pit->isMultiLingual(bparams)) { + if (!bparams.useNonTeXFonts + && (bparams.inputenc == "auto-legacy" + || bparams.inputenc == "auto-legacy-plain") + && data.par_language->encoding()->package() == Encoding::CJK + && state->open_encoding_ != CJK && pit->isMultiLingual(bparams)) { if (prev_par_language->encoding()->package() == Encoding::CJK) { os << "\\begin{CJK}{" << from_ascii(data.par_language->encoding()->latexName()) @@ -675,8 +679,12 @@ void parStartCommand(Paragraph const & par, otexstream & os, { switch (style.latextype) { case LATEX_COMMAND: - if (par.needsCProtection(runparams.moving_arg)) + if (par.needsCProtection(runparams.moving_arg)) { + if (contains(runparams.active_chars, '^')) + // cprotect relies on ^ being on catcode 7 + os << "\\begingroup\\catcode`\\^=7"; os << "\\cprotect"; + } os << '\\' << from_ascii(style.latexname()); // Command arguments @@ -739,7 +747,7 @@ void TeXOnePar(Buffer const & buf, OutputParams runparams = runparams_in; runparams.isLastPar = (pit == pit_type(paragraphs.size() - 1)); - // We reinitialze par begin and end to be on the safe side + // We reinitialize par begin and end to be on the safe side // with embedded inset as we don't know if they set those // value correctly. runparams.par_begin = 0; @@ -759,7 +767,7 @@ void TeXOnePar(Buffer const & buf, Font const outerfont = text.outerFont(pit); // No newline before first paragraph in this lyxtext - if (pit > 0) { + if (pit > 0 && !text.inset().getLayout().parbreakIgnored()) { os << '\n'; if (!text.inset().getLayout().parbreakIsNewline()) os << '\n'; @@ -770,9 +778,9 @@ void TeXOnePar(Buffer const & buf, } Paragraph const * nextpar = runparams.isLastPar - ? 0 : ¶graphs.at(pit + 1); + ? nullptr : ¶graphs.at(pit + 1); - bool const intitle_command = style.intitle && style.latextype == LATEX_COMMAND; + bool const intitle_command = style.intitle && style.isCommand(); if (style.pass_thru) { Font const outerfont = text.outerFont(pit); @@ -790,8 +798,13 @@ void TeXOnePar(Buffer const & buf, // I did not create a parEndCommand for this minuscule // task because in the other user of parStartCommand // the code is different (JMarc) - if (style.isCommand()) - os << "}\n"; + if (style.isCommand()) { + os << "}"; + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; + os << "\n"; + } else os << '\n'; if (!style.parbreak_is_newline) { @@ -810,16 +823,16 @@ 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; + nextpar->getParLanguage(bparams) : nullptr; // The document's language Language const * const doc_language = bparams.language; // The language that was in effect when the environment this paragraph is // inside of was opened Language const * const outer_language = - (runparams.local_font != 0) ? + (runparams.local_font != nullptr) ? runparams.local_font->language() : doc_language; - Paragraph const * priorpar = (pit == 0) ? 0 : ¶graphs.at(pit - 1); + Paragraph const * priorpar = (pit == 0) ? nullptr : ¶graphs.at(pit - 1); // The previous language that was in effect is the language of the // previous paragraph, unless the previous paragraph is inside an @@ -829,19 +842,36 @@ void TeXOnePar(Buffer const & buf, // Note further that we take the outer language also if the prior par // is PassThru, since in that case it has latex_language, and all secondary // languages have been closed (#10793). - bool const use_prev_env_language = state->prev_env_language_ != 0 + bool const use_prev_env_language = state->prev_env_language_ != nullptr && priorpar && priorpar->layout().isEnvironment() && (priorpar->getDepth() > par.getDepth() || (priorpar->getDepth() == par.getDepth() - && priorpar->layout() != par.layout())); + && priorpar->layout() != par.layout())); + + // We need to ignore previous intitle commands since languages + // are switched locally there (# 11514) + // There might be paragraphs before the title, so we check this. + Paragraph * prior_nontitle_par = nullptr; + if (!intitle_command) { + pit_type ppit = pit; + while (ppit > 0) { + --ppit; + Paragraph const * tmppar = ¶graphs.at(ppit); + if (tmppar->layout().intitle && tmppar->layout().isCommand()) + continue; + prior_nontitle_par = const_cast(tmppar); + break; + } + } Language const * const prev_language = - runparams_in.for_search ? - languages.getLanguage("ignore") - :(priorpar && !priorpar->isPassThru()) - ? (use_prev_env_language ? state->prev_env_language_ - : priorpar->getParLanguage(bparams)) - : outer_language; + runparams_in.for_search + ? languages.getLanguage("ignore") + : (prior_nontitle_par && !prior_nontitle_par->isPassThru()) + ? (use_prev_env_language + ? state->prev_env_language_ + : prior_nontitle_par->getParLanguage(bparams)) + : outer_language; bool const use_polyglossia = runparams.use_polyglossia; string const par_lang = use_polyglossia ? @@ -880,7 +910,7 @@ void TeXOnePar(Buffer const & buf, // languages (see # 10111). bool const in_polyglossia_rtl_env = use_polyglossia - && runparams.local_font != 0 + && runparams.local_font != nullptr && outer_language->rightToLeft() && !par_language->rightToLeft(); bool const localswitch = runparams_in.for_search @@ -936,7 +966,7 @@ void TeXOnePar(Buffer const & buf, && par_language->lang() != "arabic_arabtex" && outer_language->lang() != "arabic_arabtex" // are we in an inset? - && runparams.local_font != 0 + && runparams.local_font != nullptr // is the inset within an \L or \R? // // FIXME: currently, we don't check this; this means that @@ -963,8 +993,10 @@ void TeXOnePar(Buffer const & buf, os << "\\L{"; } // With CJK, the CJK tag has to be closed first (see below) - if ((runparams.encoding->package() != Encoding::CJK || runparams.for_search) - && (par_lang != openLanguageName(state) || localswitch) + if ((runparams.encoding->package() != Encoding::CJK + || bparams.useNonTeXFonts + || runparams.for_search) + && (par_lang != openLanguageName(state) || localswitch || intitle_command) && !par_lang.empty()) { string bc = use_polyglossia ? getPolyglossiaBegin(lang_begin_command, par_lang, @@ -979,11 +1011,12 @@ void TeXOnePar(Buffer const & buf, } } - // Switch file encoding if necessary; no need to do this for "default" + // Switch file encoding if necessary; no need to do this for "auto-legacy-plain" // encoding, since this only affects the position of the outputted // \inputencoding command; the encoding switch will occur when necessary - if (bparams.inputenc == "auto" + if (bparams.inputenc == "auto-legacy" && !runparams.isFullUnicode() // Xe/LuaTeX use one document-wide encoding (see also switchEncoding()) + && runparams.encoding->package() != Encoding::japanese && runparams.encoding->package() != Encoding::none) { // Look ahead for future encoding changes. // We try to output them at the beginning of the paragraph, @@ -1029,12 +1062,7 @@ void TeXOnePar(Buffer const & buf, if (runparams.encoding->package() == Encoding::CJK && par_lang != openLanguageName(state) && !par_lang.empty()) { - string bc = use_polyglossia ? - getPolyglossiaBegin(lang_begin_command, par_lang, - par_language->polyglossiaOpts(), - localswitch) - : subst(lang_begin_command, "$$lang", par_lang); - os << bc + os << subst(lang_begin_command, "$$lang", par_lang) << lang_command_termination; if (using_begin_end) pushLanguageName(par_lang, localswitch); @@ -1114,6 +1142,9 @@ void TeXOnePar(Buffer const & buf, os << runparams.post_macro; runparams.post_macro.clear(); } + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; if (runparams.encoding != prev_encoding) { runparams.encoding = prev_encoding; os << setEncoding(prev_encoding->iconvName()); @@ -1133,10 +1164,10 @@ void TeXOnePar(Buffer const & buf, && nextpar->getDepth() < par.getDepth())) close_lang_switch = using_begin_end; if (nextpar && par.params().depth() < nextpar->params().depth()) - pending_newline = true; + pending_newline = !text.inset().getLayout().parbreakIgnored(); break; case LATEX_ENVIRONMENT: { - // if its the last paragraph of the current environment + // if it's the last paragraph of the current environment // skip it otherwise fall through if (nextpar && ((nextpar->layout() != par.layout() @@ -1152,7 +1183,7 @@ void TeXOnePar(Buffer const & buf, default: // we don't need it for the last paragraph and in InTitle commands!!! if (nextpar && !intitle_command) - pending_newline = true; + pending_newline = !text.inset().getLayout().parbreakIgnored(); } // InTitle commands use switches (not environments) for space settings @@ -1181,7 +1212,7 @@ void TeXOnePar(Buffer const & buf, && (par_language->lang() != "arabic_arabtex" && outer_language->lang() != "arabic_arabtex") // have we opened an \L or \R environment? - && runparams.local_font != 0 + && runparams.local_font != nullptr && runparams.local_font->isRightToLeft() != par_language->rightToLeft() // are we about to close the language? &&((nextpar && par_lang != nextpar_lang) @@ -1190,7 +1221,7 @@ void TeXOnePar(Buffer const & buf, if (localswitch_needed || (intitle_command && using_begin_end) || closing_rtl_ltr_environment - || ((runparams.isLastPar || close_lang_switch) + || (((runparams.isLastPar && !runparams.inbranch) || close_lang_switch) && (par_lang != outer_lang || (using_begin_end && style.isEnvironment() && par_lang != nextpar_lang)))) { @@ -1202,7 +1233,9 @@ void TeXOnePar(Buffer const & buf, os << '\n'; // when the paragraph uses CJK, the language has to be closed earlier - if ((font.language()->encoding()->package() != Encoding::CJK) || runparams_in.for_search) { + if ((font.language()->encoding()->package() != Encoding::CJK) + || bparams.useNonTeXFonts + || runparams_in.for_search) { if (lang_end_command.empty()) { // If this is a child, we should restore the // master language after the last paragraph. @@ -1221,7 +1254,8 @@ void TeXOnePar(Buffer const & buf, localswitch) : subst(lang_begin_command, "$$lang", current_lang); os << bc; - pending_newline = !localswitch; + pending_newline = !localswitch + && !text.inset().getLayout().parbreakIgnored(); unskip_newline = !localswitch; if (using_begin_end) pushLanguageName(current_lang, localswitch); @@ -1251,7 +1285,8 @@ void TeXOnePar(Buffer const & buf, lang_end_command, "$$lang", par_lang)); - pending_newline = !localswitch; + pending_newline = !localswitch + && !text.inset().getLayout().parbreakIgnored(); unskip_newline = !localswitch; if (using_begin_end) popLanguageName(); @@ -1264,20 +1299,21 @@ void TeXOnePar(Buffer const & buf, // InTitle commands need to be closed after the language has been closed. if (intitle_command) { - if (is_command) { - os << '}'; - if (!style.postcommandargs().empty()) - latexArgInsets(par, os, runparams, style.postcommandargs(), "post:"); - if (!runparams.post_macro.empty()) { - // Output the stored fragile commands (labels, indices etc.) - // that need to be output after the command with moving argument. - os << runparams.post_macro; - runparams.post_macro.clear(); - } - if (runparams.encoding != prev_encoding) { - runparams.encoding = prev_encoding; - os << setEncoding(prev_encoding->iconvName()); - } + os << '}'; + if (!style.postcommandargs().empty()) + latexArgInsets(par, os, runparams, style.postcommandargs(), "post:"); + if (!runparams.post_macro.empty()) { + // Output the stored fragile commands (labels, indices etc.) + // that need to be output after the command with moving argument. + os << runparams.post_macro; + runparams.post_macro.clear(); + } + if (par.needsCProtection(runparams.moving_arg) + && contains(runparams.active_chars, '^')) + os << "\\endgroup"; + if (runparams.encoding != prev_encoding) { + runparams.encoding = prev_encoding; + os << setEncoding(prev_encoding->iconvName()); } } @@ -1294,11 +1330,11 @@ void TeXOnePar(Buffer const & buf, // 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 && bparams.encoding().iconvName() != "UTF-8" - && bparams.encoding().package() != Encoding::CJK ) + if (nextpar && state->open_encoding_ == CJK + && bparams.encoding().iconvName() != "UTF-8" + && bparams.encoding().package() != Encoding::CJK && (nextpar_language->encoding()->package() != Encoding::CJK - || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) + || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) // inbetween environments, CJK has to be closed later (nesting!) && (!style.isEnvironment() || !nextpar->layout().isEnvironment())) { os << "\\end{CJK}\n"; @@ -1325,6 +1361,12 @@ void TeXOnePar(Buffer const & buf, break; } case inputenc: { + // FIXME: If we are in an inset and the switch happened outside this inset, + // do not switch back at the end of the inset (bug #8479) + // The following attempt does not help with listings-caption in a CJK document: + // if (runparams_in.local_font != 0 + // && runparams_in.encoding == runparams_in.local_font->language()->encoding()) + // break; os << "\\egroup"; state->open_encoding_ = none; break; @@ -1336,13 +1378,13 @@ 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, and not - // compiling with XeTeX or LuaTeX, the encoding - // should be set back to that local_font's encoding. - if (runparams.isLastPar && runparams_in.local_font != 0 + // Information about local language is stored as a font feature. + // If this is the last paragraph of the inset and a local_font was set upon entering + // and we are mixing encodings ("auto-legacy" or "auto-legacy-plain" and no XeTeX or LuaTeX), + // ensure the encoding is set back to the default encoding of the local language. + if (runparams.isLastPar && runparams_in.local_font != nullptr && runparams_in.encoding != runparams_in.local_font->language()->encoding() - && (bparams.inputenc == "auto" || bparams.inputenc == "default") + && (bparams.inputenc == "auto-legacy" || bparams.inputenc == "auto-legacy-plain") && !runparams.isFullUnicode() ) { runparams_in.encoding = runparams_in.local_font->language()->encoding(); @@ -1360,9 +1402,10 @@ void TeXOnePar(Buffer const & buf, // Note from JMarc: we will re-add a \n explicitly in // TeXEnvironment, because it is needed in this case if (nextpar && !os.afterParbreak() && !last_was_separator) { - // Make sure to start a new line - os << breakln; Layout const & next_layout = nextpar->layout(); + if (!text.inset().getLayout().parbreakIgnored()) + // Make sure to start a new line + os << breakln; // A newline '\n' is always output before a command, // so avoid doubling it. if (!next_layout.isCommand()) { @@ -1386,22 +1429,23 @@ void TeXOnePar(Buffer const & buf, if ((style == next_layout && !style.parbreak_is_newline && !text.inset().getLayout().parbreakIsNewline() + && !text.inset().getLayout().parbreakIgnored() && style.latextype != LATEX_ITEM_ENVIRONMENT && style.latextype != LATEX_LIST_ENVIRONMENT - && style.align == par.getAlign() + && style.align == par.getAlign(bparams) && nextpar->getDepth() == par.getDepth() - && nextpar->getAlign() == par.getAlign()) + && nextpar->getAlign(bparams) == par.getAlign(bparams)) || (!next_layout.isEnvironment() && nextpar->getDepth() > par.getDepth() - && nextpar->getAlign() == next_layout.align) + && nextpar->getAlign(bparams) == next_layout.align) || (!style.isEnvironment() && next_layout.latextype == LATEX_ENVIRONMENT && nextpar->getDepth() < par.getDepth()) || (style.isCommand() && !next_layout.isEnvironment() - && style.align == par.getAlign() - && next_layout.align == nextpar->getAlign()) - || (style.align != par.getAlign() + && style.align == par.getAlign(bparams) + && next_layout.align == nextpar->getAlign(bparams)) + || (style.align != par.getAlign(bparams) && tclass.isDefaultLayout(next_layout))) { os << '\n'; } @@ -1435,7 +1479,8 @@ void latexParagraphs(Buffer const & buf, if (multibib_child && mparams.useBiblatex()) os << "\\newrefsection"; - else if (multibib_child && mparams.useBibtopic()) { + else if (multibib_child && mparams.useBibtopic() + && !buf.masterBibInfo().empty()) { os << "\\begin{btUnit}\n"; runparams.openbtUnit = true; } @@ -1451,7 +1496,8 @@ void latexParagraphs(Buffer const & buf, && runparams.use_CJK)) ) { docstring const cjkenc = bparams.encoding().iconvName() == "UTF-8" - ? from_ascii("UTF8") : from_ascii(bparams.encoding().latexName()); + ? from_ascii("UTF8") + : from_ascii(bparams.encoding().latexName()); os << "\\begin{CJK}{" << cjkenc << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n"; state->open_encoding_ = CJK; @@ -1545,7 +1591,8 @@ void latexParagraphs(Buffer const & buf, && layout.latexname() == bparams.multibib) { if (runparams.openbtUnit) os << "\\end{btUnit}\n"; - if (!bparams.useBiblatex()) { + if (!bparams.useBiblatex() + && !buf.masterBibInfo().empty()) { os << '\n' << "\\begin{btUnit}\n"; runparams.openbtUnit = true; } @@ -1564,6 +1611,7 @@ void latexParagraphs(Buffer const & buf, finishEnvironment(os, runparams, data); } + // FIXME: uncomment the content or remove this block if (pit == runparams.par_end) { // Make sure that the last paragraph is // correctly terminated (because TeXOnePar does @@ -1587,8 +1635,10 @@ void latexParagraphs(Buffer const & buf, // if "auto end" is switched off, explicitly close the language at the end // but only if the last par is in a babel or polyglossia language + Language const * const lastpar_language = + paragraphs.at(lastpit).getParLanguage(bparams); if (maintext && !lyxrc.language_auto_end && !mainlang.empty() && - paragraphs.at(lastpit).getParLanguage(bparams)->encoding()->package() != Encoding::CJK) { + lastpar_language->encoding()->package() != Encoding::CJK) { os << from_utf8(subst(lang_end_command, "$$lang", mainlang)) @@ -1604,14 +1654,29 @@ void latexParagraphs(Buffer const & buf, state->open_encoding_ = none; } // Likewise for polyglossia or when using begin/end commands + // or at the very end of an active branch inset with a language switch + Language const * const outer_language = (runparams.local_font != nullptr) + ? runparams.local_font->language() : bparams.language; + string const & prev_lang = runparams.use_polyglossia + ? getPolyglossiaEnvName(outer_language) + : outer_language->babel(); + string const lastpar_lang = runparams.use_polyglossia ? + getPolyglossiaEnvName(lastpar_language): lastpar_language->babel(); string const & cur_lang = openLanguageName(state); - if (maintext && !is_child && !cur_lang.empty()) { + if (((runparams.inbranch && langOpenedAtThisLevel(state) && prev_lang != cur_lang) + || (maintext && !is_child)) && !cur_lang.empty()) { os << from_utf8(subst(lang_end_command, "$$lang", cur_lang)) << '\n'; if (using_begin_end) popLanguageName(); + } else if (runparams.inbranch && !using_begin_end + && prev_lang != lastpar_lang && !lastpar_lang.empty()) { + // with !using_begin_end, cur_lang is empty, so we need to + // compare against the paragraph language (and we are in the + // last paragraph at this point) + os << subst(lang_begin_command, "$$lang", prev_lang) << '\n'; } // reset inherited encoding @@ -1627,44 +1692,44 @@ void latexParagraphs(Buffer const & buf, } } - +// Switch the input encoding for some part(s) of the document. pair switchEncoding(odocstream & os, BufferParams const & bparams, OutputParams const & runparams, Encoding const & newEnc, bool force, bool noswitchmacro) { - // 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. + // Never switch encoding with XeTeX/LuaTeX + // or if we're in a moving argument or inherit the outer encoding. if (runparams.isFullUnicode() || newEnc.name() == "inherit") + return make_pair(false, 0); + + // Only switch for auto-selected legacy encodings (inputenc setting + // "auto-legacy" or "auto-legacy-plain"). + // The "listings" environment can force a switch also with other + // encoding settings (it does not support variable width encodings + // (utf8, jis, ...) under 8-bit latex engines). + if (!force && ((bparams.inputenc != "auto-legacy" && bparams.inputenc != "auto-legacy-plain") + || runparams.moving_arg)) return make_pair(false, 0); Encoding const & oldEnc = *runparams.encoding; - bool moving_arg = runparams.moving_arg; - if (!force - && ((bparams.inputenc != "auto" && bparams.inputenc != "default") || moving_arg)) + // Do not switch, if the encoding is unchanged or switching is not supported. + if (oldEnc.name() == newEnc.name() + || oldEnc.package() == Encoding::japanese + || oldEnc.package() == Encoding::none + || newEnc.package() == Encoding::none + || runparams.for_search) return make_pair(false, 0); - - // Do nothing if the encoding is unchanged. - if (oldEnc.name() == newEnc.name()) - return make_pair(false, 0); - // FIXME We ignore encoding switches from/to encodings that do // neither support the inputenc package nor the CJK package here. - // This does of course only work in special cases (e.g. switch from - // tis620-0 to latin1, but the text in latin1 contains ASCII only), - // but it is the best we can do - // - // 2019-01-08 Possibly no longer required since tis620-0 is supported - // by inputenc (but check special encodings "utf8-plain" and "default"). - if (oldEnc.package() == Encoding::none || newEnc.package() == Encoding::none) - return make_pair(false, 0); + // This may fail for characters not supported by "unicodesymbols" + // or for non-ASCII characters in "listings" + // but it is the best we can do. // change encoding LYXERR(Debug::LATEX, "Changing LaTeX encoding from " << oldEnc.name() << " to " << newEnc.name()); os << setEncoding(newEnc.iconvName()); - if (bparams.inputenc == "default") + if (bparams.inputenc == "auto-legacy-plain") return make_pair(true, 0); docstring const inputenc_arg(from_ascii(newEnc.latexName())); @@ -1672,7 +1737,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, switch (newEnc.package()) { case Encoding::none: case Encoding::japanese: - // shouldn't ever reach here, see above + // shouldn't ever reach here (see above) but avoids warning. return make_pair(true, 0); case Encoding::inputenc: { int count = inputenc_arg.length(); @@ -1688,7 +1753,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, state->open_encoding_ = none; count += 7; } - if (runparams.local_font != 0 + if (runparams.local_font != nullptr && oldEnc.package() == Encoding::CJK) { // within insets, \inputenc switches need // to be embraced within \bgroup...\egroup; @@ -1697,8 +1762,7 @@ pair switchEncoding(odocstream & os, BufferParams const & bparams, count += 7; state->open_encoding_ = inputenc; } - // with the japanese option, inputenc is omitted. - if (runparams.use_japanese || noswitchmacro) + if (noswitchmacro) return make_pair(true, count); os << "\\inputencoding{" << inputenc_arg << '}'; return make_pair(true, count + 16);