From 5996b2e37354412180bb0da5f5107ee5f61328bf Mon Sep 17 00:00:00 2001 From: Juergen Spitzmueller Date: Sun, 27 May 2018 11:49:10 +0200 Subject: [PATCH] Unbreak bibitem citations ENGINE_TYPE_DEFAULT includes the other two types. Thus we need to check for multiple engines in parallel (and reintroduce the binary operators) --- src/TextClass.cpp | 111 +++++++++++++++++++++++++++++++++------------- 1 file changed, 79 insertions(+), 32 deletions(-) diff --git a/src/TextClass.cpp b/src/TextClass.cpp index 28b8fe8ac3..df8aebeef9 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -1050,21 +1050,31 @@ vector const & TextClass::getCiteStyles( bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add) { int const type = readCiteEngineType(lexrc); - CiteEngineType cetype = ENGINE_TYPE_DEFAULT; - if (type & ENGINE_TYPE_AUTHORYEAR) - cetype = ENGINE_TYPE_AUTHORYEAR; - else if (type & ENGINE_TYPE_NUMERICAL) - cetype = ENGINE_TYPE_NUMERICAL; + bool authoryear = (type & ENGINE_TYPE_AUTHORYEAR); + bool numerical = (type & ENGINE_TYPE_NUMERICAL); + bool defce = (type & ENGINE_TYPE_DEFAULT); - if (rt == CITE_ENGINE && !getCiteStyles(cetype).empty()) + if (rt == CITE_ENGINE) { // The cite engines are not supposed to overwrite // CiteStyle defined by the class or a module. - return true; + if (authoryear) + authoryear = getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty(); + if (numerical) + numerical = getCiteStyles(ENGINE_TYPE_NUMERICAL).empty(); + if (defce) + defce = getCiteStyles(ENGINE_TYPE_DEFAULT).empty(); + } - if (rt != CITE_ENGINE && !add) + if (rt != CITE_ENGINE && !add) { // Reset if we defined CiteStyle // from the class or a module - cite_styles_[cetype].clear(); + if (authoryear) + cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear(); + if (numerical) + cite_styles_[ENGINE_TYPE_NUMERICAL].clear(); + if (defce) + cite_styles_[ENGINE_TYPE_DEFAULT].clear(); + } string def; bool getout = false; @@ -1156,21 +1166,41 @@ bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add) cs.stardesc = stardescs[0]; if (size > 1) cs.startooltip = stardescs[1]; - if (add) - class_cite_styles_[cetype].push_back(cs); - else - cite_styles_[cetype].push_back(cs); + if (add) { + if (authoryear) + class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs); + if (numerical) + class_cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs); + if (defce) + class_cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs); + } else { + if (authoryear) + cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs); + if (numerical) + cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs); + if (defce) + cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs); + } } - // Stop here if we do AddToCiteEngine, + // If we do AddToCiteEngine, do not apply yet, // except if we have already a style to add something to - if (add && getCiteStyles(cetype).empty()) - return getout; + bool apply_ay = !add; + bool apply_num = !add; + bool apply_def = !add; + if (add) { + if (type & ENGINE_TYPE_AUTHORYEAR) + apply_ay = !getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty(); + if (type & ENGINE_TYPE_NUMERICAL) + apply_num = !getCiteStyles(ENGINE_TYPE_NUMERICAL).empty(); + if (type & ENGINE_TYPE_DEFAULT) + apply_def = !getCiteStyles(ENGINE_TYPE_DEFAULT).empty(); + } // Add the styles from AddToCiteEngine to the class' styles // (but only if they are not yet defined) for (auto const cis : class_cite_styles_) { // Only consider the current CiteEngineType - if (cis.first != cetype) + if (!(type & cis.first)) continue; for (auto const ciss : cis.second) { bool defined = false; @@ -1178,11 +1208,22 @@ bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add) for (auto const av : getCiteStyles(cis.first)) if (av.name == ciss.name) defined = true; - if (!defined) - cite_styles_[cis.first].push_back(ciss); + if (!defined) { + if (cis.first == ENGINE_TYPE_AUTHORYEAR && apply_ay) + cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(ciss); + else if (cis.first == ENGINE_TYPE_NUMERICAL && apply_num) + cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(ciss); + else if (cis.first == ENGINE_TYPE_DEFAULT && apply_def) + cite_styles_[ENGINE_TYPE_DEFAULT].push_back(ciss); + } } } - class_cite_styles_[cetype].clear(); + if (type & ENGINE_TYPE_AUTHORYEAR && apply_ay) + class_cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear(); + if (type & ENGINE_TYPE_NUMERICAL && apply_num) + class_cite_styles_[ENGINE_TYPE_NUMERICAL].clear(); + if (type & ENGINE_TYPE_DEFAULT && apply_def) + class_cite_styles_[ENGINE_TYPE_DEFAULT].clear(); return getout; } @@ -1213,12 +1254,6 @@ int TextClass::readCiteEngineType(Lexer & lexrc) const bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt) { int const type = readCiteEngineType(lexrc); - CiteEngineType cetype = ENGINE_TYPE_DEFAULT; - if (type & ENGINE_TYPE_AUTHORYEAR) - cetype = ENGINE_TYPE_AUTHORYEAR; - else if (type & ENGINE_TYPE_NUMERICAL) - cetype = ENGINE_TYPE_NUMERICAL; - string etype; string definition; // Cite engine definitions do not overwrite existing @@ -1240,24 +1275,36 @@ bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt) bool defined = false; // Check if the macro is already def'ed for (auto const cm : cite_macros_) { - if (cm.first != cetype) + if (!(type & cm.first)) continue; if (cm.second.find(etype) != cm.second.end()) defined = true; } - if (!defined || overwrite) - cite_macros_[cetype][etype] = definition; + if (!defined || overwrite) { + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL) + cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type & ENGINE_TYPE_DEFAULT) + cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition; + } } else { bool defined = false; // Check if the format is already def'ed for (auto const cm : cite_formats_) { - if (cm.first != cetype) + if (!(type & cm.first)) continue; if (cm.second.find(etype) != cm.second.end()) defined = true; } - if (!defined || overwrite) - cite_formats_[cetype][etype] = definition; + if (!defined || overwrite){ + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL) + cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type & ENGINE_TYPE_DEFAULT) + cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition; + } } } return true; -- 2.39.5