X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=eb92612d847b6d9bad0ead06aa018324b53164fe;hb=9d8a45b5c055ef49e45c34ba0d751a0256d97e15;hp=e1e40272ea0651b71c21a9f657feead535c7cf56;hpb=fd1ee3b424786db6428bd9e39cad9a79071f9482;p=lyx.git diff --git a/src/TextClass.cpp b/src/TextClass.cpp index e1e40272ea..eb92612d84 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -17,6 +17,7 @@ #include "TextClass.h" #include "LayoutFile.h" +#include "CiteEnginesList.h" #include "Color.h" #include "Counters.h" #include "Floating.h" @@ -61,44 +62,39 @@ namespace lyx { // You should also run the development/tools/updatelayouts.py script, // to update the format of all of our layout files. // -int const LAYOUT_FORMAT = 60; //lasgouttes LongTableNoNumber => Unnumbered +int const LAYOUT_FORMAT = 82; // dourouc05: DocBook additions. -namespace { -class LayoutNamesEqual : public unary_function { -public: - LayoutNamesEqual(docstring const & name) - : name_(name) - {} - bool operator()(Layout const & c) const - { - return c.name() == name_; - } -private: - docstring name_; -}; +// Layout format for the current lyx file format. Controls which format is +// targeted by Local Layout > Convert. In master, equal to LAYOUT_FORMAT. +int const LYXFILE_LAYOUT_FORMAT = LAYOUT_FORMAT; + +namespace { -bool layout2layout(FileName const & filename, FileName const & tempfile) +bool layout2layout(FileName const & filename, FileName const & tempfile, + int const format = LAYOUT_FORMAT) { FileName const script = libFileSearch("scripts", "layout2layout.py"); if (script.empty()) { LYXERR0("Could not find layout conversion " - "script layout2layout.py."); + "script layout2layout.py."); return false; } ostringstream command; command << os::python() << ' ' << quoteName(script.toFilesystemEncoding()) - << ' ' << quoteName(filename.toFilesystemEncoding()) - << ' ' << quoteName(tempfile.toFilesystemEncoding()); + << " -t " << format + << ' ' << quoteName(filename.toFilesystemEncoding()) + << ' ' << quoteName(tempfile.toFilesystemEncoding()); string const command_str = command.str(); LYXERR(Debug::TCLASS, "Running `" << command_str << '\''); cmd_ret const ret = runCommand(command_str); if (ret.first != 0) { - LYXERR0("Could not run layout conversion script layout2layout.py."); + if (format == LAYOUT_FORMAT) + LYXERR0("Conversion of layout with layout2layout.py has failed."); return false; } return true; @@ -114,6 +110,8 @@ string translateReadType(TextClass::ReadType rt) return "input file"; case TextClass::MODULE: return "module file"; + case TextClass::CITE_ENGINE: + return "cite engine"; case TextClass::VALIDATION: return "validation"; } @@ -121,7 +119,7 @@ string translateReadType(TextClass::ReadType rt) return string(); } -} // namespace anon +} // namespace // This string should not be translated here, @@ -138,14 +136,15 @@ docstring const TextClass::plain_layout_ = from_ascii(N_("Plain Layout")); TextClass::TextClass() : loaded_(false), tex_class_avail_(false), opt_enginetype_("authoryear|numerical"), opt_fontsize_("10|11|12"), - opt_pagestyle_("empty|plain|headings|fancy"), pagestyle_("default"), - columns_(1), sides_(OneSide), secnumdepth_(3), tocdepth_(3), - outputType_(LATEX), outputFormat_("latex"), - defaultfont_(sane_font), + opt_pagesize_("default|a4|a5|b5|letter|legal|executive"), + opt_pagestyle_("empty|plain|headings|fancy"), fontsize_format_("$$spt"), pagesize_("default"), + pagesize_format_("$$spaper"), pagestyle_("default"), tablestyle_("default"), + docbookroot_("article"), docbookforceabstract_(false), + columns_(1), sides_(OneSide), secnumdepth_(3), tocdepth_(3), outputType_(LATEX), + outputFormat_("latex"), has_output_format_(false), defaultfont_(sane_font), titletype_(TITLE_COMMAND_AFTER), titlename_("maketitle"), - min_toclevel_(0), max_toclevel_(0), - cite_full_author_list_(true) -{ + min_toclevel_(0), max_toclevel_(0), maxcitenames_(2), + cite_full_author_list_(true), bibintoc_(false) { } @@ -179,6 +178,7 @@ enum TextClassTags { TC_COLUMNS, TC_SIDES, TC_PAGESTYLE, + TC_PAGESIZE, TC_DEFAULTFONT, TC_SECNUMDEPTH, TC_TOCDEPTH, @@ -207,23 +207,33 @@ enum TextClassTags { TC_EXCLUDESMODULE, TC_HTMLTOCSECTION, TC_CITEENGINE, + TC_ADDTOCITEENGINE, TC_CITEENGINETYPE, TC_CITEFORMAT, + TC_CITEFRAMEWORK, + TC_MAXCITENAMES, TC_DEFAULTBIBLIO, TC_FULLAUTHORLIST, - TC_OUTLINERNAME + TC_OUTLINERNAME, + TC_TABLESTYLE, + TC_BIBINTOC, + TC_DOCBOOKROOT, + TC_DOCBOOKFORCEABSTRACT }; namespace { LexerKeyword textClassTags[] = { + { "addtociteengine", TC_ADDTOCITEENGINE }, { "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE }, { "addtohtmlstyles", TC_ADDTOHTMLSTYLES }, { "addtopreamble", TC_ADDTOPREAMBLE }, + { "bibintoc", TC_BIBINTOC }, { "citeengine", TC_CITEENGINE }, { "citeenginetype", TC_CITEENGINETYPE }, { "citeformat", TC_CITEFORMAT }, + { "citeframework", TC_CITEFRAMEWORK }, { "classoptions", TC_CLASSOPTIONS }, { "columns", TC_COLUMNS }, { "counter", TC_COUNTER }, @@ -231,6 +241,8 @@ LexerKeyword textClassTags[] = { { "defaultfont", TC_DEFAULTFONT }, { "defaultmodule", TC_DEFAULTMODULE }, { "defaultstyle", TC_DEFAULTSTYLE }, + { "docbookforceabstract", TC_DOCBOOKFORCEABSTRACT }, + { "docbookroot", TC_DOCBOOKROOT }, { "excludesmodule", TC_EXCLUDESMODULE }, { "float", TC_FLOAT }, { "format", TC_FORMAT }, @@ -242,6 +254,7 @@ LexerKeyword textClassTags[] = { { "input", TC_INPUT }, { "insetlayout", TC_INSETLAYOUT }, { "leftmargin", TC_LEFTMARGIN }, + { "maxcitenames", TC_MAXCITENAMES }, { "modifystyle", TC_MODIFYSTYLE }, { "nocounter", TC_NOCOUNTER }, { "nofloat", TC_NOFLOAT }, @@ -251,6 +264,7 @@ LexerKeyword textClassTags[] = { { "outputformat", TC_OUTPUTFORMAT }, { "outputtype", TC_OUTPUTTYPE }, { "packageoptions", TC_PKGOPTS }, + { "pagesize", TC_PAGESIZE }, { "pagestyle", TC_PAGESTYLE }, { "preamble", TC_PREAMBLE }, { "provides", TC_PROVIDES }, @@ -261,12 +275,13 @@ LexerKeyword textClassTags[] = { { "secnumdepth", TC_SECNUMDEPTH }, { "sides", TC_SIDES }, { "style", TC_STYLE }, + { "tablestyle", TC_TABLESTYLE }, { "titlelatexname", TC_TITLELATEXNAME }, { "titlelatextype", TC_TITLELATEXTYPE }, { "tocdepth", TC_TOCDEPTH } }; -} //namespace anon +} // namespace bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt) @@ -290,7 +305,7 @@ std::string TextClass::convert(std::string const & str) os.close(); TempFile tmp2("convert_localXXXXXX.layout"); FileName const tempfile = tmp2.name(); - bool success = layout2layout(fn, tempfile); + bool success = layout2layout(fn, tempfile, LYXFILE_LAYOUT_FORMAT); if (!success) return ""; ifstream is(tempfile.toFilesystemEncoding().c_str()); @@ -375,13 +390,13 @@ TextClass::ReturnValues TextClass::read(std::string const & str, ReadType rt) os << str; os.close(); - // now try to convert it - bool const worx = convertLayoutFormat(tempfile, rt); - if (!worx) { + // now try to convert it to LAYOUT_FORMAT + if (!convertLayoutFormat(tempfile, rt)) { LYXERR0("Unable to convert internal layout information to format " << LAYOUT_FORMAT); return ERROR; } + return OK_OLDFORMAT; } @@ -392,11 +407,14 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) if (!lexrc.isOK()) return ERROR; - // Format of files before the 'Format' tag was introduced - int format = 1; - bool error = false; + // The first usable line should be + // Format LAYOUT_FORMAT + if (lexrc.lex() != TC_FORMAT || !lexrc.next() + || lexrc.getInteger() != LAYOUT_FORMAT) + return FORMAT_MISMATCH; // parsing + bool error = false; while (lexrc.isOK() && !error) { int le = lexrc.lex(); @@ -421,13 +439,15 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) switch (static_cast(le)) { case TC_FORMAT: - if (lexrc.next()) - format = lexrc.getInteger(); + lexrc.next(); + lexrc.printError("Duplicate Format directive"); break; case TC_OUTPUTFORMAT: - if (lexrc.next()) + if (lexrc.next()) { outputFormat_ = lexrc.getString(); + has_output_format_ = true; + } break; case TC_OUTPUTTYPE: @@ -436,9 +456,6 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case LATEX: outputFormat_ = "latex"; break; - case DOCBOOK: - outputFormat_ = "docbook"; - break; case LITERATE: outputFormat_ = "literate"; break; @@ -447,8 +464,13 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case TC_INPUT: // Include file if (lexrc.next()) { + FileName tmp; string const inc = lexrc.getString(); - FileName tmp = libFileSearch("layouts", inc, + if (!path().empty() && (prefixIs(inc, "./") || + prefixIs(inc, "../"))) + tmp = fileSearch(path(), inc, "layout"); + else + tmp = libFileSearch("layouts", inc, "layout"); if (tmp.empty()) { @@ -496,9 +518,9 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) error = !readStyle(lexrc, lay); break; } - + bool const have_layout = hasLayout(name); - + // If the layout already exists, then we want to add it to // the existing layout, as long as we are not in an ProvideStyle // block. @@ -528,7 +550,8 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) // Either way, we just scan the rest and discard it else { Layout lay; - readStyle(lexrc, lay); + // signal to coverity that we do not care about the result + (void)readStyle(lexrc, lay); } break; } @@ -573,6 +596,11 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) } break; + case TC_PAGESIZE: + lexrc.next(); + pagesize_ = rtrim(lexrc.getString()); + break; + case TC_PAGESTYLE: lexrc.next(); pagestyle_ = rtrim(lexrc.getString()); @@ -603,15 +631,15 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) break; case TC_PREAMBLE: - preamble_ = from_utf8(lexrc.getLongString("EndPreamble")); + preamble_ = lexrc.getLongString(from_ascii("EndPreamble")); break; case TC_HTMLPREAMBLE: - htmlpreamble_ = from_utf8(lexrc.getLongString("EndPreamble")); + htmlpreamble_ = lexrc.getLongString(from_ascii("EndPreamble")); break; case TC_HTMLSTYLES: - htmlstyles_ = from_utf8(lexrc.getLongString("EndStyles")); + htmlstyles_ = lexrc.getLongString(from_ascii("EndStyles")); break; case TC_HTMLTOCSECTION: @@ -619,15 +647,15 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) break; case TC_ADDTOPREAMBLE: - preamble_ += from_utf8(lexrc.getLongString("EndPreamble")); + preamble_ += lexrc.getLongString(from_ascii("EndPreamble")); break; case TC_ADDTOHTMLPREAMBLE: - htmlpreamble_ += from_utf8(lexrc.getLongString("EndPreamble")); + htmlpreamble_ += lexrc.getLongString(from_ascii("EndPreamble")); break; case TC_ADDTOHTMLSTYLES: - htmlstyles_ += from_utf8(lexrc.getLongString("EndStyles")); + htmlstyles_ += lexrc.getLongString(from_ascii("EndStyles")); break; case TC_PROVIDES: { @@ -645,7 +673,7 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) lexrc.eatLine(); vector const req = getVectorFromString(lexrc.getString()); - requires_.insert(req.begin(), req.end()); + required_.insert(req.begin(), req.end()); break; } @@ -704,6 +732,7 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) break; } docstring const name = subst(lexrc.getDocString(), '_', ' '); + bool const validating = (rt == VALIDATION); if (name.empty()) { string s = "Could not read name for InsetLayout: `$$Token' " + lexrc.getString() + " is probably not valid UTF-8!"; @@ -712,15 +741,17 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) // Since we couldn't read the name, we just scan the rest // of the style and discard it. il.read(lexrc, *this); - // Let's try to continue rather than abort. - // error = true; + // Let's try to continue rather than abort, unless we're validating + // in which case we want to report the error + if (validating) + error = true; } else if (hasInsetLayout(name)) { InsetLayout & il = insetlayoutlist_[name]; - error = !il.read(lexrc, *this); + error = !il.read(lexrc, *this, validating); } else { InsetLayout il; il.setName(name); - error = !il.read(lexrc, *this); + error = !il.read(lexrc, *this, validating); if (!error) insetlayoutlist_[name] = il; } @@ -732,7 +763,11 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) break; case TC_CITEENGINE: - error = !readCiteEngine(lexrc); + error = !readCiteEngine(lexrc, rt); + break; + + case TC_ADDTOCITEENGINE: + error = !readCiteEngine(lexrc, rt, true); break; case TC_CITEENGINETYPE: @@ -741,12 +776,41 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) break; case TC_CITEFORMAT: - error = !readCiteFormat(lexrc); + error = !readCiteFormat(lexrc, rt); + break; + + case TC_CITEFRAMEWORK: + lexrc.next(); + citeframework_ = rtrim(lexrc.getString()); + break; + + case TC_MAXCITENAMES: + lexrc.next(); + maxcitenames_ = size_t(lexrc.getInteger()); break; case TC_DEFAULTBIBLIO: + if (lexrc.next()) { + vector const dbs = + getVectorFromString(rtrim(lexrc.getString()), "|"); + for (auto const & dbase : dbs) { + if (!contains(dbase, ':')) { + vector const enginetypes = + getVectorFromString(opt_enginetype_, "|"); + for (string const & s: enginetypes) + cite_default_biblio_style_[s] = dbase; + } else { + string eng; + string const db = split(dbase, eng, ':'); + cite_default_biblio_style_[eng] = db; + } + } + } + break; + + case TC_BIBINTOC: if (lexrc.next()) - cite_default_biblio_style_ = rtrim(lexrc.getString()); + bibintoc_ = lexrc.getBool(); break; case TC_FULLAUTHORLIST: @@ -804,12 +868,22 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case TC_OUTLINERNAME: error = !readOutlinerName(lexrc); break; - } // end of switch - // Note that this is triggered the first time through the loop unless - // we hit a format tag. - if (format != LAYOUT_FORMAT) - return FORMAT_MISMATCH; + case TC_TABLESTYLE: + lexrc.next(); + tablestyle_ = rtrim(lexrc.getString()); + break; + + case TC_DOCBOOKROOT: + if (lexrc.next()) + docbookroot_ = lexrc.getString(); + break; + + case TC_DOCBOOKFORCEABSTRACT: + if (lexrc.next()) + docbookforceabstract_ = lexrc.getBool(); + break; + } // end of switch } // at present, we abort if we encounter an error, @@ -836,7 +910,7 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) // If we do not succeed, then it was not there, which means that // the textclass did not provide the definitions of the standard // insets. So we need to try to load them. - int erased = provides_.erase("stdinsets"); + size_type const erased = provides_.erase("stdinsets"); if (!erased) { FileName tmp = libFileSearch("layouts", "stdinsets.inc"); @@ -853,10 +927,8 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) min_toclevel_ = Layout::NOT_IN_TOC; max_toclevel_ = Layout::NOT_IN_TOC; - const_iterator lit = begin(); - const_iterator len = end(); - for (; lit != len; ++lit) { - int const toclevel = lit->toclevel; + for (auto const & lay : *this) { + int const toclevel = lay.toclevel; if (toclevel != Layout::NOT_IN_TOC) { if (min_toclevel_ == Layout::NOT_IN_TOC) min_toclevel_ = toclevel; @@ -900,7 +972,6 @@ void TextClass::readTitleType(Lexer & lexrc) void TextClass::readOutputType(Lexer & lexrc) { LexerKeyword outputTypeTags[] = { - { "docbook", DOCBOOK }, { "latex", LATEX }, { "literate", LITERATE } }; @@ -913,7 +984,6 @@ void TextClass::readOutputType(Lexer & lexrc) lexrc.printError("Unknown output type `$$Token'"); return; case LATEX: - case DOCBOOK: case LITERATE: outputType_ = static_cast(le); break; @@ -928,17 +998,21 @@ void TextClass::readClassOptions(Lexer & lexrc) { enum { CO_FONTSIZE = 1, + CO_FONTSIZE_FORMAT, + CO_PAGESIZE, + CO_PAGESIZE_FORMAT, CO_PAGESTYLE, CO_OTHER, - CO_HEADER, CO_END }; LexerKeyword classOptionsTags[] = { {"end", CO_END }, {"fontsize", CO_FONTSIZE }, - {"header", CO_HEADER }, + {"fontsizeformat", CO_FONTSIZE_FORMAT }, {"other", CO_OTHER }, + {"pagesize", CO_PAGESIZE }, + {"pagesizeformat", CO_PAGESIZE_FORMAT }, {"pagestyle", CO_PAGESTYLE } }; @@ -958,6 +1032,18 @@ void TextClass::readClassOptions(Lexer & lexrc) lexrc.next(); opt_fontsize_ = rtrim(lexrc.getString()); break; + case CO_FONTSIZE_FORMAT: + lexrc.next(); + fontsize_format_ = rtrim(lexrc.getString()); + break; + case CO_PAGESIZE: + lexrc.next(); + opt_pagesize_ = rtrim(lexrc.getString()); + break; + case CO_PAGESIZE_FORMAT: + lexrc.next(); + pagesize_format_ = rtrim(lexrc.getString()); + break; case CO_PAGESTYLE: lexrc.next(); opt_pagestyle_ = rtrim(lexrc.getString()); @@ -969,10 +1055,6 @@ void TextClass::readClassOptions(Lexer & lexrc) else options_ += ',' + lexrc.getString(); break; - case CO_HEADER: - lexrc.next(); - class_header_ = subst(lexrc.getString(), """, "\""); - break; case CO_END: getout = true; break; @@ -982,15 +1064,46 @@ void TextClass::readClassOptions(Lexer & lexrc) } -bool TextClass::readCiteEngine(Lexer & lexrc) +vector const & TextClass::getCiteStyles( + CiteEngineType const & type) const +{ + static vector empty; + map >::const_iterator it = cite_styles_.find(type); + if (it == cite_styles_.end()) + return empty; + return it->second; +} + + +bool TextClass::readCiteEngine(Lexer & lexrc, ReadType rt, bool const add) { int const type = readCiteEngineType(lexrc); - if (type & ENGINE_TYPE_AUTHORYEAR) - cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear(); - if (type & ENGINE_TYPE_NUMERICAL) - cite_styles_[ENGINE_TYPE_NUMERICAL].clear(); - if (type & ENGINE_TYPE_DEFAULT) - cite_styles_[ENGINE_TYPE_DEFAULT].clear(); + bool authoryear = (type & ENGINE_TYPE_AUTHORYEAR); + bool numerical = (type & ENGINE_TYPE_NUMERICAL); + bool defce = (type & ENGINE_TYPE_DEFAULT); + + if (rt == CITE_ENGINE) { + // The cite engines are not supposed to overwrite + // CiteStyle defined by the class or a module. + 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) { + // Reset if we defined CiteStyle + // from the class or a module + 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; while (!getout && lexrc.isOK()) { @@ -1002,45 +1115,152 @@ bool TextClass::readCiteEngine(Lexer & lexrc) getout = true; continue; } - string cmd; CitationStyle cs; char ichar = def[0]; if (ichar == '#') continue; - if (ichar == 'C') { + if (isUpperCase(ichar)) { cs.forceUpperCase = true; - def[0] = 'c'; + def[0] = lowercase(ichar); } + /** For portability reasons (between different + * cite engines such as natbib and biblatex), + * we distinguish between: + * 1. The LyX name as output in the LyX file + * 2. Possible aliases that might fall back to + * the given LyX name in the current engine + * 3. The actual LaTeX command that is output + * (2) and (3) are optional. + * Also, the GUI string for the starred version can + * be changed + * The syntax is: + * LyXName|alias,nextalias*[][]=latexcmd + */ + enum ScanMode { + LyXName, + Alias, + LaTeXCmd, + StarDesc + }; + + ScanMode mode = LyXName; + ScanMode oldmode = LyXName; + string lyx_cmd; + string alias; + string latex_cmd; + string stardesc; size_t const n = def.size(); for (size_t i = 0; i != n; ++i) { ichar = def[i]; - if (ichar == '*') - cs.fullAuthorList = true; + if (ichar == '|') + mode = Alias; + else if (ichar == '=') + mode = LaTeXCmd; + else if (ichar == '<') { + oldmode = mode; + mode = StarDesc; + } else if (ichar == '>') + mode = oldmode; + else if (mode == LaTeXCmd) + latex_cmd += ichar; + else if (mode == StarDesc) + stardesc += ichar; + else if (ichar == '$') + cs.hasQualifiedList = true; + else if (ichar == '*') + cs.hasStarredVersion = true; else if (ichar == '[' && cs.textAfter) cs.textBefore = true; else if (ichar == '[') cs.textAfter = true; - else if (ichar != ']') - cmd += ichar; + else if (ichar != ']') { + if (mode == Alias) + alias += ichar; + else + lyx_cmd += ichar; + } } - - cs.cmd = cmd; + cs.name = lyx_cmd; + cs.cmd = latex_cmd.empty() ? lyx_cmd : latex_cmd; + if (!alias.empty()) { + vector const aliases = getVectorFromString(alias); + for (string const & s: aliases) + cite_command_aliases_[s] = lyx_cmd; + } + vector const stardescs = getVectorFromString(stardesc, "!"); + int size = int(stardesc.size()); + if (size > 0) + cs.stardesc = stardescs[0]; + if (size > 1) + cs.startooltip = stardescs[1]; + 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); + } + } + // If we do AddToCiteEngine, do not apply yet, + // except if we have already a style to add something to + bool apply_ay = !add; + bool apply_num = !add; + bool apply_def = !add; + if (add) { if (type & ENGINE_TYPE_AUTHORYEAR) - cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs); + apply_ay = !getCiteStyles(ENGINE_TYPE_AUTHORYEAR).empty(); if (type & ENGINE_TYPE_NUMERICAL) - cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs); + apply_num = !getCiteStyles(ENGINE_TYPE_NUMERICAL).empty(); if (type & ENGINE_TYPE_DEFAULT) - cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs); + 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 (!(type & cis.first)) + continue; + for (auto const & ciss : cis.second) { + bool defined = false; + // Check if the style "name" is already def'ed + for (auto const & av : getCiteStyles(cis.first)) + if (av.name == ciss.name) + defined = true; + 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); + } + } + } + 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; } int TextClass::readCiteEngineType(Lexer & lexrc) const { - LATTEST(ENGINE_TYPE_DEFAULT == - (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL)); + static_assert(ENGINE_TYPE_DEFAULT == + (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL), + "Incorrect default engine type"); if (!lexrc.next()) { lexrc.printError("No cite engine type given for token: `$$Token'."); return ENGINE_TYPE_DEFAULT; @@ -1059,11 +1279,14 @@ int TextClass::readCiteEngineType(Lexer & lexrc) const } -bool TextClass::readCiteFormat(Lexer & lexrc) +bool TextClass::readCiteFormat(Lexer & lexrc, ReadType rt) { int const type = readCiteEngineType(lexrc); string etype; string definition; + // Cite engine definitions do not overwrite existing + // definitions from the class or a module + bool const overwrite = rt != CITE_ENGINE; while (lexrc.isOK()) { lexrc.next(); etype = lexrc.getString(); @@ -1076,20 +1299,62 @@ bool TextClass::readCiteFormat(Lexer & lexrc) char initchar = etype[0]; if (initchar == '#') continue; - if (initchar == '!' || initchar == '_') { - 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; + if (initchar == '!' || initchar == '_' || prefixIs(etype, "B_")) { + bool defined = false; + bool aydefined = false; + bool numdefined = false; + // Check if the macro is already def'ed + for (auto const & cm : cite_macros_) { + if (!(type & cm.first)) + continue; + if (cm.second.find(etype) != cm.second.end()) { + if (type == cm.first) + // defined as default or specific type + defined = true; + if (cm.first == ENGINE_TYPE_AUTHORYEAR) + // defined for author-year + aydefined = true; + else if (cm.first == ENGINE_TYPE_NUMERICAL) + // defined for numerical + numdefined = true; + } + } + if (!defined || overwrite) { + if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined)) + cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined)) + cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type == ENGINE_TYPE_DEFAULT) + cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition; + } } else { - 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; + bool defined = false; + bool aydefined = false; + bool numdefined = false; + // Check if the format is already def'ed + for (auto const & cm : cite_formats_) { + if (!(type & cm.first)) + continue; + if (cm.second.find(etype) != cm.second.end()) { + if (type == cm.first) + // defined as default or specific type + defined = true; + if (cm.first == ENGINE_TYPE_AUTHORYEAR) + // defined for author-year + aydefined = true; + else if (cm.first == ENGINE_TYPE_NUMERICAL) + // defined for numerical + numdefined = true; + } + } + if (!defined || overwrite){ + if (type & ENGINE_TYPE_AUTHORYEAR && (type != ENGINE_TYPE_DEFAULT || !aydefined)) + cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL && (type != ENGINE_TYPE_DEFAULT || !numdefined)) + cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type == ENGINE_TYPE_DEFAULT) + cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition; + } } } return true; @@ -1111,11 +1376,14 @@ bool TextClass::readFloat(Lexer & lexrc) FT_HTMLSTYLE, FT_HTMLATTR, FT_HTMLTAG, + FT_DOCBOOKATTR, + FT_DOCBOOKTAG, FT_LISTCOMMAND, FT_REFPREFIX, FT_ALLOWED_PLACEMENT, FT_ALLOWS_SIDEWAYS, - FT_ALLOWS_WIDE, + FT_ALLOWS_WIDE, + FT_REQUIRES, FT_END }; @@ -1123,6 +1391,8 @@ bool TextClass::readFloat(Lexer & lexrc) { "allowedplacement", FT_ALLOWED_PLACEMENT }, { "allowssideways", FT_ALLOWS_SIDEWAYS }, { "allowswide", FT_ALLOWS_WIDE }, + { "docbookattr", FT_DOCBOOKATTR }, + { "docbooktag", FT_DOCBOOKTAG }, { "end", FT_END }, { "extension", FT_EXT }, { "guiname", FT_NAME }, @@ -1135,6 +1405,7 @@ bool TextClass::readFloat(Lexer & lexrc) { "numberwithin", FT_WITHIN }, { "placement", FT_PLACEMENT }, { "refprefix", FT_REFPREFIX }, + { "requires", FT_REQUIRES }, { "style", FT_STYLE }, { "type", FT_TYPE }, { "usesfloatpkg", FT_USESFLOAT } @@ -1144,8 +1415,10 @@ bool TextClass::readFloat(Lexer & lexrc) string ext; string htmlattr; - string htmlstyle; + docstring htmlstyle; string htmltag; + string docbookattr; + string docbooktag; string listname; string listcommand; string name; @@ -1155,6 +1428,7 @@ bool TextClass::readFloat(Lexer & lexrc) string style; string type; string within; + string required; bool usesfloat = true; bool ispredefined = false; bool allowswide = true; @@ -1230,6 +1504,10 @@ bool TextClass::readFloat(Lexer & lexrc) lexrc.next(); usesfloat = lexrc.getBool(); break; + case FT_REQUIRES: + lexrc.next(); + required = lexrc.getString(); + break; case FT_PREDEFINED: lexrc.next(); ispredefined = lexrc.getBool(); @@ -1248,12 +1526,20 @@ bool TextClass::readFloat(Lexer & lexrc) break; case FT_HTMLSTYLE: lexrc.next(); - htmlstyle = lexrc.getLongString("EndHTMLStyle"); + htmlstyle = lexrc.getLongString(from_ascii("EndHTMLStyle")); break; case FT_HTMLTAG: lexrc.next(); htmltag = lexrc.getString(); break; + case FT_DOCBOOKATTR: + lexrc.next(); + docbookattr = lexrc.getString(); + break; + case FT_DOCBOOKTAG: + lexrc.next(); + docbooktag = lexrc.getString(); + break; case FT_END: getout = true; break; @@ -1267,11 +1553,9 @@ bool TextClass::readFloat(Lexer & lexrc) if (!usesfloat && listcommand.empty()) { // if this float uses the same auxfile as an existing one, // there is no need for it to provide a list command. - FloatList::const_iterator it = floatlist_.begin(); - FloatList::const_iterator en = floatlist_.end(); bool found_ext = false; - for (; it != en; ++it) { - if (it->second.ext() == ext) { + for (auto const & f : floatlist_) { + if (f.second.ext() == ext) { found_ext = true; break; } @@ -1282,17 +1566,20 @@ bool TextClass::readFloat(Lexer & lexrc) "not be able to produce a float list."); } Floating fl(type, placement, ext, within, style, name, - listname, listcommand, refprefix, allowed_placement, - htmltag, htmlattr, htmlstyle, usesfloat, ispredefined, - allowswide, allowssideways); + listname, listcommand, refprefix, allowed_placement, + htmltag, htmlattr, htmlstyle, docbooktag, docbookattr, + required, usesfloat, ispredefined, allowswide, + allowssideways); floatlist_.newFloat(fl); // each float has its own counter counters_.newCounter(from_ascii(type), from_ascii(within), - docstring(), docstring()); + docstring(), docstring(), + bformat(_("%1$s (Float)"), _(name))); // also define sub-float counters docstring const subtype = "sub-" + from_ascii(type); counters_.newCounter(subtype, from_ascii(type), - "\\alph{" + subtype + "}", docstring()); + "\\alph{" + subtype + "}", docstring(), + bformat(_("Sub-%1$s (Float)"), _(name))); } return getout; } @@ -1319,18 +1606,6 @@ bool TextClass::readOutlinerName(Lexer & lexrc) } -docstring TextClass::outlinerName(std::string const & type) const -{ - std::map::const_iterator const it - = outliner_names_.find(type); - if (it == outliner_names_.end()) { - LYXERR0("Missing OutlinerName for " << type << "!"); - return from_utf8(type); - } else - return it->second; -} - - string const & TextClass::prerequisites(string const & sep) const { if (contains(prerequisites_, ',')) { @@ -1344,10 +1619,7 @@ string const & TextClass::prerequisites(string const & sep) const bool TextClass::hasLayout(docstring const & n) const { docstring const name = n.empty() ? defaultLayoutName() : n; - - return find_if(layoutlist_.begin(), layoutlist_.end(), - LayoutNamesEqual(name)) - != layoutlist_.end(); + return getLayout(name) != nullptr; } @@ -1364,21 +1636,19 @@ Layout const & TextClass::operator[](docstring const & name) const { LATTEST(!name.empty()); - const_iterator it = - find_if(begin(), end(), LayoutNamesEqual(name)); - - if (it == end()) { + Layout const * c = getLayout(name); + if (!c) { LYXERR0("We failed to find the layout '" << name << "' in the layout list. You MUST investigate!"); - for (const_iterator cit = begin(); cit != end(); ++cit) - lyxerr << " " << to_utf8(cit->name()) << endl; + for (auto const & lay : *this) + lyxerr << " " << to_utf8(lay.name()) << endl; // We require the name to exist static const Layout dummy; LASSERT(false, return dummy); } - return *it; + return *c; } @@ -1387,22 +1657,21 @@ Layout & TextClass::operator[](docstring const & name) LATTEST(!name.empty()); // Safe to continue, given what we do below. - iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); - - if (it == end()) { + Layout * c = getLayout(name); + if (!c) { LYXERR0("We failed to find the layout '" << to_utf8(name) << "' in the layout list. You MUST investigate!"); - for (const_iterator cit = begin(); cit != end(); ++cit) - LYXERR0(" " << to_utf8(cit->name())); + for (auto const & lay : *this) + LYXERR0(" " << to_utf8(lay.name())); // we require the name to exist LATTEST(false); // we are here only in release mode layoutlist_.push_back(createBasicLayout(name, true)); - it = find_if(begin(), end(), LayoutNamesEqual(name)); + c = getLayout(name); } - return *it; + return *c; } @@ -1413,9 +1682,9 @@ bool TextClass::deleteLayout(docstring const & name) LayoutList::iterator it = remove_if(layoutlist_.begin(), layoutlist_.end(), - LayoutNamesEqual(name)); + [name](const Layout &c) { return c.name() == name; }); - LayoutList::iterator end = layoutlist_.end(); + LayoutList::iterator const end = layoutlist_.end(); bool const ret = (it != end); layoutlist_.erase(it, end); return ret; @@ -1456,6 +1725,30 @@ bool TextClass::load(string const & path) const } +Layout const * TextClass::getLayout(docstring const & name) const +{ + LayoutList::const_iterator cit = + find_if(begin(), end(), + [name](const Layout &c) { return c.name() == name; }); + if (cit == layoutlist_.end()) + return nullptr; + + return &(*cit); +} + + +Layout * TextClass::getLayout(docstring const & name) +{ + LayoutList::iterator it = + find_if(layoutlist_.begin(), layoutlist_.end(), + [name](const Layout &c) { return c.name() == name; }); + if (it == layoutlist_.end()) + return nullptr; + + return &(*it); +} + + bool DocumentClass::addLayoutIfNeeded(docstring const & n) const { if (hasLayout(n)) @@ -1470,14 +1763,13 @@ string DocumentClass::forcedLayouts() const { ostringstream os; bool first = true; - const_iterator const e = end(); - for (const_iterator i = begin(); i != e; ++i) { - if (i->forcelocal > 0) { + for (auto const & lay : *this) { + if (lay.forcelocal > 0) { if (first) { os << "Format " << LAYOUT_FORMAT << '\n'; first = false; } - i->write(os); + lay.write(os); } } return os.str(); @@ -1542,7 +1834,7 @@ bool TextClass::isPlainLayout(Layout const & layout) const Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const { - static Layout * defaultLayout = NULL; + static Layout * defaultLayout = nullptr; if (defaultLayout) { defaultLayout->setUnknown(unknown); @@ -1574,21 +1866,18 @@ Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const DocumentClassPtr getDocumentClass( LayoutFile const & baseClass, LayoutModuleList const & modlist, - bool const clone) + string const & cengine, bool const clone) { DocumentClassPtr doc_class = DocumentClassPtr(new DocumentClass(baseClass)); - LayoutModuleList::const_iterator it = modlist.begin(); - LayoutModuleList::const_iterator en = modlist.end(); - for (; it != en; ++it) { - string const modName = *it; - LyXModule * lm = theModuleList[modName]; + for (auto const & mod : modlist) { + LyXModule * lm = theModuleList[mod]; if (!lm) { docstring const msg = bformat(_("The module %1$s has been requested by\n" "this document but has not been found in the list of\n" "available modules. If you recently installed it, you\n" - "probably need to reconfigure LyX.\n"), from_utf8(modName)); + "probably need to reconfigure LyX.\n"), from_utf8(mod)); if (!clone) frontend::Alert::warning(_("Module not available"), msg); continue; @@ -1602,16 +1891,49 @@ DocumentClassPtr getDocumentClass( "Missing prerequisites:\n" "\t%2$s\n" "See section 3.1.2.3 (Modules) of the User's Guide for more information."), - from_utf8(modName), prereqs); + from_utf8(mod), prereqs); frontend::Alert::warning(_("Package not available"), msg, true); } FileName layout_file = libFileSearch("layouts", lm->getFilename()); if (!doc_class->read(layout_file, TextClass::MODULE)) { docstring const msg = - bformat(_("Error reading module %1$s\n"), from_utf8(modName)); + bformat(_("Error reading module %1$s\n"), from_utf8(mod)); + frontend::Alert::warning(_("Read Error"), msg); + } + } + + if (cengine.empty()) + return doc_class; + + LyXCiteEngine * ce = theCiteEnginesList[cengine]; + if (!ce) { + docstring const msg = + bformat(_("The cite engine %1$s has been requested by\n" + "this document but has not been found in the list of\n" + "available engines. If you recently installed it, you\n" + "probably need to reconfigure LyX.\n"), from_utf8(cengine)); + if (!clone) + frontend::Alert::warning(_("Cite Engine not available"), msg); + } else if (!ce->isAvailable() && !clone) { + docstring const prereqs = from_utf8(getStringFromVector(ce->prerequisites(), "\n\t")); + docstring const msg = + bformat(_("The cite engine %1$s requires a package that is not\n" + "available in your LaTeX installation, or a converter that\n" + "you have not installed. LaTeX output may not be possible.\n" + "Missing prerequisites:\n" + "\t%2$s\n" + "See section 3.1.2.3 (Modules) of the User's Guide for more information."), + from_utf8(cengine), prereqs); + frontend::Alert::warning(_("Package not available"), msg, true); + } else { + FileName layout_file = libFileSearch("citeengines", ce->getFilename()); + if (!doc_class->read(layout_file, TextClass::CITE_ENGINE)) { + docstring const msg = + bformat(_("Error reading cite engine %1$s\n"), from_utf8(cengine)); frontend::Alert::warning(_("Read Error"), msg); } } + return doc_class; } @@ -1629,10 +1951,8 @@ DocumentClass::DocumentClass(LayoutFile const & tc) bool DocumentClass::hasLaTeXLayout(std::string const & lay) const { - LayoutList::const_iterator it = layoutlist_.begin(); - LayoutList::const_iterator end = layoutlist_.end(); - for (; it != end; ++it) - if (it->latexname() == lay) + for (auto const & l : layoutlist_) + if (l.latexname() == lay) return true; return false; } @@ -1653,17 +1973,15 @@ bool DocumentClass::hasTocLevels() const Layout const & DocumentClass::getTOCLayout() const { // we're going to look for the layout with the minimum toclevel - TextClass::LayoutList::const_iterator lit = begin(); - TextClass::LayoutList::const_iterator const len = end(); int minlevel = 1000; - Layout const * lay = NULL; - for (; lit != len; ++lit) { - int const level = lit->toclevel; + Layout const * lay = nullptr; + for (auto const & l : *this) { + int const level = l.toclevel; // we don't want Part or unnumbered sections - if (level == Layout::NOT_IN_TOC || level < 0 - || level >= minlevel || lit->counter.empty()) + if (level == Layout::NOT_IN_TOC || level < 0 + || level >= minlevel || l.counter.empty()) continue; - lay = &*lit; + lay = &l; minlevel = level; } if (lay) @@ -1681,10 +1999,14 @@ Layout const & DocumentClass::htmlTOCLayout() const } -string const & DocumentClass::getCiteFormat(CiteEngineType const & type, - string const & entry, string const & fallback) const +string const DocumentClass::getCiteFormat(CiteEngineType const & type, + string const & entry, bool const punct, string const & fallback) const { - static string default_format = "{%author%[[%author%, ]][[{%editor%[[%editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}."; + string default_format = "{%fullnames:author%[[%fullnames:author%, ]][[{%fullnames:editor%[[%fullnames:editor%, ed., ]]}]]}" + "\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]]" + "[[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}"; + if (punct) + default_format += "."; map >::const_iterator itype = cite_formats_.find(type); if (itype == cite_formats_.end()) @@ -1694,6 +2016,8 @@ string const & DocumentClass::getCiteFormat(CiteEngineType const & type, it = itype->second.find(fallback); if (it == itype->second.end()) return default_format; + if (punct) + return it->second + "."; return it->second; } @@ -1716,13 +2040,10 @@ vector const DocumentClass::citeCommands( CiteEngineType const & type) const { vector const styles = citeStyles(type); - vector::const_iterator it = styles.begin(); - vector::const_iterator end = styles.end(); vector cmds; - for (; it != end; ++it) { - CitationStyle const cite = *it; - cmds.push_back(cite.cmd); - } + for (auto const & cs : styles) + cmds.push_back(cs.name); + return cmds; }