X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=5c79fa6e9c5b1e30c490c18766decc7bb9471716;hb=4a75fe0310ac64a079edab0c07d8f8eebaf519c0;hp=13adf04675cdf0a43e6673bded0843fd5f566558;hpb=f0771cecc2a5e15b2c0e02a42083f6bad2cfef50;p=lyx.git diff --git a/src/TextClass.cpp b/src/TextClass.cpp index 13adf04675..5c79fa6e9c 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -27,6 +27,7 @@ #include "frontends/alert.h" +#include "support/lassert.h" #include "support/debug.h" #include "support/ExceptionMessage.h" #include "support/FileName.h" @@ -36,10 +37,9 @@ #include "support/os.h" #include +#include #include -#include "boost/assert.hpp" - using namespace std; using namespace lyx::support; @@ -61,15 +61,15 @@ private: }; -int const FORMAT = 6; +int const FORMAT = 8; bool layout2layout(FileName const & filename, FileName const & tempfile) { FileName const script = libFileSearch("scripts", "layout2layout.py"); if (script.empty()) { - lyxerr << "Could not find layout conversion " - "script layout2layout.py." << endl; + LYXERR0("Could not find layout conversion " + "script layout2layout.py."); return false; } @@ -81,11 +81,9 @@ bool layout2layout(FileName const & filename, FileName const & tempfile) LYXERR(Debug::TCLASS, "Running `" << command_str << '\''); - cmd_ret const ret = - runCommand(command_str); + cmd_ret const ret = runCommand(command_str); if (ret.first != 0) { - lyxerr << "Could not run layout conversion " - "script layout2layout.py." << endl; + LYXERR0("Could not run layout conversion script layout2layout.py."); return false; } return true; @@ -101,6 +99,8 @@ std::string translateRT(TextClass::ReadType rt) return "input file"; case TextClass::MODULE: return "module file"; + case TextClass::VALIDATION: + return "validation"; } // shutup warning return string(); @@ -109,11 +109,19 @@ std::string translateRT(TextClass::ReadType rt) } // namespace anon -docstring const TextClass::emptylayout_ = from_ascii("PlainLayout"); +// This string should not be translated here, +// because it is a layout identifier. +docstring const TextClass::plain_layout_ = from_ascii("Plain Layout"); + +InsetLayout DocumentClass::plain_insetlayout_; -InsetLayout DocumentClass::empty_insetlayout_; +///////////////////////////////////////////////////////////////////////// +// +// TextClass +// +///////////////////////////////////////////////////////////////////////// TextClass::TextClass() { @@ -129,17 +137,15 @@ TextClass::TextClass() titletype_ = TITLE_COMMAND_AFTER; titlename_ = "maketitle"; loaded_ = false; - // a hack to make this available for translation - // i'm sure there must be a better way (rgh) - _("PlainLayout"); + _("Plain Layout"); // a hack to make this translatable } -bool TextClass::readStyle(Lexer & lexrc, Layout & lay) +bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const { LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name())); if (!lay.read(lexrc, *this)) { - lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl; + LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\''); return false; } // Resolve fonts @@ -157,7 +163,6 @@ enum TextClassTags { TC_STYLE, TC_DEFAULTSTYLE, TC_INSETLAYOUT, - TC_ENVIRONMENT, TC_NOSTYLE, TC_COLUMNS, TC_SIDES, @@ -176,26 +181,21 @@ enum TextClassTags { TC_NOFLOAT, TC_TITLELATEXNAME, TC_TITLELATEXTYPE, - TC_FORMAT + TC_FORMAT, + TC_ADDTOPREAMBLE, + TC_USEMODULE }; -// Reads a textclass structure from file. -bool TextClass::read(FileName const & filename, ReadType rt) -{ - if (!filename.isReadableFile()) { - lyxerr << "Cannot read layout file `" << filename << "'." - << endl; - return false; - } +namespace { - keyword_item textClassTags[] = { + LexerKeyword textClassTags[] = { + { "addtopreamble", TC_ADDTOPREAMBLE }, { "classoptions", TC_CLASSOPTIONS }, { "columns", TC_COLUMNS }, { "counter", TC_COUNTER }, { "defaultfont", TC_DEFAULTFONT }, { "defaultstyle", TC_DEFAULTSTYLE }, - { "environment", TC_ENVIRONMENT }, { "float", TC_FLOAT }, { "format", TC_FORMAT }, { "input", TC_INPUT }, @@ -214,40 +214,102 @@ bool TextClass::read(FileName const & filename, ReadType rt) { "style", TC_STYLE }, { "titlelatexname", TC_TITLELATEXNAME }, { "titlelatextype", TC_TITLELATEXTYPE }, - { "tocdepth", TC_TOCDEPTH } + { "tocdepth", TC_TOCDEPTH }, + { "usemodule", TC_USEMODULE } }; + +} //namespace anon + + +bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt) +{ + LYXERR(Debug::TCLASS, "Converting layout file to " << FORMAT); + FileName const tempfile = FileName::tempName("convert_layout"); + bool success = layout2layout(filename, tempfile); + if (success) + success = read(tempfile, rt); + tempfile.removeFile(); + return success; +} + +bool TextClass::read(FileName const & filename, ReadType rt) +{ + if (!filename.isReadableFile()) { + lyxerr << "Cannot read layout file `" << filename << "'." + << endl; + return false; + } LYXERR(Debug::TCLASS, "Reading " + translateRT(rt) + ": " + to_utf8(makeDisplayPath(filename.absFilename()))); - // Define the `empty' layout used in table cells, ert, etc. Note that + // Define the plain layout used in table cells, ert, etc. Note that // we do this before loading any layout file, so that classes can // override features of this layout if they should choose to do so. - if (rt == BASECLASS) { - static char const * s = "Margin Static\n" - "LatexType Paragraph\n" - "LatexName dummy\n" - "Align Block\n" - "AlignPossible Left, Right, Center\n" - "LabelType No_Label\n" - "End"; - istringstream ss(s); - Lexer lex(textClassTags, sizeof(textClassTags) / sizeof(textClassTags[0])); - lex.setStream(ss); - Layout lay; - lay.setName(emptylayout_); - if (!readStyle(lex, lay)) { - // The only way this happens is because the hardcoded layout above - // is wrong. - BOOST_ASSERT(false); - }; - layoutlist_.push_back(lay); + if (rt == BASECLASS && !hasLayout(plain_layout_)) + layoutlist_.push_back(createBasicLayout(plain_layout_)); + + Lexer lexrc(textClassTags); + lexrc.setFile(filename); + ReturnValues retval = read(lexrc, rt); + + LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " + + to_utf8(makeDisplayPath(filename.absFilename()))); + + if (retval != FORMAT_MISMATCH) + return retval == OK; + + bool const worx = convertLayoutFormat(filename, rt); + if (!worx) { + lyxerr << "Unable to convert " << filename << + " to format " << FORMAT << std::endl; + return false; } + return true; +} - Lexer lexrc(textClassTags, - sizeof(textClassTags) / sizeof(textClassTags[0])); - lexrc.setFile(filename); +bool TextClass::validate(std::string const & str) +{ + TextClass tc; + return tc.read(str, VALIDATION); +} + + +bool TextClass::read(std::string const & str, ReadType rt) +{ + Lexer lexrc(textClassTags); + istringstream is(str); + lexrc.setStream(is); + ReturnValues retval = read(lexrc, rt); + + if (retval != FORMAT_MISMATCH) + return retval == OK; + + // write the layout string to a temporary file + FileName const tempfile = FileName::tempName("TextClass_read"); + ofstream os(tempfile.toFilesystemEncoding().c_str()); + if (!os) { + LYXERR0("Unable to create temporary file"); + return false; + } + os << str; + os.close(); + + // now try to convert it + bool const worx = convertLayoutFormat(tempfile, rt); + if (!worx) { + LYXERR0("Unable to convert internal layout information to format " + << FORMAT); + } + tempfile.removeFile(); + return worx; +} + + +// Reads a textclass structure from file. +TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) +{ bool error = !lexrc.isOK(); // Format of files before the 'Format' tag was introduced @@ -306,7 +368,6 @@ bool TextClass::read(FileName const & filename, ReadType rt) } break; - case TC_ENVIRONMENT: case TC_STYLE: if (lexrc.next()) { docstring const name = from_utf8(subst(lexrc.getString(), @@ -316,21 +377,18 @@ bool TextClass::read(FileName const & filename, ReadType rt) + lexrc.getString() + " is probably not valid UTF-8!"; lexrc.printError(s.c_str()); Layout lay; - //FIXME If we're just dropping this layout, do we really - //care whether there's an error?? Or should we just set - //error to true, since we couldn't even read the name? + // Since we couldn't read the name, we just scan the rest + // of the style and discard it. error = !readStyle(lexrc, lay); } else if (hasLayout(name)) { Layout & lay = operator[](name); error = !readStyle(lexrc, lay); } else { - Layout lay; - lay.setName(name); - if (le == TC_ENVIRONMENT) - lay.is_environment = true; - error = !readStyle(lexrc, lay); + Layout layout; + layout.setName(name); + error = !readStyle(lexrc, layout); if (!error) - layoutlist_.push_back(lay); + layoutlist_.push_back(layout); if (defaultlayout_.empty()) { // We do not have a default layout yet, so we choose @@ -341,8 +399,8 @@ bool TextClass::read(FileName const & filename, ReadType rt) } else { //FIXME Should we also eat the style here? viz: - //Layout lay; - //readStyle(lexrc, lay); + //Layout layout; + //readStyle(lexrc, layout); //as above... lexrc.printError("No name given for style: `$$Token'."); error = true; @@ -412,6 +470,10 @@ bool TextClass::read(FileName const & filename, ReadType rt) preamble_ = from_utf8(lexrc.getLongString("EndPreamble")); break; + case TC_ADDTOPREAMBLE: + preamble_ += from_utf8(lexrc.getLongString("EndPreamble")); + break; + case TC_PROVIDES: { lexrc.next(); string const feature = lexrc.getString(); @@ -431,6 +493,13 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } + case TC_USEMODULE: { + lexrc.next(); + string const module = lexrc.getString(); + usemod_.insert(module); + break; + } + case TC_LEFTMARGIN: // left margin type if (lexrc.next()) leftmargin_ = lexrc.getDocString(); @@ -444,9 +513,8 @@ bool TextClass::read(FileName const & filename, ReadType rt) case TC_INSETLAYOUT: if (lexrc.next()) { InsetLayout il; - if (il.read(lexrc)) { + if (il.read(lexrc, *this)) insetlayoutlist_[il.name()] = il; - } // else there was an error, so forget it } break; @@ -482,39 +550,28 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } - if (format != FORMAT) { - LYXERR(Debug::TCLASS, "Converting layout file from format " - << format << " to " << FORMAT); - FileName const tempfile = FileName::tempName(); - bool success = layout2layout(filename, tempfile); - if (success) - read(tempfile, rt); - tempfile.removeFile(); - return success; - } - - LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " + - to_utf8(makeDisplayPath(filename.absFilename()))); + if (format != FORMAT) + return FORMAT_MISMATCH; if (rt != BASECLASS) - return !error; + return (error ? ERROR : OK); if (defaultlayout_.empty()) { - lyxerr << "Error: Textclass '" << name_ - << "' is missing a defaultstyle." << endl; + LYXERR0("Error: Textclass '" << name_ + << "' is missing a defaultstyle."); error = true; } - //Try to erase "stdinsets" from the provides_ set. - //The - // Provides stdinsets 1 - //declaration simply tells us that the standard insets have been - //defined. (It's found in stdinsets.inc but could also be used in - //user-defined files.) There isn't really any such package. So we - //might as well go ahead and erase it. - //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. + // Try to erase "stdinsets" from the provides_ set. + // The + // Provides stdinsets 1 + // declaration simply tells us that the standard insets have been + // defined. (It's found in stdinsets.inc but could also be used in + // user-defined files.) There isn't really any such package. So we + // might as well go ahead and erase it. + // 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"); if (!erased) { FileName tmp = libFileSearch("layouts", "stdinsets.inc"); @@ -547,32 +604,30 @@ bool TextClass::read(FileName const & filename, ReadType rt) LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_ << ", maximum is " << max_toclevel_); - return !error; + return (error ? ERROR : OK); } void TextClass::readTitleType(Lexer & lexrc) { - keyword_item titleTypeTags[] = { + LexerKeyword titleTypeTags[] = { { "commandafter", TITLE_COMMAND_AFTER }, - { "environment", TITLE_ENVIRONMENT } + { "environment", TITLE_ENVIRONMENT } }; - PushPopHelper pph(lexrc, titleTypeTags, TITLE_ENVIRONMENT); + PushPopHelper pph(lexrc, titleTypeTags); int le = lexrc.lex(); switch (le) { case Lexer::LEX_UNDEF: lexrc.printError("Unknown output type `$$Token'"); - return; + break; case TITLE_COMMAND_AFTER: case TITLE_ENVIRONMENT: titletype_ = static_cast(le); break; default: - lyxerr << "Unhandled value " << le - << " in TextClass::readTitleType." << endl; - + LYXERR0("Unhandled value " << le << " in TextClass::readTitleType."); break; } } @@ -580,13 +635,13 @@ void TextClass::readTitleType(Lexer & lexrc) void TextClass::readOutputType(Lexer & lexrc) { - keyword_item outputTypeTags[] = { - { "docbook", DOCBOOK }, - { "latex", LATEX }, + LexerKeyword outputTypeTags[] = { + { "docbook", DOCBOOK }, + { "latex", LATEX }, { "literate", LITERATE } }; - PushPopHelper pph(lexrc, outputTypeTags, LITERATE); + PushPopHelper pph(lexrc, outputTypeTags); int le = lexrc.lex(); switch (le) { @@ -599,34 +654,31 @@ void TextClass::readOutputType(Lexer & lexrc) outputType_ = static_cast(le); break; default: - lyxerr << "Unhandled value " << le - << " in TextClass::readOutputType." << endl; - + LYXERR0("Unhandled value " << le); break; } } -enum ClassOptionsTags { - CO_FONTSIZE = 1, - CO_PAGESTYLE, - CO_OTHER, - CO_HEADER, - CO_END -}; - - void TextClass::readClassOptions(Lexer & lexrc) { - keyword_item classOptionsTags[] = { - {"end", CO_END }, - {"fontsize", CO_FONTSIZE }, - {"header", CO_HEADER }, - {"other", CO_OTHER }, + enum { + CO_FONTSIZE = 1, + CO_PAGESTYLE, + CO_OTHER, + CO_HEADER, + CO_END + }; + + LexerKeyword classOptionsTags[] = { + {"end", CO_END }, + {"fontsize", CO_FONTSIZE }, + {"header", CO_HEADER }, + {"other", CO_OTHER }, {"pagestyle", CO_PAGESTYLE } }; - lexrc.pushTable(classOptionsTags, CO_END); + lexrc.pushTable(classOptionsTags); bool getout = false; while (!getout && lexrc.isOK()) { int le = lexrc.lex(); @@ -636,7 +688,7 @@ void TextClass::readClassOptions(Lexer & lexrc) continue; default: break; } - switch (static_cast(le)) { + switch (le) { case CO_FONTSIZE: lexrc.next(); opt_fontsize_ = rtrim(lexrc.getString()); @@ -662,22 +714,21 @@ void TextClass::readClassOptions(Lexer & lexrc) } -enum FloatTags { - FT_TYPE = 1, - FT_NAME, - FT_PLACEMENT, - FT_EXT, - FT_WITHIN, - FT_STYLE, - FT_LISTNAME, - FT_BUILTIN, - FT_END -}; - - void TextClass::readFloat(Lexer & lexrc) { - keyword_item floatTags[] = { + enum { + FT_TYPE = 1, + FT_NAME, + FT_PLACEMENT, + FT_EXT, + FT_WITHIN, + FT_STYLE, + FT_LISTNAME, + FT_BUILTIN, + FT_END + }; + + LexerKeyword floatTags[] = { { "end", FT_END }, { "extension", FT_EXT }, { "guiname", FT_NAME }, @@ -689,7 +740,7 @@ void TextClass::readFloat(Lexer & lexrc) { "type", FT_TYPE } }; - lexrc.pushTable(floatTags, FT_END); + lexrc.pushTable(floatTags); string type; string placement; @@ -709,7 +760,7 @@ void TextClass::readFloat(Lexer & lexrc) continue; default: break; } - switch (static_cast(le)) { + switch (le) { case FT_TYPE: lexrc.next(); type = lexrc.getString(); @@ -778,18 +829,17 @@ void TextClass::readFloat(Lexer & lexrc) } -enum CounterTags { - CT_NAME = 1, - CT_WITHIN, - CT_LABELSTRING, - CT_LABELSTRING_APPENDIX, - CT_END -}; - - void TextClass::readCounter(Lexer & lexrc) { - keyword_item counterTags[] = { + enum { + CT_NAME = 1, + CT_WITHIN, + CT_LABELSTRING, + CT_LABELSTRING_APPENDIX, + CT_END + }; + + LexerKeyword counterTags[] = { { "end", CT_END }, { "labelstring", CT_LABELSTRING }, { "labelstringappendix", CT_LABELSTRING_APPENDIX }, @@ -797,7 +847,7 @@ void TextClass::readCounter(Lexer & lexrc) { "within", CT_WITHIN } }; - lexrc.pushTable(counterTags, CT_END); + lexrc.pushTable(counterTags); docstring name; docstring within; @@ -813,7 +863,7 @@ void TextClass::readCounter(Lexer & lexrc) continue; default: break; } - switch (static_cast(le)) { + switch (le) { case CT_NAME: lexrc.next(); name = lexrc.getDocString(); @@ -862,10 +912,9 @@ bool TextClass::hasLayout(docstring const & n) const } - Layout const & TextClass::operator[](docstring const & name) const { - BOOST_ASSERT(!name.empty()); + LASSERT(!name.empty(), /**/); const_iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); @@ -878,7 +927,7 @@ Layout const & TextClass::operator[](docstring const & name) const lyxerr << " " << to_utf8(cit->name()) << endl; // we require the name to exist - BOOST_ASSERT(false); + LASSERT(false, /**/); } return *it; @@ -887,19 +936,18 @@ Layout const & TextClass::operator[](docstring const & name) const Layout & TextClass::operator[](docstring const & name) { - BOOST_ASSERT(!name.empty()); + LASSERT(!name.empty(), /**/); iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); if (it == end()) { - lyxerr << "We failed to find the layout '" << to_utf8(name) - << "' in the layout list. You MUST investigate!" - << endl; + 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) - lyxerr << " " << to_utf8(cit->name()) << endl; + LYXERR0(" " << to_utf8(cit->name())); // we require the name to exist - BOOST_ASSERT(false); + LASSERT(false, /**/); } return *it; @@ -908,7 +956,7 @@ Layout & TextClass::operator[](docstring const & name) bool TextClass::deleteLayout(docstring const & name) { - if (name == defaultLayoutName() || name == emptyLayoutName()) + if (name == defaultLayoutName() || name == plainLayoutName()) return false; LayoutList::iterator it = @@ -929,8 +977,9 @@ bool TextClass::load(string const & path) const return true; // Read style-file, provided path is searched before the system ones - FileName layout_file; - if (!path.empty()) + // If path is a file, it is loaded directly. + FileName layout_file(path); + if (!path.empty() && !layout_file.isReadableFile()) layout_file = FileName(addName(path, name_ + ".layout")); if (layout_file.empty() || !layout_file.exists()) layout_file = libFileSearch("layouts", name_, "layout"); @@ -948,8 +997,17 @@ bool TextClass::load(string const & path) const } +void DocumentClass::addLayoutIfNeeded(docstring const & n) const +{ + if (!hasLayout(n)) + layoutlist_.push_back(createBasicLayout(n, true)); +} + + InsetLayout const & DocumentClass::insetLayout(docstring const & name) const { + // FIXME The fix for the InsetLayout part of 4812 would be here: + // Add the InsetLayout to the document class if it is not found. docstring n = name; InsetLayouts::const_iterator cen = insetlayoutlist_.end(); while (!n.empty()) { @@ -959,9 +1017,9 @@ InsetLayout const & DocumentClass::insetLayout(docstring const & name) const size_t i = n.find(':'); if (i == string::npos) break; - n = n.substr(0,i); + n = n.substr(0, i); } - return empty_insetlayout_; + return plain_insetlayout_; } @@ -978,23 +1036,67 @@ Layout const & TextClass::defaultLayout() const } -bool TextClass::isDefaultLayout(Layout const & lay) const +bool TextClass::isDefaultLayout(Layout const & layout) const +{ + return layout.name() == defaultLayoutName(); +} + + +bool TextClass::isPlainLayout(Layout const & layout) const { - return lay.name() == defaultLayoutName(); + return layout.name() == plainLayoutName(); } -bool TextClass::isEmptyLayout(Layout const & lay) const +Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const { - return lay.name() == emptyLayoutName(); + static Layout * defaultLayout = NULL; + + if (defaultLayout) { + defaultLayout->setUnknown(unknown); + defaultLayout->setName(name); + return *defaultLayout; + } + + static char const * s = "Margin Static\n" + "LatexType Paragraph\n" + "LatexName dummy\n" + "Align Block\n" + "AlignPossible Left, Right, Center\n" + "LabelType No_Label\n" + "End"; + istringstream ss(s); + Lexer lex(textClassTags); + lex.setStream(ss); + defaultLayout = new Layout; + defaultLayout->setUnknown(unknown); + defaultLayout->setName(name); + if (!readStyle(lex, *defaultLayout)) { + // The only way this happens is because the hardcoded layout above + // is wrong. + LASSERT(false, /**/); + }; + return *defaultLayout; } +///////////////////////////////////////////////////////////////////////// +// +// DocumentClassBundle +// +///////////////////////////////////////////////////////////////////////// + +DocumentClassBundle::~DocumentClassBundle() +{ + for (size_t i = 0; i != documentClasses_.size(); ++i) + delete documentClasses_[i]; + documentClasses_.clear(); +} DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass) { DocumentClass * dc = new DocumentClass(baseClass); - tc_list_.push_back(dc); - return *tc_list_.back(); + documentClasses_.push_back(dc); + return *documentClasses_.back(); } @@ -1005,6 +1107,12 @@ DocumentClassBundle & DocumentClassBundle::get() } +///////////////////////////////////////////////////////////////////////// +// +// DocumentClass +// +///////////////////////////////////////////////////////////////////////// + DocumentClass::DocumentClass(LayoutFile const & tc) : TextClass(tc) {} @@ -1033,6 +1141,12 @@ bool DocumentClass::hasTocLevels() const } +///////////////////////////////////////////////////////////////////////// +// +// PageSides +// +///////////////////////////////////////////////////////////////////////// + ostream & operator<<(ostream & os, PageSides p) { switch (p) {