The logic of the endParagraph() routine is wrong. We should first

[lyx.git] / src / output_xhtml.cpp

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index 3a157c6f4d68c781da5b7fe65c35a39351c27c71..11d2de2734c90c309ebd4e368919999dbe3e070a 100644 (file)
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -198,10 +198,30 @@ XHTMLStream::XHTMLStream(odocstream & os)
 {}
 
 
-void XHTMLStream::writeError(std::string const & s)
+#if 0
+void XHTMLStream::dumpTagStack(string const & msg) const
+{
+       writeError(msg + ": Tag Stack");
+       TagStack::const_reverse_iterator it = tag_stack_.rbegin();
+       TagStack::const_reverse_iterator en = tag_stack_.rend();
+       for (; it != en; ++it) {
+               writeError(it->tag_);
+       }
+       writeError("Pending Tags");
+       it = pending_tags_.rbegin();
+       en = pending_tags_.rend();
+       for (; it != en; ++it) {
+               writeError(it->tag_);
+       }
+       writeError("End Tag Stack");
+}
+#endif
+
+
+void XHTMLStream::writeError(std::string const & s) const
 {
        LYXERR0(s);
-       os_ << from_utf8("<!-- Output Error: " + s + " -->");
+       os_ << from_utf8("<!-- Output Error: " + s + " -->\n");
 }
 
 
@@ -213,8 +233,15 @@ namespace {
 
 bool XHTMLStream::closeFontTags()
 {
+       if (isTagPending(parsep_tag))
+               // we haven't had any content
+               return true;
+
+       // this may be a useless check, since we ought at least to have
+       // the parsep_tag. but it can't hurt too much to be careful.
        if (tag_stack_.empty())
                return true;
+
        // first, we close any open font tags we can close
        html::StartTag curtag = tag_stack_.back();
        while (html::isFontTag(curtag.tag_)) {
@@ -227,7 +254,7 @@ bool XHTMLStream::closeFontTags()
                        return true;
                curtag = tag_stack_.back();
        }
-
+       
        if (curtag.tag_ == parsep_tag)
                return true;
 
@@ -246,45 +273,37 @@ bool XHTMLStream::closeFontTags()
 }
 
 
-void XHTMLStream::startParagraph()
+void XHTMLStream::startParagraph(bool keep_empty)
 {
        pending_tags_.push_back(html::StartTag(parsep_tag));
+       if (keep_empty)
+               clearTagDeque();
 }
 
 
 void XHTMLStream::endParagraph()
 {
-       if (!isTagOpen(parsep_tag)) {
-               // is it pending?
-               TagStack::const_iterator dit = pending_tags_.begin();
-               TagStack::const_iterator const den = pending_tags_.end();
-               bool found = false;
-               for (; dit != den; ++dit) {
-                       if (dit->tag_ == parsep_tag) {
-                               found = true;
-                               break;
-                       }
-               }
-
-               if (!found) {
-                       writeError("No paragraph separation tag found in endParagraph().");
-                       return;
-               }
-               
-               // this case is normal.
+       if (isTagPending(parsep_tag)) {
+               // this case is normal. it just means we didn't have content,
+               // so the parsep_tag never got moved onto the tag stack.
                while (!pending_tags_.empty()) {
                        // clear all pending tags up to and including the parsep tag.
                        // note that we work from the back, because we want to get rid
-                       // of everything that hasnt' been used.
+                       // of everything that hasn't been used.
                        html::StartTag const cur_tag = pending_tags_.back();
                        string const & tag = cur_tag.tag_;
-                       tag_stack_.pop_back();
+                       pending_tags_.pop_back();
                        if (tag == parsep_tag)
                                break;
                }
                return;
        }
 
+       if (!isTagOpen(parsep_tag)) {
+               writeError("No paragraph separation tag found in endParagraph().");
+               return;
+       }
+
        // this case is also normal, if the parsep tag is the last one 
        // on the stack. otherwise, it's an error.
        while (!tag_stack_.empty()) {
@@ -396,7 +415,7 @@ XHTMLStream & XHTMLStream::operator<<(html::CR const &)
 }
 
 
-bool XHTMLStream::isTagOpen(string const & stag)
+bool XHTMLStream::isTagOpen(string const & stag) const
 {
        TagStack::const_iterator sit = tag_stack_.begin();
        TagStack::const_iterator const sen = tag_stack_.end();
@@ -407,6 +426,17 @@ bool XHTMLStream::isTagOpen(string const & stag)
 }
 
 
+bool XHTMLStream::isTagPending(string const & stag) const
+{
+       TagStack::const_iterator sit = pending_tags_.begin();
+       TagStack::const_iterator const sen = pending_tags_.end();
+       for (; sit != sen; ++sit)
+               if (sit->tag_ == stag)
+                       return true;
+       return false;
+}
+
+
 // this is complicated, because we want to make sure that
 // everything is properly nested. the code ought to make 
 // sure of that, but we won't assert (yet) if we run into
@@ -922,11 +952,20 @@ void xhtmlParagraphs(Text const & text,
                       OutputParams const & runparams)
 {
        ParagraphList const & paragraphs = text.paragraphs();
-       ParagraphList::const_iterator par = paragraphs.begin();
-       ParagraphList::const_iterator pend = paragraphs.end();
+       if (runparams.par_begin == runparams.par_end) {
+               runparams.par_begin = 0;
+               runparams.par_end = paragraphs.size();
+       }
+       pit_type bpit = runparams.par_begin;
+       pit_type const epit = runparams.par_end;
+       LASSERT(bpit < epit, /* */);
 
        OutputParams ourparams = runparams;
-       while (par != pend) {
+       ParagraphList::const_iterator const pend =
+               (epit == (int) paragraphs.size()) ?
+                       paragraphs.end() : paragraphs.constIterator(epit);
+       while (bpit < epit) {
+               ParagraphList::const_iterator par = paragraphs.constIterator(bpit);
                if (par->params().startOfAppendix()) {
                        // FIXME: only the counter corresponding to toplevel
                        // sectioning should be reset
@@ -935,7 +974,7 @@ void xhtmlParagraphs(Text const & text,
                        cnts.appendix(true);
                }
                Layout const & style = par->layout();
-               ParagraphList::const_iterator lastpar = par;
+               ParagraphList::const_iterator const lastpar = par;
                ParagraphList::const_iterator send;
 
                switch (style.latextype) {
@@ -972,10 +1011,7 @@ void xhtmlParagraphs(Text const & text,
                        par = makeParagraphs(buf, xs, ourparams, text, par, send);
                        break;
                }
-               // FIXME??
-               // makeEnvironment may process more than one paragraphs and bypass pend
-               if (distance(lastpar, par) >= distance(lastpar, pend))
-                       break;
+               bpit += distance(lastpar, par);
        }
 }