htmldocvisitor.cpp File Reference

#include "htmldocvisitor.h"
#include "docparser.h"
#include "language.h"
#include "doxygen.h"
#include "outputgen.h"
#include "outputlist.h"
#include "dot.h"
#include "message.h"
#include "config.h"
#include "htmlgen.h"
#include "parserintf.h"
#include "msc.h"
#include "dia.h"
#include "util.h"
#include "vhdldocgen.h"
#include "filedef.h"
#include "memberdef.h"
#include "htmlentity.h"
#include "emoji.h"
#include "plantuml.h"
#include "mermaid.h"
#include "formula.h"
#include "fileinfo.h"
#include "indexlist.h"
#include "portable.h"
#include "codefragment.h"
#include "cite.h"
#include "md5.h"

Include dependency graph for htmldocvisitor.cpp:

Go to the source code of this file.

Enumerations
enum class	contexts_t {   NONE , STARTLI , STARTDD , ENDLI ,   ENDDD , STARTTD , ENDTD , INTERLI ,   INTERDD , INTERTD }

Functions
static constexpr const char *	contexts (contexts_t type)
static QCString	convertIndexWordToAnchor (const QCString &word)
static bool	mustBeOutsideParagraph (const DocNodeVariant &n)
static bool	isDocVerbatimVisible (const DocVerbatim &s)
static bool	isDocIncludeVisible (const DocInclude &s)
static bool	isDocIncOperatorVisible (const DocIncOperator &s)
static bool	isInvisibleNode (const DocNodeVariant &node)
template<class Node>
static bool	holds_value (const Node *val, const DocNodeVariant &v)
template<class T>
bool	isFirstChildNode (const T *parent, const DocPara &node)
template<class T>
bool	isLastChildNode (const T *parent, const DocPara &node)
bool	isSeparatedParagraph (const DocSimpleSect &parent, const DocPara &par)
static contexts_t	getParagraphContext (const DocPara &p, bool &isFirst, bool &isLast)
static bool	determineIfNeedsTag (const DocPara &p)
static bool	insideStyleChangeThatIsOutsideParagraph (const DocPara *para, DocNodeList::const_iterator it)
	Returns TRUE if the child nodes in paragraph para until nodeIndex contain a style change node that is still active and that style change is one that must be located outside of a paragraph, i.e.

Variables
static const int	NUM_HTML_LIST_TYPES = 4
static const char	g_types [][NUM_HTML_LIST_TYPES] = {"1", "a", "i", "A"}
static const char *	hex ="0123456789ABCDEF"

Enumeration Type Documentation

contexts_t

enum class contexts_t

strong

Enumerator
NONE
STARTLI
STARTDD
ENDLI
ENDDD
STARTTD
ENDTD
INTERLI
INTERDD
INTERTD

Definition at line 47 of file htmldocvisitor.cpp.

{
    NONE,      // 0
    STARTLI,   // 1
    STARTDD,   // 2
    ENDLI,     // 3
    ENDDD,     // 4
    STARTTD,   // 5
    ENDTD,     // 6
    INTERLI,   // 7
    INTERDD,   // 8
    INTERTD    // 9
};

Function Documentation

contexts()

constexpr const char * contexts ( contexts_t type )

staticconstexpr

Definition at line 61 of file htmldocvisitor.cpp.

{
  switch (type)
  {
    case contexts_t::NONE:    return nullptr;
    case contexts_t::STARTLI: return "startli";
    case contexts_t::STARTDD: return "startdd";
    case contexts_t::ENDLI:   return "endli";
    case contexts_t::ENDDD:   return "enddd";
    case contexts_t::STARTTD: return "starttd";
    case contexts_t::ENDTD:   return "endtd";
    case contexts_t::INTERLI: return "interli";
    case contexts_t::INTERDD: return "interdd";
    case contexts_t::INTERTD: return "intertd";
    default:                  return nullptr;
  }
}

