#include "frontends/alert.h"
+#include "support/lassert.h"
#include "support/debug.h"
#include "support/ExceptionMessage.h"
#include "support/FileName.h"
#include <fstream>
#include <sstream>
-#include "boost/assert.hpp"
-
using namespace std;
using namespace lyx::support;
};
-int const FORMAT = 6;
+int const FORMAT = 7;
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;
}
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;
} // 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::emptylayout_ = from_ascii("Plain Layout");
InsetLayout DocumentClass::empty_insetlayout_;
+/////////////////////////////////////////////////////////////////////////
+//
+// TextClass
+//
+/////////////////////////////////////////////////////////////////////////
+
TextClass::TextClass()
{
outputType_ = LATEX;
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
}
{
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
TC_NOFLOAT,
TC_TITLELATEXNAME,
TC_TITLELATEXTYPE,
- TC_FORMAT
+ TC_FORMAT,
+ TC_ADDTOPREAMBLE
};
namespace {
- keyword_item textClassTags[] = {
+ LexerKeyword textClassTags[] = {
+ { "addtopreamble", TC_ADDTOPREAMBLE },
{ "classoptions", TC_CLASSOPTIONS },
{ "columns", TC_COLUMNS },
{ "counter", TC_COUNTER },
"LabelType No_Label\n"
"End";
istringstream ss(s);
- Lexer lex(textClassTags, sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lex(textClassTags);
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);
+ LASSERT(false, /**/);
};
layoutlist_.push_back(lay);
}
- Lexer lexrc(textClassTags,
- sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lexrc(textClassTags);
lexrc.setFile(filename);
ReturnValues retval = read(lexrc, rt);
bool TextClass::read(std::string const & str, ReadType rt)
{
- Lexer lexrc(textClassTags,
- sizeof(textClassTags) / sizeof(textClassTags[0]));
+ Lexer lexrc(textClassTags);
istringstream is(str);
lexrc.setStream(is);
ReturnValues retval = read(lexrc, rt);
FileName const tempfile = FileName::tempName();
ofstream os(tempfile.toFilesystemEncoding().c_str());
if (!os) {
- lyxerr << "Unable to create tempoary file in TextClass::read!!"
- << std::endl;
+ LYXERR0("Unable to create tempoary file");
return false;
}
os << str;
// now try to convert it
bool const worx = convertLayoutFormat(tempfile, rt);
if (!worx) {
- lyxerr << "Unable to convert internal layout information to format "
- << FORMAT << std::endl;
+ LYXERR0("Unable to convert internal layout information to format "
+ << FORMAT);
}
tempfile.removeFile();
return worx;
Layout & lay = operator[](name);
error = !readStyle(lexrc, lay);
} else {
- Layout lay;
- lay.setName(name);
+ Layout layout;
+ layout.setName(name);
if (le == TC_ENVIRONMENT)
- lay.is_environment = true;
- error = !readStyle(lexrc, lay);
+ layout.is_environment = true;
+ 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
}
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;
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();
case TC_INSETLAYOUT:
if (lexrc.next()) {
InsetLayout il;
- if (il.read(lexrc)) {
+ if (il.read(lexrc))
insetlayoutlist_[il.name()] = il;
- }
// else there was an error, so forget it
}
break;
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");
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<TitleLatexType>(le);
break;
default:
- lyxerr << "Unhandled value " << le
- << " in TextClass::readTitleType." << endl;
-
+ LYXERR0("Unhandled value " << le << " in TextClass::readTitleType.");
break;
}
}
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) {
outputType_ = static_cast<OutputType>(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();
continue;
default: break;
}
- switch (static_cast<ClassOptionsTags>(le)) {
+ switch (le) {
case CO_FONTSIZE:
lexrc.next();
opt_fontsize_ = rtrim(lexrc.getString());
}
-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 },
{ "type", FT_TYPE }
};
- lexrc.pushTable(floatTags, FT_END);
+ lexrc.pushTable(floatTags);
string type;
string placement;
continue;
default: break;
}
- switch (static_cast<FloatTags>(le)) {
+ switch (le) {
case FT_TYPE:
lexrc.next();
type = lexrc.getString();
}
-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 },
{ "within", CT_WITHIN }
};
- lexrc.pushTable(counterTags, CT_END);
+ lexrc.pushTable(counterTags);
docstring name;
docstring within;
continue;
default: break;
}
- switch (static_cast<CounterTags>(le)) {
+ switch (le) {
case CT_NAME:
lexrc.next();
name = lexrc.getDocString();
Layout const & TextClass::operator[](docstring const & name) const
{
- BOOST_ASSERT(!name.empty());
+ LASSERT(!name.empty(), /**/);
const_iterator it =
find_if(begin(), end(), LayoutNamesEqual(name));
lyxerr << " " << to_utf8(cit->name()) << endl;
// we require the name to exist
- BOOST_ASSERT(false);
+ LASSERT(false, /**/);
}
return *it;
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;
}
-bool TextClass::isDefaultLayout(Layout const & lay) const
+bool TextClass::isDefaultLayout(Layout const & layout) const
{
- return lay.name() == defaultLayoutName();
+ return layout.name() == defaultLayoutName();
}
-bool TextClass::isEmptyLayout(Layout const & lay) const
+bool TextClass::isEmptyLayout(Layout const & layout) const
{
- return lay.name() == emptyLayoutName();
+ return layout.name() == emptyLayoutName();
}
+/////////////////////////////////////////////////////////////////////////
+//
+// 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();
}
}
+/////////////////////////////////////////////////////////////////////////
+//
+// DocumentClass
+//
+/////////////////////////////////////////////////////////////////////////
+
DocumentClass::DocumentClass(LayoutFile const & tc)
: TextClass(tc)
{}
}
+/////////////////////////////////////////////////////////////////////////
+//
+// PageSides
+//
+/////////////////////////////////////////////////////////////////////////
+
ostream & operator<<(ostream & os, PageSides p)
{
switch (p) {