#include "BufferParams.h"
#include "Counters.h"
#include "Layout.h"
-#include "OutputParams.h"
#include "Paragraph.h"
#include "Text.h"
#include "TextClass.h"
#include "support/convert.h"
+#include "support/debug.h"
#include "support/docstream.h"
#include "support/lassert.h"
#include "support/lstrings.h"
}
-bool StartTag::operator==(FontTag const &rhs) const
-{
- return rhs == *this;
-}
-
-
docstring EndTag::writeEndTag() const
{
return from_utf8("</") + tag_ + from_utf8(">");
// automatically.
docstring attributes = escapeString(attr_, XMLStream::ESCAPE_NONE);
attributes.erase(attributes.begin(), std::find_if(attributes.begin(), attributes.end(),
- [](int c) {return !std::isspace(c);}));
+ [](char_type c) {return !isSpace(c);}));
if (!attributes.empty()) {
output += ' ' + attributes;
}
return output;
}
-
-bool FontTag::operator==(StartTag const & tag) const
-{
- FontTag const * const ftag = tag.asFontTag();
- if (!ftag)
- return false;
- return (font_type_ == ftag->font_type_);
-}
-
} // namespace xml
void XMLStream::writeError(std::string const &s)
{
- LYXERR0(s);
+ LYXERR(Debug::OUTFILE, s);
*this << ESCAPE_NONE << from_utf8("<!-- Output Error: " + s + " -->");
*this << xml::CR();
}
void XMLStream::writeError(docstring const &s)
{
- LYXERR0(s);
+ LYXERR(Debug::OUTFILE, s);
*this << ESCAPE_NONE << from_utf8("<!-- Output Error: ");
*this << s;
*this << ESCAPE_NONE << from_utf8(" -->");
}
+XMLStream &XMLStream::operator<<(xml::NullTag const &)
+{
+ is_last_tag_cr_ = false;
+ clearTagDeque();
+ // Don't output anything to os_, by definition of a NullTag (as opposed to text output).
+ escape_ = ESCAPE_ALL;
+ return *this;
+}
+
+
XMLStream &XMLStream::operator<<(const char *s)
{
is_last_tag_cr_ = false;
}
+bool operator==(xml::StartTag const & lhs, xml::StartTag const & rhs)
+{
+ xml::FontTag const * const lhs_ft = lhs.asFontTag();
+ xml::FontTag const * const rhs_ft = rhs.asFontTag();
+
+ if ((!lhs_ft && rhs_ft) || (lhs_ft && !rhs_ft))
+ return false;
+ if (!lhs_ft && !rhs_ft)
+ return lhs.tag_ == rhs.tag_;
+ return lhs_ft->tag_ == rhs_ft->tag_ && lhs_ft->font_type_ == rhs_ft->font_type_;
+}
+
+
+bool operator==(xml::EndTag const & lhs, xml::StartTag const & rhs)
+{
+ xml::EndFontTag const * const lhs_ft = lhs.asFontTag();
+ xml::FontTag const * const rhs_ft = rhs.asFontTag();
+
+ if ((!lhs_ft && rhs_ft) || (lhs_ft && !rhs_ft))
+ return false;
+ if (!lhs_ft && !rhs_ft)
+ return lhs.tag_ == rhs.tag_;
+ return lhs_ft->tag_ == rhs_ft->tag_ && lhs_ft->font_type_ == rhs_ft->font_type_;
+}
+
+
+bool operator!=(xml::EndTag const & lhs, xml::StartTag const & rhs)
+{
+ return !(lhs == rhs);
+}
+
+
+bool operator!=(xml::StartTag const & lhs, xml::StartTag const & rhs)
+{
+ return !(lhs == rhs);
+}
+
+
void xml::openTag(odocstream & os, string const & name, string const & attribute)
{
// FIXME UNICODE
string param = subst(attribute, "<", "\"");
param = subst(param, ">", "\"");
- // Note: we ignore the name if it empty or if it is a comment "<!-- -->" or
+ // Note: we ignore the name if it is empty or if it is a comment "<!-- -->" or
// if the name is *dummy*.
- // We ignore dummy because dummy is not a valid docbook element and it is
+ // We ignore dummy because dummy is not a valid DocBook element and it is
// the internal name given to single paragraphs in the latex output.
// This allow us to simplify the code a lot and is a reasonable compromise.
if (!name.empty() && name != "!-- --" && name != "dummy") {
}
+void openInlineTag(XMLStream & xs, const docstring & tag, const docstring & attr)
+{
+ xs << xml::StartTag(tag, attr);
+}
+
+
+void closeInlineTag(XMLStream & xs, const docstring & tag)
+{
+ xs << xml::EndTag(tag);
+}
+
+
+void openParTag(XMLStream & xs, const docstring & tag, const docstring & attr)
+{
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::StartTag(tag, attr);
+}
+
+
+void closeParTag(XMLStream & xs, const docstring & tag)
+{
+ xs << xml::EndTag(tag);
+ xs << xml::CR();
+}
+
+
+void openBlockTag(XMLStream & xs, const docstring & tag, const docstring & attr)
+{
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::StartTag(tag, attr);
+ xs << xml::CR();
+}
+
+
+void closeBlockTag(XMLStream & xs, const docstring & tag)
+{
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::EndTag(tag);
+ xs << xml::CR();
+}
+
+
+void xml::openTag(XMLStream & xs, const docstring & tag, const docstring & attr, const std::string & tagtype)
+{
+ if (tag.empty() || tag == from_ascii("NONE")) // Common check to be performed elsewhere, if it was not here.
+ return;
+
+ if (tag == from_ascii("para") || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
+ openParTag(xs, tag, attr);
+ else if (tagtype == "block")
+ openBlockTag(xs, tag, attr);
+ else if (tagtype == "inline")
+ openInlineTag(xs, tag, attr);
+ else if (tagtype == "none")
+ xs << xml::StartTag(tag, attr);
+ else
+ xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + to_utf8(tag) + (attr.empty() ? "" : " ") +
+ to_utf8(attr) + "'");
+}
+
+
+void xml::openTag(XMLStream & xs, const std::string & tag, const std::string & attr, const std::string & tagtype)
+{
+ xml::openTag(xs, from_utf8(tag), from_utf8(attr), tagtype);
+}
+
+
+void xml::openTag(XMLStream & xs, const docstring & tag, const std::string & attr, const std::string & tagtype)
+{
+ xml::openTag(xs, tag, from_utf8(attr), tagtype);
+}
+
+
+void xml::openTag(XMLStream & xs, const std::string & tag, const docstring & attr, const std::string & tagtype)
+{
+ xml::openTag(xs, from_utf8(tag), attr, tagtype);
+}
+
+
+void xml::closeTag(XMLStream & xs, const docstring & tag, const std::string & tagtype)
+{
+ if (tag.empty() || tag == "NONE" || tag == "IGNORE")
+ return;
+
+ if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
+ closeParTag(xs, tag);
+ else if (tagtype == "block")
+ closeBlockTag(xs, tag);
+ else if (tagtype == "inline")
+ closeInlineTag(xs, tag);
+ else if (tagtype == "none")
+ xs << xml::EndTag(tag);
+ else
+ xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + to_utf8(tag) + "'");
+}
+
+
+void xml::closeTag(XMLStream & xs, const std::string & tag, const std::string & tagtype)
+{
+ xml::closeTag(xs, from_utf8(tag), tagtype);
+}
+
+
+void xml::compTag(XMLStream & xs, const docstring & tag, const docstring & attr, const std::string & tagtype)
+{
+ if (tag.empty() || tag == from_ascii("NONE"))
+ return;
+
+ // Special case for <para>: always considered as a paragraph.
+ if (tag == from_ascii("para") || tagtype == "paragraph" || tagtype == "block") {
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::CompTag(tag, attr);
+ xs << xml::CR();
+ } else if (tagtype == "inline") {
+ xs << xml::CompTag(tag, attr);
+ } else {
+ xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + to_utf8(tag) + "'");
+ }
+}
+
+
+void xml::compTag(XMLStream & xs, const std::string & tag, const std::string & attr, const std::string & tagtype)
+{
+ xml::compTag(xs, from_utf8(tag), from_utf8(attr), tagtype);
+}
+
+
+void xml::compTag(XMLStream & xs, const docstring & tag, const std::string & attr, const std::string & tagtype)
+{
+ xml::compTag(xs, tag, from_utf8(attr), tagtype);
+}
+
+
+void xml::compTag(XMLStream & xs, const std::string & tag, const docstring & attr, const std::string & tagtype)
+{
+ xml::compTag(xs, from_utf8(tag), attr, tagtype);
+}
+
+
} // namespace lyx
projects / lyx.git / blobdiff