References ENDDD, ENDLI, ENDTD, INTERDD, INTERLI, INTERTD, NONE, STARTDD, STARTLI, and STARTTD.

Referenced by HtmlDocVisitor::operator()().

convertIndexWordToAnchor()

QCString convertIndexWordToAnchor ( const QCString & word )

static

Definition at line 80 of file htmldocvisitor.cpp.

{
  static int cnt = 0;
  QCString result="a";
  QCString cntStr;
  result += cntStr.setNum(cnt);
  result += "_";
  cnt++;
  const char *str = word.data();
  unsigned char c = 0;
  if (str)
  {
    while ((c = *str++))
    {
      if ((c >= 'a' && c <= 'z') || // ALPHA
          (c >= 'A' && c <= 'Z') || // ALPHA
          (c >= '0' && c <= '9') || // DIGIT
          c == '-' ||
          c == '.'
         )
      {
        result += c;
      }
      else
      {
        char enc[4];
        enc[0] = '_';
        enc[1] = hex[(c & 0xf0) >> 4];
        enc[2] = hex[c & 0xf];
        enc[3] = 0;
        result += enc;
      }
    }
  }
  return result;
}

References QCString::data(), hex, and QCString::setNum().

Referenced by HtmlDocVisitor::operator()().

determineIfNeedsTag()

bool determineIfNeedsTag ( const DocPara & p )

static

Definition at line 1233 of file htmldocvisitor.cpp.

{
  bool needsTag = FALSE;
  if (p.parent())
  {
    if (holds_one_of_alternatives<DocSection,
                         DocInternal,
                         DocHtmlListItem,
                         DocHtmlDescData,
                         DocHtmlCell,
                         DocSimpleListItem,
                         DocAutoListItem,
                         DocSimpleSect,
                         DocXRefItem,
                         DocHtmlBlockQuote,
                         DocParBlock,
                         DocHtmlDetails,
                         DocHtmlSummary
                         >(*p.parent()))
    {
      needsTag = TRUE;
    }
    else if (std::get_if<DocRoot>(p.parent()))
    {
      needsTag = !std::get<DocRoot>(*p.parent()).singleLine();
    }
  }
  return needsTag;
}

References FALSE, holds_one_of_alternatives(), DocNode::parent(), and TRUE.

Referenced by HtmlDocVisitor::operator()().

getParagraphContext()

contexts_t getParagraphContext ( const DocPara & p, bool & isFirst, bool & isLast )

static

Definition at line 1101 of file htmldocvisitor.cpp.

{
  contexts_t t=contexts_t::NONE;
  isFirst=FALSE;
  isLast=FALSE;
  if (p.parent())
  {
    const auto parBlock = std::get_if<DocParBlock>(p.parent());
    if (parBlock)
    {
      // hierarchy: node N -> para -> parblock -> para
      // adapt return value to kind of N
      const DocNodeVariant *p3 = nullptr;
      if (::parent(p.parent()) && ::parent(::parent(p.parent())) )
      {
        p3 = ::parent(::parent(p.parent()));
      }
      isFirst=isFirstChildNode(parBlock,p);
      isLast =isLastChildNode (parBlock,p);
      bool isLI = p3!=nullptr && holds_one_of_alternatives<DocHtmlListItem,DocSecRefItem>(*p3);
      bool isDD = p3!=nullptr && holds_one_of_alternatives<DocHtmlDescData,DocXRefItem,DocSimpleSect>(*p3);
      bool isTD = p3!=nullptr && holds_one_of_alternatives<DocHtmlCell,DocParamList>(*p3);
      t=contexts_t::NONE;
      if (isFirst)
      {
        if (isLI) t=contexts_t::STARTLI; else if (isDD) t=contexts_t::STARTDD; else if (isTD) t=contexts_t::STARTTD;
      }
      if (isLast)
      {
        if (isLI) t=contexts_t::ENDLI;   else if (isDD) t=contexts_t::ENDDD;   else if (isTD) t=contexts_t::ENDTD;
      }
      if (!isFirst && !isLast)
      {
        if (isLI) t=contexts_t::INTERLI; else if (isDD) t=contexts_t::INTERDD; else if (isTD) t=contexts_t::INTERTD;
      }
      return t;
    }
    const auto docAutoListItem = std::get_if<DocAutoListItem>(p.parent());
    if (docAutoListItem)
    {
      isFirst=isFirstChildNode(docAutoListItem,p);
      isLast =isLastChildNode (docAutoListItem,p);
      t=contexts_t::STARTLI; // not used
      return t;
    }
    const auto docSimpleListItem = std::get_if<DocSimpleListItem>(p.parent());
    if (docSimpleListItem)
    {
      isFirst=TRUE;
      isLast =TRUE;
      t=contexts_t::STARTLI; // not used
      return t;
    }
    const auto docParamList = std::get_if<DocParamList>(p.parent());
    if (docParamList)
    {
      isFirst=TRUE;
      isLast =TRUE;
      t=contexts_t::STARTLI; // not used
      return t;
    }
    const auto docHtmlListItem = std::get_if<DocHtmlListItem>(p.parent());
    if (docHtmlListItem)
    {
      isFirst=isFirstChildNode(docHtmlListItem,p);
      isLast =isLastChildNode (docHtmlListItem,p);
      if (isFirst) t=contexts_t::STARTLI;
      if (isLast)  t=contexts_t::ENDLI;
      if (!isFirst && !isLast) t = contexts_t::INTERLI;
      return t;
    }
    const auto docSecRefItem = std::get_if<DocSecRefItem>(p.parent());
    if (docSecRefItem)
    {
      isFirst=isFirstChildNode(docSecRefItem,p);
      isLast =isLastChildNode (docSecRefItem,p);
      if (isFirst) t=contexts_t::STARTLI;
      if (isLast)  t=contexts_t::ENDLI;
      if (!isFirst && !isLast) t = contexts_t::INTERLI;
      return t;
    }
    const auto docHtmlDescData = std::get_if<DocHtmlDescData>(p.parent());
    if (docHtmlDescData)
    {
      isFirst=isFirstChildNode(docHtmlDescData,p);
      isLast =isLastChildNode (docHtmlDescData,p);
      if (isFirst) t=contexts_t::STARTDD;
      if (isLast)  t=contexts_t::ENDDD;
      if (!isFirst && !isLast) t = contexts_t::INTERDD;
      return t;
    }
    const auto docXRefItem = std::get_if<DocXRefItem>(p.parent());
    if (docXRefItem)
    {
      isFirst=isFirstChildNode(docXRefItem,p);
      isLast =isLastChildNode (docXRefItem,p);
      if (isFirst) t=contexts_t::STARTDD;
      if (isLast)  t=contexts_t::ENDDD;
      if (!isFirst && !isLast) t = contexts_t::INTERDD;
      return t;
    }
    const auto docSimpleSect = std::get_if<DocSimpleSect>(p.parent());
    if (docSimpleSect)
    {
      isFirst=isFirstChildNode(docSimpleSect,p);
      isLast =isLastChildNode (docSimpleSect,p);
      if (isFirst) t=contexts_t::STARTDD;
      if (isLast)  t=contexts_t::ENDDD;
      if (isSeparatedParagraph(*docSimpleSect,p))
        // if the paragraph is enclosed with separators it will
        // be included in <dd>..</dd> so avoid addition paragraph
        // markers
      {
        isFirst=isLast=TRUE;
      }
      if (!isFirst && !isLast) t = contexts_t::INTERDD;
      return t;
    }
    const auto docHtmlCell = std::get_if<DocHtmlCell>(p.parent());
    if (docHtmlCell)
    {
      isFirst=isFirstChildNode(docHtmlCell,p);
      isLast =isLastChildNode (docHtmlCell,p);
      if (isFirst) t=contexts_t::STARTTD;
      if (isLast)  t=contexts_t::ENDTD;
      if (!isFirst && !isLast) t = contexts_t::INTERTD;
      return t;
    }
  }
  return t;
}

References ENDDD, ENDLI, ENDTD, FALSE, holds_one_of_alternatives(), INTERDD, INTERLI, INTERTD, isFirstChildNode(), isLastChildNode(), isSeparatedParagraph(), NONE, DocNode::parent(), parent(), STARTDD, STARTLI, STARTTD, and TRUE.

Referenced by HtmlDocVisitor::forceEndParagraph(), HtmlDocVisitor::forceStartParagraph(), and HtmlDocVisitor::operator()().

holds_value()

template<class Node>

bool holds_value ( const Node * val, const DocNodeVariant & v )

static

Definition at line 1057 of file htmldocvisitor.cpp.

{
  bool b = std::visit([&](auto &&x) {
      //printf("holds_value val=%s (%p) v=%s (%p)\n",
      //        docNodeName(*val),(void*)val,docNodeName(v),(void *)&x);
      return val==static_cast<const DocNode*>(&x);
  }, v);
  return b;
}

Referenced by HtmlDocVisitor::forceEndParagraph(), HtmlDocVisitor::forceStartParagraph(), isFirstChildNode(), isLastChildNode(), and isSeparatedParagraph().

insideStyleChangeThatIsOutsideParagraph()

bool insideStyleChangeThatIsOutsideParagraph ( const DocPara * para, DocNodeList::const_iterator it )

static

Returns TRUE if the child nodes in paragraph para until nodeIndex contain a style change node that is still active and that style change is one that must be located outside of a paragraph, i.e.

it is a center, div, or pre tag. See also bug746162.

Definition at line 2357 of file htmldocvisitor.cpp.

{
  //printf("insideStyleChangeThatIsOutputParagraph(index=%d)\n",nodeIndex);
  int styleMask=0;
  bool styleOutsideParagraph=FALSE;
  while (!styleOutsideParagraph)
  {
    const DocNodeVariant *n = &(*it);
    const DocStyleChange *sc = std::get_if<DocStyleChange>(n);
    if (sc)
    {
      if (!sc->enable()) // remember styles that has been closed already
      {
        styleMask|=static_cast<int>(sc->style());
      }
      bool paraStyle = sc->style()==DocStyleChange::Center ||
                       sc->style()==DocStyleChange::Div    ||
                       sc->style()==DocStyleChange::Preformatted;
      //printf("Found style change %s enabled=%d\n",sc->styleString(),sc->enable());
      if (sc->enable() && (styleMask&static_cast<int>(sc->style()))==0 && // style change that is still active
          paraStyle
         )
      {
        styleOutsideParagraph=TRUE;
      }
    }
    if (it!=std::begin(para->children()))
    {
      --it;
    }
    else
    {
      break;
    }
  }
  return styleOutsideParagraph;
}

References DocStyleChange::Center, DocCompoundNode::children(), DocStyleChange::Div, DocStyleChange::enable(), FALSE, DocStyleChange::Preformatted, DocStyleChange::style(), and TRUE.

Referenced by HtmlDocVisitor::forceEndParagraph(), and HtmlDocVisitor::forceStartParagraph().

isDocIncludeVisible()

bool isDocIncludeVisible ( const DocInclude & s )

static

Definition at line 184 of file htmldocvisitor.cpp.

{
  switch (s.type())
  {
    case DocInclude::DontInclude:
    case DocInclude::LatexInclude:
    case DocInclude::RtfInclude:
    case DocInclude::ManInclude:
    case DocInclude::XmlInclude:
    case DocInclude::DocbookInclude:
      return FALSE;
    default:
      return TRUE;
  }
}

References DocInclude::DocbookInclude, DocInclude::DontInclude, FALSE, DocInclude::LatexInclude, DocInclude::ManInclude, DocInclude::RtfInclude, TRUE, DocInclude::type(), and DocInclude::XmlInclude.

Referenced by isInvisibleNode().

isDocIncOperatorVisible()

bool isDocIncOperatorVisible ( const DocIncOperator & s )

static

Definition at line 200 of file htmldocvisitor.cpp.

{
  switch (s.type())
  {
    case DocIncOperator::Skip:
      return FALSE;
    default:
      return TRUE;
  }
}

References FALSE, DocIncOperator::Skip, TRUE, and DocIncOperator::type().

Referenced by isInvisibleNode().

isDocVerbatimVisible()

bool isDocVerbatimVisible ( const DocVerbatim & s )

static

Definition at line 169 of file htmldocvisitor.cpp.

{
  switch (s.type())
  {
    case DocVerbatim::ManOnly:
    case DocVerbatim::LatexOnly:
    case DocVerbatim::XmlOnly:
    case DocVerbatim::RtfOnly:
    case DocVerbatim::DocbookOnly:
      return FALSE;
    default:
      return TRUE;
  }
}

References DocVerbatim::DocbookOnly, FALSE, DocVerbatim::LatexOnly, DocVerbatim::ManOnly, DocVerbatim::RtfOnly, TRUE, DocVerbatim::type(), and DocVerbatim::XmlOnly.

Referenced by isInvisibleNode().

isFirstChildNode()

template<class T>

bool isFirstChildNode	(	const T *	parent,
		const DocPara &	node )

Definition at line 1068 of file htmldocvisitor.cpp.

{
   return !parent->children().empty() && holds_value(&node,parent->children().front());
}

References holds_value(), and parent().

Referenced by getParagraphContext().

isInvisibleNode()

bool isInvisibleNode ( const DocNodeVariant & node )

static

Definition at line 211 of file htmldocvisitor.cpp.

{
  //printf("isInvisibleNode(%s)\n",docNodeName(node));
  // skip over white space
  const DocWhiteSpace *ws = std::get_if<DocWhiteSpace>(&node);
  if (ws) return true;
  // skip over image nodes that are not for HTML output
  const DocImage *di = std::get_if<DocImage>(&node);
  if (di) return di->type()!=DocImage::Html;
  // skip over verbatim nodes that are not visible in the HTML output
  const DocVerbatim *dv = std::get_if<DocVerbatim>(&node);
  if (dv) return !isDocVerbatimVisible(*dv);
  // skip over include nodes that are not visible in the HTML output
  const DocInclude *dinc = std::get_if<DocInclude>(&node);
  if (dinc) return !isDocIncludeVisible(*dinc);
  const DocIncOperator *dio = std::get_if<DocIncOperator>(&node);
  // skip over include operator nodes that are not visible in the HTML output
  if (dio) return !isDocIncOperatorVisible(*dio);
  return false;
}

References DocImage::Html, isDocIncludeVisible(), isDocIncOperatorVisible(), isDocVerbatimVisible(), and DocImage::type().

Referenced by HtmlDocVisitor::forceEndParagraph(), HtmlDocVisitor::forceStartParagraph(), and HtmlDocVisitor::operator()().

isLastChildNode()

template<class T>

bool isLastChildNode	(	const T *	parent,
		const DocPara &	node )

Definition at line 1074 of file htmldocvisitor.cpp.

{
   return !parent->children().empty() && holds_value(&node,parent->children().back());
}

References holds_value(), and parent().

Referenced by getParagraphContext().

isSeparatedParagraph()

bool isSeparatedParagraph	(	const DocSimpleSect &	parent,
		const DocPara &	par )

Definition at line 1079 of file htmldocvisitor.cpp.

{
  const DocNodeList &nodes = parent.children();
  auto it = std::find_if(std::begin(nodes),std::end(nodes),[&par](const auto &n) { return holds_value(&par,n); });
  if (it==std::end(nodes)) return FALSE;
  size_t count = parent.children().size();
  auto isSeparator = [](auto &&it_) { return std::get_if<DocSimpleSectSep>(&(*it_))!=nullptr; };
  if (count>1 && it==std::begin(nodes)) // it points to first node
  {
    return isSeparator(std::next(it));
  }
  else if (count>1 && it==std::prev(std::end(nodes))) // it points to last node
  {
    return isSeparator(std::prev(it));
  }
  else if (count>2 && it!=std::begin(nodes) && it!=std::prev(std::end(nodes))) // it points to intermediate node
  {
    return isSeparator(std::prev(it)) && isSeparator(std::next(it));
  }
  return false;
}

References FALSE, holds_value(), and parent().

Referenced by getParagraphContext().

mustBeOutsideParagraph()

bool mustBeOutsideParagraph ( const DocNodeVariant & n )

static

Definition at line 119 of file htmldocvisitor.cpp.

{
  //printf("mustBeOutsideParagraph(%s)=",docNodeName(n));
  if (holds_one_of_alternatives< /* <ul> */          DocHtmlList,   DocSimpleList, DocAutoList,
                                 /* <dl> */          DocSimpleSect, DocParamSect,  DocHtmlDescList, DocXRefItem,
                                 /* <table> */       DocHtmlTable,
                                 /* <h?> */          DocSection,    DocHtmlHeader,
                                 /* \internal */     DocInternal,
                                 /* <div> */         DocInclude,    DocSecRefList,
                                 /* <hr> */          DocHorRuler,
                                 /* <blockquote> */  DocHtmlBlockQuote,
                                 /* \parblock */     DocParBlock,
                                 /* \dotfile */      DocDotFile,
                                 /* \mscfile */      DocMscFile,
                                 /* \diafile */      DocDiaFile,
                                 /* \plantumlfile */ DocPlantUmlFile,
                                 /* \mermaidfile */  DocMermaidFile,
                                 /* <details> */     DocHtmlDetails,
                                 /* <summary> */     DocHtmlSummary,
                                                     DocIncOperator >(n))
  {
    return TRUE;
  }
  const DocVerbatim *dv = std::get_if<DocVerbatim>(&n);
  if (dv)
  {
    DocVerbatim::Type t = dv->type();
    if (t == DocVerbatim::JavaDocCode || t == DocVerbatim::JavaDocLiteral) return FALSE;
    return t!=DocVerbatim::HtmlOnly || dv->isBlock();
  }
  const DocStyleChange *sc = std::get_if<DocStyleChange>(&n);
  if (sc)
  {
    return sc->style()==DocStyleChange::Preformatted ||
           sc->style()==DocStyleChange::Div ||
           sc->style()==DocStyleChange::Center;
  }
  const DocFormula *df = std::get_if<DocFormula>(&n);
  if (df)
  {
    return !df->isInline();
  }
  const DocImage *di = std::get_if<DocImage>(&n);
  if (di)
  {
    return !di->isInlineImage();
  }
  return FALSE;
}

References DocStyleChange::Center, DocStyleChange::Div, FALSE, holds_one_of_alternatives(), DocVerbatim::HtmlOnly, DocVerbatim::isBlock(), DocFormula::isInline(), DocImage::isInlineImage(), DocVerbatim::JavaDocCode, DocVerbatim::JavaDocLiteral, DocStyleChange::Preformatted, DocStyleChange::style(), TRUE, and DocVerbatim::type().

Referenced by HtmlDocVisitor::forceEndParagraph(), HtmlDocVisitor::forceStartParagraph(), and HtmlDocVisitor::operator()().

Variable Documentation

g_types

const char g_types[][NUM_HTML_LIST_TYPES] = {"1", "a", "i", "A"}

static

Definition at line 46 of file htmldocvisitor.cpp.

{"1", "a", "i", "A"};

Referenced by HtmlDocVisitor::operator()().

hex

const char* hex ="0123456789ABCDEF"

static

Definition at line 78 of file htmldocvisitor.cpp.

NUM_HTML_LIST_TYPES

const int NUM_HTML_LIST_TYPES = 4

static

Definition at line 45 of file htmldocvisitor.cpp.

Referenced by HtmlDocVisitor::operator()().