Try a simpler way to tell coverity that we do not care about the result

[lyx.git] / src / output_xhtml.cpp

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index 84d171b08ae2904ac11e4d82e224ae6d33df5857..037988ba69e684ef1a86ddb65fa81601e57c62e3 100644 (file)
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -335,6 +335,10 @@ bool XHTMLStream::closeFontTags()
                // we haven't had any content
                return true;
 
+#ifdef XHTML_DEBUG
+       dumpTagStack("Beging Close Font Tags");
+#endif
+
        // 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())
@@ -347,10 +351,14 @@ bool XHTMLStream::closeFontTags()
                tag_stack_.pop_back();
                // this shouldn't happen, since then the font tags
                // weren't in any other tag.
-               LBUFERR(!tag_stack_.empty());
+               LASSERT(!tag_stack_.empty(), return true);
                curtag = tag_stack_.back();
        }
 
+#ifdef XHTML_DEBUG
+       dumpTagStack("End Close Font Tags");
+#endif
+       
        if (*curtag == parsep_tag)
                return true;
 
@@ -368,15 +376,18 @@ bool XHTMLStream::closeFontTags()
 }
 
 
-void XHTMLStream::startParagraph(bool keep_empty)
+void XHTMLStream::startDivision(bool keep_empty)
 {
        pending_tags_.push_back(makeTagPtr(html::StartTag(parsep_tag)));
        if (keep_empty)
                clearTagDeque();
+#ifdef XHTML_DEBUG
+       dumpTagStack("StartDivision");
+#endif
 }
 
 
-void XHTMLStream::endParagraph()
+void XHTMLStream::endDivision()
 {
        if (isTagPending(parsep_tag)) {
                // this case is normal. it just means we didn't have content,
@@ -390,11 +401,16 @@ void XHTMLStream::endParagraph()
                        if (*cur_tag == parsep_tag)
                                break;
                }
+
+#ifdef XHTML_DEBUG
+               dumpTagStack("EndDivision");
+#endif
+               
                return;
        }
 
        if (!isTagOpen(parsep_tag)) {
-               writeError("No paragraph separation tag found in endParagraph().");
+               writeError("No division separation tag found in endDivision().");
                return;
        }
 
@@ -408,6 +424,10 @@ void XHTMLStream::endParagraph()
                writeError("Tag `" + cur_tag->tag_ + "' still open at end of paragraph. Closing.");
                os_ << cur_tag->writeEndTag();
        }
+
+#ifdef XHTML_DEBUG
+       dumpTagStack("EndDivision");
+#endif
 }
 
 
@@ -845,14 +865,30 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                //   (i) the current layout permits multiple paragraphs
                //  (ii) we are either not already inside a paragraph (HTMLIsBlock) OR
                //       we are, but this is not the first paragraph
-               // But we do not want to open the paragraph tag if this paragraph contains
+               //
+               // But there is also a special case, and we first see whether we are in it.
+               // We do not want to open the paragraph tag if this paragraph contains
                // only one item, and that item is "inline", i.e., not HTMLIsBlock (such 
-               // as a branch). That is the "special case" we handle first.
+               // as a branch). On the other hand, if that single item has a font change
+               // applied to it, then we still do need to open the paragraph.
+               //
+               // Obviously, this is very fragile. The main reason we need to do this is
+               // because of branches, e.g., a branch that contains an entire new section.
+               // We do not really want to wrap that whole thing in a <div>...</div>.
+               bool special_case = false;
                Inset const * specinset = par->size() == 1 ? par->getInset(0) : 0;
-               bool const special_case =  
-                       specinset && !specinset->getLayout().htmlisblock();
+               if (specinset && !specinset->getLayout().htmlisblock()) {
+                       Layout const & style = par->layout();
+                       FontInfo const first_font = style.labeltype == LABEL_MANUAL ?
+                                               style.labelfont : style.font;
+                       FontInfo const our_font =
+                               par->getFont(buf.masterBuffer()->params(), 0,
+                                      text.outerFont(distance(begin, par))).fontInfo();
+                       if (first_font == our_font)
+                               special_case = true;
+               }
 
-               bool const opened = runparams.html_make_pars
+               bool const open_par = runparams.html_make_pars
                        && (!runparams.html_in_par || par != pbegin)
                        && !special_case;
 
@@ -863,11 +899,11 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                //        but we are in the first par, and there is a next par.
                ParagraphList::const_iterator nextpar = par;
                ++nextpar;
-               bool const needclose =
-                       (opened && (!runparams.html_in_par || nextpar != pend))
-                       || (!opened && runparams.html_in_par && par == pbegin && nextpar != pend);
+               bool const close_par =
+                       (open_par && (!runparams.html_in_par || nextpar != pend))
+                       || (!open_par && runparams.html_in_par && par == pbegin && nextpar != pend);
 
-               if (opened) {
+               if (open_par) {
                        // We do not issue the paragraph id if we are doing 
                        // this for the TOC (or some similar purpose)
                        openParTag(xs, lay, par->params(),
@@ -876,15 +912,16 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
 
                docstring const deferred = par->simpleLyXHTMLOnePar(buf, xs, 
                        runparams, text.outerFont(distance(begin, par)),
-                       opened, needclose);
+                       open_par, close_par);
 
-               if (!deferred.empty()) {
-                       xs << XHTMLStream::ESCAPE_NONE << deferred << html::CR();
-               }
-               if (needclose) {
+               if (close_par) {
                        closeTag(xs, lay);
                        xs << html::CR();
                }
+
+               if (!deferred.empty()) {
+                       xs << XHTMLStream::ESCAPE_NONE << deferred << html::CR();
+               }
        }
        return pend;
 }
@@ -1010,8 +1047,9 @@ ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
                                if (labelfirst)
                                        openItemTag(xs, style, par->params());
 
-                               par->simpleLyXHTMLOnePar(buf, xs, runparams,
+                               docstring deferred = par->simpleLyXHTMLOnePar(buf, xs, runparams,
                                        text.outerFont(distance(begin, par)), true, true, sep);
+                               xs << XHTMLStream::ESCAPE_NONE << deferred;
                                ++par;
 
                                // We may not want to close the tag yet, in particular: