Markdown::Private Struct Reference

Collaboration diagram for Markdown::Private:

Classes
struct	LinkRef

Public Types
using	Action_t = std::function<int(std::string_view,size_t)>

Public Member Functions
	Private (const QCString &fn, int line, int indent)
QCString	processQuotations (std::string_view data, size_t refIndent)
QCString	processBlocks (std::string_view data, size_t indent)
QCString	isBlockCommand (std::string_view data, size_t offset)
size_t	isSpecialCommand (std::string_view data, size_t offset)
size_t	findEndOfLine (std::string_view data, size_t offset)
int	processHtmlTagWrite (std::string_view data, size_t offset, bool doWrite)
	Process a HTML tag.
int	processHtmlTag (std::string_view data, size_t offset)
int	processEmphasis (std::string_view data, size_t offset)
int	processEmphasis1 (std::string_view data, char c)
	process single emphasis
int	processEmphasis2 (std::string_view data, char c)
	process double emphasis
int	processEmphasis3 (std::string_view data, char c)
	Parsing triple emphasis.
int	processNmdash (std::string_view data, size_t offset)
	Process ndash and mdashes.
int	processQuoted (std::string_view data, size_t offset)
	Process quoted section "...", can contain one embedded newline.
int	processCodeSpan (std::string_view data, size_t offset)
	` parsing a code span (assuming codespan != 0)
int	processSpecialCommand (std::string_view data, size_t offset)
int	processLink (std::string_view data, size_t offset)
size_t	findEmphasisChar (std::string_view, char c, size_t c_size)
	looks for the next emph char, skipping other constructs, and stopping when either it is found, or we are at the end of a paragraph.
void	addStrEscapeUtf8Nbsp (std::string_view data)
void	processInline (std::string_view data)
void	writeMarkdownImage (std::string_view fmt, bool inline_img, bool explicitTitle, const QCString &title, const QCString &content, const QCString &link, const QCString &attributes, const FileDef *fd)
int	isHeaderline (std::string_view data, bool allowAdjustLevel)
	returns whether the line is a setext-style hdr underline
int	isAtxHeader (std::string_view data, QCString &header, QCString &id, bool allowAdjustLevel, bool *pIsIdGenerated=nullptr)
void	writeOneLineHeaderOrRuler (std::string_view data)
void	writeFencedCodeBlock (std::string_view data, std::string_view lang, size_t blockStart, size_t blockEnd)
size_t	writeBlockQuote (std::string_view data)
size_t	writeCodeBlock (std::string_view, size_t refIndent)
size_t	writeTableBlock (std::string_view data)
QCString	extractTitleId (QCString &title, int level, bool *pIsIdGenerated=nullptr)

Public Attributes
std::unordered_map< std::string, LinkRef >	linkRefs
QCString	fileName
int	lineNr = 0
int	indentLevel =0
QCString	out
std::array< Action_t, 256 >	actions

Detailed Description

Definition at line 113 of file markdown.cpp.

Member Typedef Documentation

Action_t

using Markdown::Private::Action_t = std::function<int(std::string_view,size_t)>

Definition at line 172 of file markdown.cpp.

Constructor & Destructor Documentation

Private()

Markdown::Private::Private ( const QCString & fn, int line, int indent )

inline

Definition at line 115 of file markdown.cpp.

    : fileName(fn), lineNr(line), indentLevel(indent)
  {
    // setup callback table for special characters
    actions[static_cast<unsigned int>('_')] = [this](std::string_view data,size_t offset) { return processEmphasis      (data,offset); };
    actions[static_cast<unsigned int>('*')] = [this](std::string_view data,size_t offset) { return processEmphasis      (data,offset); };
    actions[static_cast<unsigned int>('~')] = [this](std::string_view data,size_t offset) { return processEmphasis      (data,offset); };
    actions[static_cast<unsigned int>('`')] = [this](std::string_view data,size_t offset) { return processCodeSpan      (data,offset); };
    actions[static_cast<unsigned int>('\\')]= [this](std::string_view data,size_t offset) { return processSpecialCommand(data,offset); };
    actions[static_cast<unsigned int>('@')] = [this](std::string_view data,size_t offset) { return processSpecialCommand(data,offset); };
    actions[static_cast<unsigned int>('[')] = [this](std::string_view data,size_t offset) { return processLink          (data,offset); };
    actions[static_cast<unsigned int>('!')] = [this](std::string_view data,size_t offset) { return processLink          (data,offset); };
    actions[static_cast<unsigned int>('<')] = [this](std::string_view data,size_t offset) { return processHtmlTag       (data,offset); };
    actions[static_cast<unsigned int>('-')] = [this](std::string_view data,size_t offset) { return processNmdash        (data,offset); };
    actions[static_cast<unsigned int>('"')] = [this](std::string_view data,size_t offset) { return processQuoted        (data,offset); };
  }

Member Function Documentation

addStrEscapeUtf8Nbsp()

void Markdown::Private::addStrEscapeUtf8Nbsp

(

std::string_view

data

)

Definition at line 1742 of file markdown.cpp.

{
  AUTO_TRACE("{}",Trace::trunc(data));
  if (Portable::strnstr(data.data(),g_doxy_nbsp,data.size())==nullptr) // no escape needed -> fast
  {
    out+=data;
  }
  else // escape needed -> slow
  {
    out+=substitute(QCString(data),g_doxy_nbsp,g_utf8_nbsp);
  }
}

References AUTO_TRACE, g_doxy_nbsp, g_utf8_nbsp, out, Portable::strnstr(), substitute(), and Trace::trunc().

Referenced by processSpecialCommand(), and writeFencedCodeBlock().

extractTitleId()

QCString Markdown::Private::extractTitleId	(	QCString &	title,
		int	level,
		bool *	pIsIdGenerated = nullptr )

Definition at line 2045 of file markdown.cpp.

{
  AUTO_TRACE("title={} level={}",Trace::trunc(title),level);
  // match e.g. '{#id-b11} ' and capture 'id-b11'
  static const reg::Ex r2(R"({#(\a[\w-]*)}\s*$)");
  reg::Match match;
  std::string ti = title.str();
  if (reg::search(ti,match,r2))
  {
    std::string id = match[1].str();
    title = title.left(match.position());
    if (AnchorGenerator::instance().reserve(id)>0)
    {
      warn(fileName, lineNr, "An automatically generated id already has the name '{}'!", id);
    }
    //printf("found match id='%s' title=%s\n",id.c_str(),qPrint(title));
    AUTO_TRACE_EXIT("id={}",id);
    return id;
  }
  if (((level>0) && (level<=Config_getInt(TOC_INCLUDE_HEADINGS))) || (Config_getEnum(MARKDOWN_ID_STYLE)==MARKDOWN_ID_STYLE_t::GITHUB))
  {
    QCString id = AnchorGenerator::instance().generate(ti);
    if (pIsIdGenerated) *pIsIdGenerated=true;
    //printf("auto-generated id='%s' title='%s'\n",qPrint(id),qPrint(title));
    AUTO_TRACE_EXIT("id={}",id);
    return id;
  }
  //printf("no id found in title '%s'\n",qPrint(title));
  return "";
}

References AUTO_TRACE, AUTO_TRACE_EXIT, Config_getEnum, Config_getInt, fileName, AnchorGenerator::generate(), AnchorGenerator::instance(), QCString::left(), lineNr, reg::search(), QCString::str(), Trace::trunc(), and warn.

Referenced by isAtxHeader(), and processBlocks().

findEmphasisChar()

size_t Markdown::Private::findEmphasisChar	(	std::string_view	data,
		char	c,
		size_t	c_size )

looks for the next emph char, skipping other constructs, and stopping when either it is found, or we are at the end of a paragraph.

Definition at line 702 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' c={} c_size={}",Trace::trunc(data),c,c_size);
  size_t i = 1;
  const size_t size = data.size();
 
  while (i<size)
  {
    while (i<size && data[i]!=c    &&
                     data[i]!='\\' && data[i]!='@' &&
                     !(data[i]=='/' && data[i-1]=='<') && // html end tag also ends emphasis
                     data[i]!='\n') i++;
    // avoid overflow (unclosed emph token)
    if (i==size)
    {
      return 0;
    }
    //printf("findEmphasisChar: data=[%s] i=%d c=%c\n",data,i,data[i]);
 
    // not counting escaped chars or characters that are unlikely
    // to appear as the end of the emphasis char
    if (ignoreCloseEmphChar(data[i-1],data[i]))
    {
      i++;
      continue;
    }
    else
    {
      // get length of emphasis token
      size_t len = 0;
      while (i+len<size && data[i+len]==c)
      {
        len++;
      }
 
      if (len>0)
      {
        if (len!=c_size || (i+len<size && isIdChar(data[i+len]))) // to prevent touching some_underscore_identifier
        {
          i+=len;
          continue;
        }
        AUTO_TRACE_EXIT("result={}",i);
        return static_cast<int>(i); // found it
      }
    }
 
    // skipping a code span
    if (data[i]=='`')
    {
      int snb=0;
      while (i<size && data[i]=='`') snb++,i++;
 
      // find same pattern to end the span
      int enb=0;
      while (i<size && enb<snb)
      {
        if (data[i]=='`') enb++;
        if (snb==1 && data[i]=='\'') break; // ` ended by '
        i++;
      }
    }
    else if (data[i]=='@' || data[i]=='\\')
    { // skip over blocks that should not be processed
      QCString endBlockName = isBlockCommand(data.substr(i),i);
      if (!endBlockName.isEmpty())
      {
        i++;
        size_t l = endBlockName.length();
        while (i+l<size)
        {
          if ((data[i]=='\\' || data[i]=='@') && // command
              data[i-1]!='\\' && data[i-1]!='@') // not escaped
          {
            if (qstrncmp(&data[i+1],endBlockName.data(),l)==0)
            {
              break;
            }
          }
          i++;
        }
      }
      else if (i+1<size && isIdChar(data[i+1])) // @cmd, stop processing, see bug 690385
      {
        return 0;
      }
      else
      {
        i++;
      }
    }
    else if (data[i-1]=='<' && data[i]=='/') // html end tag invalidates emphasis
    {
      return 0;
    }
    else if (data[i]=='\n') // end * or _ at paragraph boundary
    {
      i++;
      while (i<size && data[i]==' ') i++;
      if (i>=size || data[i]=='\n')
      {
        return 0;
      } // empty line -> paragraph
    }
    else // should not get here!
    {
      i++;
    }
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, QCString::data(), ignoreCloseEmphChar, isBlockCommand(), QCString::isEmpty(), isIdChar, QCString::length(), qstrncmp(), and Trace::trunc().

Referenced by processEmphasis1(), processEmphasis2(), and processEmphasis3().

findEndOfLine()

size_t Markdown::Private::findEndOfLine	(	std::string_view	data,
		size_t	offset )

Definition at line 3031 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  // find end of the line
  const size_t size = data.size();
  size_t nb=0, end=offset+1, j=0;
  while (end<=size && (j=isNewline(data.substr(end-1)))==0)
  {
    // while looking for the end of the line we might encounter a block
    // that needs to be passed unprocessed.
    if ((data[end-1]=='\\' || data[end-1]=='@') &&          // command
        (end<=1 || (data[end-2]!='\\' && data[end-2]!='@')) // not escaped
       )
    {
      QCString endBlockName = isBlockCommand(data.substr(end-1),end-1);
      end++;
      if (!endBlockName.isEmpty())
      {
        size_t l = endBlockName.length();
        for (;end+l+1<size;end++) // search for end of block marker
        {
          if ((data[end]=='\\' || data[end]=='@') &&
              data[end-1]!='\\' && data[end-1]!='@'
             )
          {
            if (qstrncmp(&data[end+1],endBlockName.data(),l)==0)
            {
              // found end marker, skip over this block
              //printf("feol.block out={%s}\n",qPrint(QCString(data+i).left(end+l+1-i)));
              end = end + l + 2;
              break;
            }
          }
        }
      }
    }
    else if (nb==0 && data[end-1]=='<' && size>=6 && end+6<size &&
             (end<=1 || (data[end-2]!='\\' && data[end-2]!='@'))
            )
    {
      if (tolower(data[end])=='p' && tolower(data[end+1])=='r' &&
          tolower(data[end+2])=='e' && (data[end+3]=='>' || data[end+3]==' ')) // <pre> tag
      {
        // skip part until including </pre>
        end  = end + processHtmlTagWrite(data.substr(end-1),end-1,false);
        break;
      }
      else
      {
        end++;
      }
    }
    else if (nb==0 && data[end-1]=='`')
    {
      while (end<=size && data[end-1]=='`') end++,nb++;
    }
    else if (nb>0 && data[end-1]=='`')
    {
      size_t enb=0;
      while (end<=size && data[end-1]=='`') end++,enb++;
      if (enb==nb) nb=0;
    }
    else
    {
      end++;
    }
  }
  if (j>0) end+=j-1;
  AUTO_TRACE_EXIT("offset={} end={}",offset,end);
  return end;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, QCString::data(), end(), isBlockCommand(), QCString::isEmpty(), isNewline(), QCString::length(), processHtmlTagWrite(), qstrncmp(), and Trace::trunc().

Referenced by processBlocks(), and processQuotations().

isAtxHeader()

int Markdown::Private::isAtxHeader	(	std::string_view	data,
		QCString &	header,
		QCString &	id,
		bool	allowAdjustLevel,
		bool *	pIsIdGenerated = nullptr )

Definition at line 2077 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' header={} id={} allowAdjustLevel={}",Trace::trunc(data),Trace::trunc(header),id,allowAdjustLevel);
  size_t i = 0;
  int level = 0, blanks=0;
  const size_t size = data.size();
 
  // find start of header text and determine heading level
  while (i<size && data[i]==' ') i++;
  if (i>=size || data[i]!='#')
  {
    return 0;
  }
  while (i<size && data[i]=='#') i++,level++;
  if (level>SectionType::MaxLevel) // too many #'s -> no section
  {
    return 0;
  }
  while (i<size && data[i]==' ') i++,blanks++;
  if (level==1 && blanks==0)
  {
    return 0; // special case to prevent #someid seen as a header (see bug 671395)
  }
 
  // find end of header text
  size_t end=i;
  while (end<size && data[end]!='\n') end++;
  while (end>i && (data[end-1]=='#' || data[end-1]==' ')) end--;
 
  // store result
  header = data.substr(i,end-i);
  id = extractTitleId(header, level, pIsIdGenerated);
  if (!id.isEmpty()) // strip #'s between title and id
  {
    int idx=static_cast<int>(header.length())-1;
    while (idx>=0 && (header.at(idx)=='#' || header.at(idx)==' ')) idx--;
    header=header.left(idx+1);
  }
 
  if (allowAdjustLevel && level==1 && indentLevel==-1)
  {
    // in case we find a `# Section` on a markdown page that started with the same level
    // header, we no longer need to artificially decrease the paragraph level.
    // So both
    // -------------------
    // # heading 1    <-- here we set g_indentLevel to -1
    // # heading 2    <-- here we set g_indentLevel back to 0 such that this will be a @section
    // -------------------
    // and
    // -------------------
    // # heading 1    <-- here we set  g_indentLevel to -1
    // ## heading 2   <-- here we keep g_indentLevel at -1 such that @subsection will be @section
    // -------------------
    // will convert to
    // -------------------
    // @page md_page Heading 1
    // @section autotoc_md1 Heading 2
    // -------------------
 
    indentLevel=0;
  }
  int res = level+indentLevel;
  AUTO_TRACE_EXIT("result={}",res);
  return res;
}

References QCString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, end(), extractTitleId(), indentLevel, QCString::left(), QCString::length(), SectionType::MaxLevel, and Trace::trunc().

Referenced by writeOneLineHeaderOrRuler().

isBlockCommand()

QCString Markdown::Private::isBlockCommand	(	std::string_view	data,
		size_t	offset )

Definition at line 360 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
 
  using EndBlockFunc = QCString (*)(const std::string &,bool,char);
 
  static const auto getEndBlock   = [](const std::string &blockName,bool,char) -> QCString
  {
    return "end"+blockName;
  };
  static const auto getEndCode    = [](const std::string &blockName,bool openBracket,char) -> QCString
  {
    return openBracket ? QCString("}") : "end"+blockName;
  };
  static const auto getEndUml     = [](const std::string &/* blockName */,bool,char) -> QCString
  {
    return "enduml";
  };
  static const auto getEndFormula = [](const std::string &/* blockName */,bool,char nextChar) -> QCString
  {
    switch (nextChar)
    {
      case '$': return "f$";
      case '(': return "f)";
      case '[': return "f]";
      case '{': return "f}";
    }
    return "";
  };
 
  // table mapping a block start command to a function that can return the matching end block string
  static const std::unordered_map<std::string,EndBlockFunc> blockNames =
  {
    { "dot",         getEndBlock   },
    { "code",        getEndCode    },
    { "icode",       getEndBlock   },
    { "msc",         getEndBlock   },
    { "verbatim",    getEndBlock   },
    { "iverbatim",   getEndBlock   },
    { "iliteral",    getEndBlock   },
    { "latexonly",   getEndBlock   },
    { "htmlonly",    getEndBlock   },
    { "xmlonly",     getEndBlock   },
    { "rtfonly",     getEndBlock   },
    { "manonly",     getEndBlock   },
    { "docbookonly", getEndBlock   },
    { "startuml",    getEndUml     },
    { "f",           getEndFormula }
  };
 
  const size_t size = data.size();
  bool openBracket = offset>0 && data.data()[-1]=='{';
  bool isEscaped = offset>0 && (data.data()[-1]=='\\' || data.data()[-1]=='@');
  if (isEscaped) return QCString();
 
  size_t end=1;
  while (end<size && (data[end]>='a' && data[end]<='z')) end++;
  if (end==1) return QCString();
  std::string blockName(data.substr(1,end-1));
  auto it = blockNames.find(blockName);
  QCString result;
  if (it!=blockNames.end()) // there is a function assigned
  {
    result = it->second(blockName, openBracket, end<size ? data[end] : 0);
  }
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, end(), QCString::size(), and Trace::trunc().

Referenced by findEmphasisChar(), findEndOfLine(), processBlocks(), and processSpecialCommand().

isHeaderline()

int Markdown::Private::isHeaderline	(	std::string_view	data,
		bool	allowAdjustLevel )

returns whether the line is a setext-style hdr underline

Definition at line 1858 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' allowAdjustLevel",Trace::trunc(data),allowAdjustLevel);
  size_t i=0, c=0;
  const size_t size = data.size();
  while (i<size && data[i]==' ') i++;
  if (i==size) return 0;
 
  // test of level 1 header
  if (data[i]=='=')
  {
    while (i<size && data[i]=='=') i++,c++;
    while (i<size && data[i]==' ') i++;
    int level = (c>1 && (i>=size || data[i]=='\n')) ? 1 : 0;
    if (allowAdjustLevel && level==1 && indentLevel==-1)
    {
      // In case a page starts with a header line we use it as title, promoting it to @page.
      // We set g_indentLevel to -1 to promoting the other sections if they have a deeper
      // nesting level than the page header, i.e. @section..@subsection becomes @page..@section.
      // In case a section at the same level is found (@section..@section) however we need
      // to undo this (and the result will be @page..@section).
      indentLevel=0;
    }
    AUTO_TRACE_EXIT("result={}",indentLevel+level);
    return indentLevel+level;
  }
  // test of level 2 header
  if (data[i]=='-')
  {
    while (i<size && data[i]=='-') i++,c++;
    while (i<size && data[i]==' ') i++;
    return (c>1 && (i>=size || data[i]=='\n')) ? indentLevel+2 : 0;
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, indentLevel, and Trace::trunc().

Referenced by processBlocks().

isSpecialCommand()

size_t Markdown::Private::isSpecialCommand	(	std::string_view	data,
		size_t	offset )

Definition at line 429 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
 
  using EndCmdFunc = size_t (*)(std::string_view,size_t);
 
  static const auto endOfLine = [](std::string_view data_,size_t offset_) -> size_t
  {
    // skip until the end of line (allowing line continuation characters)
    char lc = 0;
    char c = 0;
    while (offset_<data_.size() && ((c=data_[offset_])!='\n' || lc=='\\'))
    {
      if (c=='\\')     lc='\\'; // last character was a line continuation
      else if (c!=' ') lc=0;    // rest line continuation
      offset_++;
    }
    return offset_;
  };
 
  static const auto endOfLabels = [](std::string_view data_,size_t offset_,bool multi_) -> size_t
  {
    if (offset_<data_.size() && data_[offset_]==' ') // we expect a space before the label
    {
      char c = 0;
      offset_++;
      bool done=false;
      while (!done)
      {
        // skip over spaces
        while (offset_<data_.size() && data_[offset_]==' ')
        {
          offset_++;
        }
        // skip over label
        while (offset_<data_.size() && (c=data_[offset_])!=' ' && c!=',' && c!='\\' && c!='@' && c!='\n')
        {
          offset_++;
        }
        // optionally skip over a comma separated list of labels
        if (multi_ && offset_<data_.size() && (data_[offset_]==',' || data_[offset_]==' '))
        {
          size_t off = offset_;
          while (off<data_.size() && data_[off]==' ')
          {
            off++;
          }
          if (off<data_.size() && data_[off]==',')
          {
            offset_ = ++off;
          }
          else // no next label found
          {
            done=true;
          }
        }
        else
        {
          done=true;
        }
      }
      return offset_;
    }
    return 0;
  };
 
  static const auto endOfLabel = [](std::string_view data_,size_t offset_) -> size_t
  {
    return endOfLabels(data_,offset_,false);
  };
 
  static const auto endOfLabelOpt = [](std::string_view data_,size_t offset_) -> size_t
  {
    size_t index=offset_;
    if (index<data_.size() && data_[index]==' ') // skip over optional spaces
    {
      index++;
      while (index<data_.size() && data_[index]==' ') index++;
    }
    if (index<data_.size() && data_[index]=='{') // find matching '}'
    {
      index++;
      char c = 0;
      while (index<data_.size() && (c=data_[index])!='}' && c!='\\' && c!='@' && c!='\n') index++;
      if (index==data_.size() || data_[index]!='}') return 0; // invalid option
      offset_=index+1; // part after {...} is the option
    }
    return endOfLabel(data_,offset_);
  };
 
  static const auto endOfParam = [](std::string_view data_,size_t offset_) -> size_t
  {
    size_t index=offset_;
    if (index<data_.size() && data_[index]==' ') // skip over optional spaces
    {
      index++;
      while (index<data_.size() && data_[index]==' ') index++;
    }
    if (index<data_.size() && data_[index]=='[') // find matching ']'
    {
      index++;
      char c = 0;
      while (index<data_.size() && (c=data_[index])!=']' && c!='\n') index++;
      if (index==data_.size() || data_[index]!=']') return 0; // invalid parameter
      offset_=index+1; // part after [...] is the parameter name
    }
    return endOfLabels(data_,offset_,true);
  };
 
  static const auto endOfRetVal = [](std::string_view data_,size_t offset_) -> size_t
  {
    return endOfLabels(data_,offset_,true);
  };
 
  static const auto endOfFuncLike = [](std::string_view data_,size_t offset_,bool allowSpaces) -> size_t
  {
    if (offset_<data_.size() && data_[offset_]==' ') // we expect a space before the name
    {
      char c=0;
      offset_++;
      // skip over spaces
      while (offset_<data_.size() && data_[offset_]==' ')
      {
        offset_++;
      }
      // skip over name (and optionally type)
      while (offset_<data_.size() && (c=data_[offset_])!='\n' && (allowSpaces || c!=' ') && c!='(')
      {
        if (literal_at(data_.substr(offset_),"\\ilinebr ")) break;
        offset_++;
      }
      if (c=='(') // find the end of the function
      {
        int count=1;
        offset_++;
        while (offset_<data_.size() && (c=data_[offset_++]))
        {
          if      (c=='(') count++;
          else if (c==')') count--;
          if (count==0) return offset_;
        }
      }
      return offset_;
    }
    return 0;
  };
 
  static const auto endOfFunc = [](std::string_view data_,size_t offset_) -> size_t
  {
    return endOfFuncLike(data_,offset_,true);
  };
 
  static const auto endOfGuard = [](std::string_view data_,size_t offset_) -> size_t
  {
    return endOfFuncLike(data_,offset_,false);
  };
 
  static const std::unordered_map<std::string,EndCmdFunc> cmdNames =
  {
    { "a",              endOfLabel },
    { "addindex",       endOfLine  },
    { "addtogroup",     endOfLabel },
    { "anchor",         endOfLabel },
    { "b",              endOfLabel },
    { "c",              endOfLabel },
    { "category",       endOfLine  },
    { "cite",           endOfLabel },
    { "class",          endOfLine  },
    { "concept",        endOfLine  },
    { "copybrief",      endOfFunc  },
    { "copydetails",    endOfFunc  },
    { "copydoc",        endOfFunc  },
    { "def",            endOfFunc  },
    { "defgroup",       endOfLabel },
    { "diafile",        endOfLine  },
    { "dir",            endOfLine  },
    { "dockbookinclude",endOfLine  },
    { "dontinclude",    endOfLine  },
    { "dotfile",        endOfLine  },
    { "e",              endOfLabel },
    { "elseif",         endOfGuard },
    { "em",             endOfLabel },
    { "emoji",          endOfLabel },
    { "enum",           endOfLabel },
    { "example",        endOfLine  },
    { "exception",      endOfLine  },
    { "extends",        endOfLabel },
    { "file",           endOfLine  },
    { "fn",             endOfFunc  },
    { "headerfile",     endOfLine  },
    { "htmlinclude",    endOfLine  },
    { "ianchor",        endOfLabelOpt },
    { "idlexcept",      endOfLine  },
    { "if",             endOfGuard },
    { "ifnot",          endOfGuard },
    { "image",          endOfLine  },
    { "implements",     endOfLine  },
    { "include",        endOfLine  },
    { "includedoc",     endOfLine  },
    { "includelineno",  endOfLine  },
    { "ingroup",        endOfLabel },
    { "interface",      endOfLine  },
    { "latexinclude",   endOfLine  },
    { "maninclude",     endOfLine  },
    { "memberof",       endOfLabel },
    { "mscfile",        endOfLine  },
    { "namespace",      endOfLabel },
    { "noop",           endOfLine  },
    { "overload",       endOfLine  },
    { "p",              endOfLabel },
    { "package",        endOfLabel },
    { "page",           endOfLabel },
    { "paragraph",      endOfLabel },
    { "param",          endOfParam },
    { "property",       endOfLine  },
    { "protocol",       endOfLine  },
    { "qualifier",      endOfLine  },
    { "ref",            endOfLabel },
    { "refitem",        endOfLine  },
    { "related",        endOfLabel },
    { "relatedalso",    endOfLabel },
    { "relates",        endOfLabel },
    { "relatesalso",    endOfLabel },
    { "retval",         endOfRetVal},
    { "rtfinclude",     endOfLine  },
    { "section",        endOfLabel },
    { "skip",           endOfLine  },
    { "skipline",       endOfLine  },
    { "snippet",        endOfLine  },
    { "snippetdoc",     endOfLine  },
    { "snippetlineno",  endOfLine  },
    { "struct",         endOfLine  },
    { "subpage",        endOfLabel },
    { "subparagraph",   endOfLabel },
    { "subsubparagraph",endOfLabel },
    { "subsection",     endOfLabel },
    { "subsubsection",  endOfLabel },
    { "throw",          endOfLabel },
    { "throws",         endOfLabel },
    { "tparam",         endOfLabel },
    { "typedef",        endOfLine  },
    { "plantumlfile",   endOfLine  },
    { "union",          endOfLine  },
    { "until",          endOfLine  },
    { "var",            endOfLine  },
    { "verbinclude",    endOfLine  },
    { "weakgroup",      endOfLabel },
    { "xmlinclude",     endOfLine  },
    { "xrefitem",       endOfLabel }
  };
 
  bool isEscaped = offset>0 && (data.data()[-1]=='\\' || data.data()[-1]=='@');
  if (isEscaped) return 0;
 
  const size_t size = data.size();
  size_t end=1;
  while (end<size && (data[end]>='a' && data[end]<='z')) end++;
  if (end==1) return 0;
  std::string cmdName(data.substr(1,end-1));
  size_t result=0;
  auto it = cmdNames.find(cmdName);
  if (it!=cmdNames.end()) // command with parameters that should be ignored by markdown
  {
    // find the end of the parameters
    result = it->second(data,end);
  }
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, end(), literal_at(), and Trace::trunc().

Referenced by processSpecialCommand().

processBlocks()

QCString Markdown::Private::processBlocks	(	std::string_view	data,
		size_t	indent )

Definition at line 3285 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' indent={}",Trace::trunc(data),indent);
  out.clear();
  size_t pi = std::string::npos;
  QCString id,link,title;
 
#if 0 // commented out, since starting with a comment block is probably a usage error
      // see also http://stackoverflow.com/q/20478611/784672
 
  // special case when the documentation starts with a code block
  // since the first line is skipped when looking for a code block later on.
  if (end>codeBlockIndent && isCodeBlock(data,0,end,blockIndent))
  {
    i=writeCodeBlock(out,data,size,blockIndent);
    end=i+1;
    pi=-1;
  }
#endif
 
  size_t currentIndent = indent;
  size_t listIndent = indent;
  bool insideList = false;
  bool newBlock = false;
  // process each line
  size_t i=0;
  while (i<data.size())
  {
    size_t end = findEndOfLine(data,i);
    // line is now found at [i..end)
 
    size_t lineIndent=0;
    int level = 0;
    while (lineIndent<end && data[i+lineIndent]==' ') lineIndent++;
    //printf("** lineIndent=%d line=(%s)\n",lineIndent,qPrint(QCString(data+i).left(end-i)));
 
    if (newBlock)
    {
      //printf("** end of block\n");
      if (insideList && lineIndent<currentIndent) // end of list
      {
        //printf("** end of list\n");
        currentIndent = indent;
        insideList = false;
      }
      newBlock = false;
    }
 
    if ((listIndent=isListMarker(data.substr(i,end-i)))) // see if we need to increase the indent level
    {
      if (listIndent<currentIndent+4)
      {
        //printf("** start of list\n");
        insideList = true;
        currentIndent = listIndent;
      }
    }
    else if (isEndOfList(data.substr(i,end-i)))
    {
      //printf("** end of list\n");
      insideList = false;
      currentIndent = listIndent;
    }
    else if (isEmptyLine(data.substr(i,end-i)))
    {
      //printf("** new block\n");
      newBlock = true;
    }
 
    //printf("indent=%d listIndent=%d blockIndent=%d\n",indent,listIndent,blockIndent);
 
    //printf("findEndOfLine: pi=%d i=%d end=%d\n",pi,i,end);
 
    if (pi!=std::string::npos)
    {
      size_t blockStart=0, blockEnd=0, blockOffset=0;
      QCString lang;
      size_t blockIndent = currentIndent;
      size_t ref = 0;
      //printf("isHeaderLine(%s)=%d\n",QCString(data+i).left(size-i).data(),level);
      QCString endBlockName;
      if (data[i]=='@' || data[i]=='\\') endBlockName = isBlockCommand(data.substr(i),i);
      if (!endBlockName.isEmpty())
      {
        // handle previous line
        if (isLinkRef(data.substr(pi,i-pi),id,link,title))
        {
          linkRefs.emplace(id.lower().str(),LinkRef(link,title));
        }
        else
        {
          writeOneLineHeaderOrRuler(data.substr(pi,i-pi));
        }
        out+=data[i];
        i++;
        size_t l = endBlockName.length();
        while (i+l<data.size())
        {
          if ((data[i]=='\\' || data[i]=='@') && // command
              data[i-1]!='\\' && data[i-1]!='@') // not escaped
          {
            if (qstrncmp(&data[i+1],endBlockName.data(),l)==0)
            {
              out+=data[i];
              out+=endBlockName;
              i+=l+1;
              break;
            }
          }
          out+=data[i];
          i++;
        }
      }
      else if ((level=isHeaderline(data.substr(i),TRUE))>0)
      {
        //printf("Found header at %d-%d\n",i,end);
        while (pi<data.size() && data[pi]==' ') pi++;
        QCString header = data.substr(pi,i-pi-1);
        id = extractTitleId(header, level);
        //printf("header='%s' is='%s'\n",qPrint(header),qPrint(id));
        if (!header.isEmpty())
        {
          if (!id.isEmpty())
          {
            out+=level==1?"@section ":"@subsection ";
            out+=id;
            out+=" ";
            out+=header;
            out+="\n\n";
          }
          else
          {
            out+=level==1?"<h1>":"<h2>";
            out+=header;
            out+=level==1?"\n</h1>\n":"\n</h2>\n";
          }
        }
        else
        {
          out+="\n<hr>\n";
        }
        pi=std::string::npos;
        i=end;
        end=i+1;
        continue;
      }
      else if ((ref=isLinkRef(data.substr(pi),id,link,title)))
      {
        //printf("found link ref: id='%s' link='%s' title='%s'\n",
        //       qPrint(id),qPrint(link),qPrint(title));
        linkRefs.emplace(id.lower().str(),LinkRef(link,title));
        i=ref+pi;
        end=i+1;
      }
      else if (isFencedCodeBlock(data.substr(pi),currentIndent,lang,blockStart,blockEnd,blockOffset))
      {
        //printf("Found FencedCodeBlock lang='%s' start=%d end=%d code={%s}\n",
        //       qPrint(lang),blockStart,blockEnd,QCString(data+pi+blockStart).left(blockEnd-blockStart).data());
        writeFencedCodeBlock(data.substr(pi),lang.view(),blockStart,blockEnd);
        i=pi+blockOffset;
        pi=std::string::npos;
        end=i+1;
        continue;
      }
      else if (isCodeBlock(data.substr(i,end-i),i,blockIndent))
      {
        // skip previous line (it is empty anyway)
        i+=writeCodeBlock(data.substr(i),blockIndent);
        pi=std::string::npos;
        end=i+1;
        continue;
      }
      else if (isTableBlock(data.substr(pi)))
      {
        i=pi+writeTableBlock(data.substr(pi));
        pi=std::string::npos;
        end=i+1;
        continue;
      }
      else
      {
        writeOneLineHeaderOrRuler(data.substr(pi,i-pi));
      }
    }
    pi=i;
    i=end;
  }
  //printf("last line %d size=%d\n",i,size);
  if (pi!=std::string::npos && pi<data.size()) // deal with the last line
  {
    if (isLinkRef(data.substr(pi),id,link,title))
    {
      //printf("found link ref: id='%s' link='%s' title='%s'\n",
      //    qPrint(id),qPrint(link),qPrint(title));
      linkRefs.emplace(id.lower().str(),LinkRef(link,title));
    }
    else
    {
      writeOneLineHeaderOrRuler(data.substr(pi));
    }
  }
 
  return out;
}

References AUTO_TRACE, codeBlockIndent, QCString::data(), end(), extractTitleId(), findEndOfLine(), isBlockCommand(), isCodeBlock(), QCString::isEmpty(), isEmptyLine(), isEndOfList(), isFencedCodeBlock(), isHeaderline(), isLinkRef(), isListMarker(), isTableBlock(), QCString::length(), linkRefs, out, qstrncmp(), TRUE, Trace::trunc(), QCString::view(), writeCodeBlock(), writeFencedCodeBlock(), writeOneLineHeaderOrRuler(), and writeTableBlock().

processCodeSpan()

int Markdown::Private::processCodeSpan	(	std::string_view	data,
		size_t	offset )

` parsing a code span (assuming codespan != 0)

Definition at line 1629 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  const size_t size = data.size();
 
  /* counting the number of backticks in the delimiter */
  size_t nb=0, end=0;
  while (nb<size && data[nb]=='`')
  {
    nb++;
  }
 
  /* finding the next delimiter with the same amount of backticks */
  size_t i = 0;
  char pc = '`';
  for (end=nb; end<size; end++)
  {
    //AUTO_TRACE_ADD("c={} nb={} i={} size={}",data[end],nb,i,size);
    if (data[end]=='`')
    {
      i++;
      if (nb==1) // `...`
      {
        if (end+1<size && data[end+1]=='`') // skip over `` inside `...`
        {
          AUTO_TRACE_ADD("case1.1");
          // skip
          end++;
          i=0;
        }
        else // normal end of `...`
        {
          AUTO_TRACE_ADD("case1.2");
          break;
        }
      }
      else if (i==nb) // ``...``
      {
        if (end+1<size && data[end+1]=='`') // do greedy match
        {
          // skip this quote and use the next one to terminate the sequence, e.g. ``X`Y```
          i--;
          AUTO_TRACE_ADD("case2.1");
        }
        else // normal end of ``...``
        {
          AUTO_TRACE_ADD("case2.2");
          break;
        }
      }
    }
    else if (data[end]=='\n')
    {
      // consecutive newlines
      if (pc == '\n')
      {
        AUTO_TRACE_EXIT("new paragraph");
        return 0;
      }
      pc = '\n';
      i = 0;
    }
    else if (data[end]=='\'' && nb==1 && (end+1==size || (end+1<size && data[end+1]!='\'' && !isIdChar(data[end+1]))))
    { // look for quoted strings like 'some word', but skip strings like `it's cool`
      out+="&lsquo;";
      out+=data.substr(nb,end-nb);
      out+="&rsquo;";
      AUTO_TRACE_EXIT("quoted end={}",end+1);
      return static_cast<int>(end+1);
    }
    else if (data[end]=='\'' && nb==2 && end+1<size && data[end+1]=='\'')
    { // look for '' to match a ``
      out+="&ldquo;";
      out+=data.substr(nb,end-nb);
      out+="&rdquo;";
      AUTO_TRACE_EXIT("double quoted end={}",end+1);
      return static_cast<int>(end+2);
    }
    else
    {
      if (data[end]!=' ') pc = data[end];
      i=0;
    }
  }
  if (i < nb && end >= size)
  {
    AUTO_TRACE_EXIT("no matching delimiter nb={} i={}",nb,i);
    if (nb>=3) // found ``` that is not at the start of the line, keep it as-is.
    {
      out+=data.substr(0,nb);
      return nb;
    }
    return 0;  // no matching delimiter
  }
  while (end<size && data[end]=='`') // do greedy match in case we have more end backticks.
  {
    end++;
  }
 
  //printf("found code span '%s'\n",qPrint(QCString(data+f_begin).left(f_end-f_begin)));
 
  /* real code span */
  if (nb+nb < end)
  {
    QCString codeFragment = data.substr(nb, end-nb-nb);
    out+="<tt>";
    out+=escapeSpecialChars(codeFragment);
    out+="</tt>";
  }
  AUTO_TRACE_EXIT("result={} nb={}",end,nb);
  return static_cast<int>(end);
}

References AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, end(), escapeSpecialChars(), isIdChar, out, and Trace::trunc().

processEmphasis()

int Markdown::Private::processEmphasis	(	std::string_view	data,
		size_t	offset )

Definition at line 1105 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  const size_t size = data.size();
 
  if ((offset>0 && !isOpenEmphChar(data.data()[-1])) || // invalid char before * or _
      (size>1 && data[0]!=data[1] && !(isIdChar(data[1]) || extraChar(data[1]))) || // invalid char after * or _
      (size>2 && data[0]==data[1] && !(isIdChar(data[2]) || extraChar(data[2]))))   // invalid char after ** or __
  {
    AUTO_TRACE_EXIT("invalid surrounding characters");
    return 0;
  }
 
  char c = data[0];
  int ret = 0;
  if (size>2 && c!='~' && data[1]!=c) // _bla or *bla
  {
    // whitespace cannot follow an opening emphasis
    if (data[1]==' ' || data[1]=='\n' ||
        (ret = processEmphasis1(data.substr(1), c)) == 0)
    {
      return 0;
    }
    AUTO_TRACE_EXIT("result={}",ret+1);
    return ret+1;
  }
  if (size>3 && data[1]==c && data[2]!=c) // __bla or **bla
  {
    if (data[2]==' ' || data[2]=='\n' ||
        (ret = processEmphasis2(data.substr(2), c)) == 0)
    {
      return 0;
    }
    AUTO_TRACE_EXIT("result={}",ret+2);
    return ret+2;
  }
  if (size>4 && c!='~' && data[1]==c && data[2]==c && data[3]!=c) // ___bla or ***bla
  {
    if (data[3]==' ' || data[3]=='\n' ||
        (ret = processEmphasis3(data.substr(3), c)) == 0)
    {
      return 0;
    }
    AUTO_TRACE_EXIT("result={}",ret+3);
    return ret+3;
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, extraChar, isIdChar, isOpenEmphChar, processEmphasis1(), processEmphasis2(), processEmphasis3(), and Trace::trunc().

processEmphasis1()

int Markdown::Private::processEmphasis1	(	std::string_view	data,
		char	c )

process single emphasis

Definition at line 815 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' c={}",Trace::trunc(data),c);
  size_t i = 0;
  const size_t size = data.size();
 
  /* skipping one symbol if coming from emph3 */
  if (size>1 && data[0]==c && data[1]==c) { i=1; }
 
  while (i<size)
  {
    size_t len = findEmphasisChar(data.substr(i), c, 1);
    if (len==0) { return 0; }
    i+=len;
    if (i>=size) { return 0; }
 
    if (i+1<size && data[i+1]==c)
    {
      i++;
      continue;
    }
    if (data[i]==c && data[i-1]!=' ' && data[i-1]!='\n')
    {
      out+="<em>";
      processInline(data.substr(0,i));
      out+="</em>";
      AUTO_TRACE_EXIT("result={}",i+1);
      return static_cast<int>(i+1);
    }
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, findEmphasisChar(), out, processInline(), and Trace::trunc().

Referenced by processEmphasis(), and processEmphasis3().

processEmphasis2()

int Markdown::Private::processEmphasis2	(	std::string_view	data,
		char	c )

process double emphasis

Definition at line 849 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' c={}",Trace::trunc(data),c);
  size_t i = 0;
  const size_t size = data.size();
 
  while (i<size)
  {
    size_t len = findEmphasisChar(data.substr(i), c, 2);
    if (len==0)
    {
      return 0;
    }
    i += len;
    if (i+1<size && data[i]==c && data[i+1]==c && i && data[i-1]!=' ' && data[i-1]!='\n')
    {
      if (c == '~') out+="<strike>";
      else out+="<strong>";
      processInline(data.substr(0,i));
      if (c == '~') out+="</strike>";
      else out+="</strong>";
      AUTO_TRACE_EXIT("result={}",i+2);
      return static_cast<int>(i+2);
    }
    i++;
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, findEmphasisChar(), out, processInline(), and Trace::trunc().

Referenced by processEmphasis(), and processEmphasis3().

processEmphasis3()

int Markdown::Private::processEmphasis3	(	std::string_view	data,
		char	c )

Parsing triple emphasis.

Finds the first closing tag, and delegates to the other emph

Definition at line 881 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' c={}",Trace::trunc(data),c);
  size_t i = 0;
  const size_t size = data.size();
 
  while (i<size)
  {
    size_t len = findEmphasisChar(data.substr(i), c, 3);
    if (len==0)
    {
      return 0;
    }
    i+=len;
 
    /* skip whitespace preceded symbols */
    if (data[i]!=c || data[i-1]==' ' || data[i-1]=='\n')
    {
      continue;
    }
 
    if (i+2<size && data[i+1]==c && data[i+2]==c)
    {
      out+="<em><strong>";
      processInline(data.substr(0,i));
      out+="</strong></em>";
      AUTO_TRACE_EXIT("result={}",i+3);
      return static_cast<int>(i+3);
    }
    else if (i+1<size && data[i+1]==c)
    {
      // double symbol found, handing over to emph1
      len = processEmphasis1(std::string_view(data.data()-2, size+2), c);
      if (len==0)
      {
        return 0;
      }
      else
      {
        AUTO_TRACE_EXIT("result={}",len-2);
        return static_cast<int>(len - 2);
      }
    }
    else
    {
      // single symbol found, handing over to emph2
      len = processEmphasis2(std::string_view(data.data()-1, size+1), c);
      if (len==0)
      {
        return 0;
      }
      else
      {
        AUTO_TRACE_EXIT("result={}",len-1);
        return static_cast<int>(len - 1);
      }
    }
  }
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, findEmphasisChar(), out, processEmphasis1(), processEmphasis2(), processInline(), and Trace::trunc().

Referenced by processEmphasis().

processHtmlTag()

int Markdown::Private::processHtmlTag	(	std::string_view	data,
		size_t	offset )

Definition at line 1099 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  return processHtmlTagWrite(data,offset,true);
}

References AUTO_TRACE, processHtmlTagWrite(), and Trace::trunc().

processHtmlTagWrite()

int Markdown::Private::processHtmlTagWrite	(	std::string_view	data,
		size_t	offset,
		bool	doWrite )

Process a HTML tag.

Note that

..

are treated specially, in the sense that all code inside is written unprocessed

Definition at line 1009 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={} doWrite={}",Trace::trunc(data),offset,doWrite);
  if (offset>0 && data.data()[-1]=='\\') { return 0; } // escaped <
 
  const size_t size = data.size();
 
  // find the end of the html tag
  size_t i=1;
  size_t l=0;
  // compute length of the tag name
  while (i<size && isIdChar(data[i])) i++,l++;
  QCString tagName(data.substr(1,i-1));
  if (tagName.lower()=="pre") // found <pre> tag
  {
    bool insideStr=FALSE;
    while (i+6<size)
    {
      char c=data[i];
      if (!insideStr && c=='<') // potential start of html tag
      {
        if (data[i+1]=='/' &&
            tolower(data[i+2])=='p' && tolower(data[i+3])=='r' &&
            tolower(data[i+4])=='e' && tolower(data[i+5])=='>')
        { // found </pre> tag, copy from start to end of tag
          if (doWrite) out+=data.substr(0,i+6);
          //printf("found <pre>..</pre> [%d..%d]\n",0,i+6);
          AUTO_TRACE_EXIT("result={}",i+6);
          return static_cast<int>(i+6);
        }
      }
      else if (insideStr && c=='"')
      {
        if (data[i-1]!='\\') insideStr=FALSE;
      }
      else if (c=='"')
      {
        insideStr=TRUE;
      }
      i++;
    }
  }
  else // some other html tag
  {
    if (l>0 && i<size)
    {
      if (data[i]=='/' && i+1<size && data[i+1]=='>') // <bla/>
      {
        //printf("Found htmlTag={%s}\n",qPrint(QCString(data).left(i+2)));
        if (doWrite) out+=data.substr(0,i+2);
        AUTO_TRACE_EXIT("result={}",i+2);
        return static_cast<int>(i+2);
      }
      else if (data[i]=='>') // <bla>
      {
        //printf("Found htmlTag={%s}\n",qPrint(QCString(data).left(i+1)));
        if (doWrite) out+=data.substr(0,i+1);
        AUTO_TRACE_EXIT("result={}",i+1);
        return static_cast<int>(i+1);
      }
      else if (data[i]==' ') // <bla attr=...
      {
        i++;
        bool insideAttr=FALSE;
        while (i<size)
        {
          if (!insideAttr && data[i]=='"')
          {
            insideAttr=TRUE;
          }
          else if (data[i]=='"' && data[i-1]!='\\')
          {
            insideAttr=FALSE;
          }
          else if (!insideAttr && data[i]=='>') // found end of tag
          {
            //printf("Found htmlTag={%s}\n",qPrint(QCString(data).left(i+1)));
            if (doWrite) out+=data.substr(0,i+1);
            AUTO_TRACE_EXIT("result={}",i+1);
            return static_cast<int>(i+1);
          }
          i++;
        }
      }
    }
  }
  AUTO_TRACE_EXIT("not a valid html tag");
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, FALSE, isIdChar, QCString::lower(), out, TRUE, and Trace::trunc().

Referenced by findEndOfLine(), and processHtmlTag().

processInline()

void Markdown::Private::processInline

(

std::string_view

data

)

Definition at line 1828 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  size_t end=0;
  Action_t action;
  const size_t size = data.size();
  while (i<size)
  {
    // skip over characters that do not trigger a specific action
    while (end<size && ((action=actions[static_cast<uint8_t>(data[end])])==nullptr)) end++;
    // and add them to the output
    out+=data.substr(i,end-i);
    if (end>=size) break;
    i=end;
    // do the action matching a special character at i
    int iend = action(data.substr(i),i);
    if (iend<=0) // update end
    {
      end=i+1-iend;
    }
    else // skip until end
    {
      i+=iend;
      end=i;
    }
  }
}

References actions, AUTO_TRACE, end(), out, and Trace::trunc().

Referenced by processEmphasis1(), processEmphasis2(), processEmphasis3(), and processLink().

processLink()

int Markdown::Private::processLink	(	std::string_view	data,
		size_t	offset )

Definition at line 1197 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  const size_t size = data.size();
  QCString content;
  QCString link;
  QCString title;
  bool isImageLink = FALSE;
  bool isImageInline = FALSE;
  bool isToc = FALSE;
  size_t i=1;
  if (data[0]=='!')
  {
    isImageLink = TRUE;
    if (size<2 || data[1]!='[')
    {
      return 0;
    }
 
    // if there is non-whitespace before the ![ within the scope of two new lines, the image
    // is considered inlined, i.e. the image is not preceded by an empty line
    int numNLsNeeded=2;
    int pos = -1;
    while (pos>=-static_cast<int>(offset) && numNLsNeeded>0)
    {
      if (data.data()[pos]=='\n') numNLsNeeded--;
      else if (data.data()[pos]!=' ') // found non-whitespace, stop searching
      {
        isImageInline=true;
        break;
      }
      pos--;
    }
    // skip '!['
    i++;
  }
  size_t contentStart=i;
  int level=1;
  int nlTotal=0;
  int nl=0;
  // find the matching ]
  while (i<size)
  {
    if (data[i-1]=='\\') // skip escaped characters
    {
    }
    else if (data[i]=='[')
    {
      level++;
    }
    else if (data[i]==']')
    {
      level--;
      if (level<=0) break;
    }
    else if (data[i]=='\n')
    {
      nl++;
      if (nl>1) { return 0; } // only allow one newline in the content
    }
    i++;
  }
  nlTotal += nl;
  nl = 0;
  if (i>=size) return 0; // premature end of comment -> no link
  size_t contentEnd=i;
  content = data.substr(contentStart,contentEnd-contentStart);
  //printf("processLink: content={%s}\n",qPrint(content));
  if (!isImageLink && content.isEmpty()) { return 0; } // no link text
  i++; // skip over ]
 
  bool whiteSpace = false;
  // skip whitespace
  while (i<size && data[i]==' ') { whiteSpace = true; i++; }
  if (i<size && data[i]=='\n') // one newline allowed here
  {
    whiteSpace = true;
    i++;
    // skip more whitespace
    while (i<size && data[i]==' ') i++;
  }
  if (whiteSpace && i<size && (data[i]=='(' || data[i]=='[')) return 0;
 
  bool explicitTitle=FALSE;
  if (i<size && data[i]=='(') // inline link
  {
    i++;
    while (i<size && data[i]==' ') i++;
    bool uriFormat=false;
    if (i<size && data[i]=='<') { i++; uriFormat=true; }
    size_t linkStart=i;
    int braceCount=1;
    while (i<size && data[i]!='\'' && data[i]!='"' && braceCount>0)
    {
      if (data[i]=='\n') // unexpected EOL
      {
        nl++;
        if (nl>1) { return 0; }
      }
      else if (data[i]=='(')
      {
        braceCount++;
      }
      else if (data[i]==')')
      {
        braceCount--;
      }
      if (braceCount>0)
      {
        i++;
      }
    }
    nlTotal += nl;
    nl = 0;
    if (i>=size || data[i]=='\n') { return 0; }
    link = data.substr(linkStart,i-linkStart);
    link = link.stripWhiteSpace();
    //printf("processLink: link={%s}\n",qPrint(link));
    if (link.isEmpty()) { return 0; }
    if (uriFormat && link.at(link.length()-1)=='>') link=link.left(link.length()-1);
 
    // optional title
    if (data[i]=='\'' || data[i]=='"')
    {
      char c = data[i];
      i++;
      size_t titleStart=i;
      nl=0;
      while (i<size)
      {
        if (data[i]=='\n')
        {
          if (nl>1) { return 0; }
          nl++;
        }
        else if (data[i]=='\\') // escaped char in string
        {
          i++;
        }
        else if (data[i]==c)
        {
          i++;
          break;
        }
        i++;
      }
      if (i>=size)
      {
        return 0;
      }
      size_t titleEnd = i-1;
      // search back for closing marker
      while (titleEnd>titleStart && data[titleEnd]==' ') titleEnd--;
      if (data[titleEnd]==c) // found it
      {
        title = data.substr(titleStart,titleEnd-titleStart);
        explicitTitle=TRUE;
        while (i<size)
        {
          if (data[i]==' ')i++; // remove space after the closing quote and the closing bracket
          else if (data[i] == ')') break; // the end bracket
          else // illegal
          {
            return 0;
          }
        }
      }
      else
      {
        return 0;
      }
    }
    i++;
  }
  else if (i<size && data[i]=='[') // reference link
  {
    i++;
    size_t linkStart=i;
    nl=0;
    // find matching ]
    while (i<size && data[i]!=']')
    {
      if (data[i]=='\n')
      {
        nl++;
        if (nl>1) { return 0; }
      }
      i++;
    }
    if (i>=size) { return 0; }
    // extract link
    link = data.substr(linkStart,i-linkStart);
    //printf("processLink: link={%s}\n",qPrint(link));
    link = link.stripWhiteSpace();
    if (link.isEmpty()) // shortcut link
    {
      link=content;
    }
    // lookup reference
    QCString link_lower = link.lower();
    auto lr_it=linkRefs.find(link_lower.str());
    if (lr_it!=linkRefs.end()) // found it
    {
      link  = lr_it->second.link;
      title = lr_it->second.title;
      //printf("processLink: ref: link={%s} title={%s}\n",qPrint(link),qPrint(title));
    }
    else // reference not found!
    {
      //printf("processLink: ref {%s} do not exist\n",link.qPrint(lower()));
      return 0;
    }
    i++;
  }
  else if (i<size && data[i]!=':' && !content.isEmpty()) // minimal link ref notation [some id]
  {
    QCString content_lower = content.lower();
    auto lr_it = linkRefs.find(content_lower.str());
    //printf("processLink: minimal link {%s} lr=%p",qPrint(content),lr);
    if (lr_it!=linkRefs.end()) // found it
    {
      link  = lr_it->second.link;
      title = lr_it->second.title;
      explicitTitle=TRUE;
      i=contentEnd;
    }
    else if (content=="TOC")
    {
      isToc=TRUE;
      i=contentEnd;
    }
    else
    {
      return 0;
    }
    i++;
  }
  else
  {
    return 0;
  }
  nlTotal += nl;
 
  // search for optional image attributes
  QCString attributes;
  if (isImageLink)
  {
    size_t j = i;
    // skip over whitespace
    while (j<size && data[j]==' ') { j++; }
    if (j<size && data[j]=='{') // we have attributes
    {
      i = j;
      // skip over '{'
      i++;
      size_t attributesStart=i;
      nl=0;
      // find the matching '}'
      while (i<size)
      {
        if (data[i-1]=='\\') // skip escaped characters
        {
        }
        else if (data[i]=='{')
        {
          level++;
        }
        else if (data[i]=='}')
        {
          level--;
          if (level<=0) break;
        }
        else if (data[i]=='\n')
        {
          nl++;
          if (nl>1) { return 0; } // only allow one newline in the content
        }
        i++;
      }
      nlTotal += nl;
      if (i>=size) return 0; // premature end of comment -> no attributes
      size_t attributesEnd=i;
      attributes = data.substr(attributesStart,attributesEnd-attributesStart);
      i++; // skip over '}'
    }
    if (!isImageInline)
    {
      // if there is non-whitespace after the image within the scope of two new lines, the image
      // is considered inlined, i.e. the image is not followed by an empty line
      int numNLsNeeded=2;
      size_t pos = i;
      while (pos<size && numNLsNeeded>0)
      {
        if (data[pos]=='\n') numNLsNeeded--;
        else if (data[pos]!=' ') // found non-whitespace, stop searching
        {
          isImageInline=true;
          break;
        }
        pos++;
      }
    }
  }
 
  if (isToc) // special case for [TOC]
  {
    int toc_level = Config_getInt(TOC_INCLUDE_HEADINGS);
    if (toc_level>=SectionType::MinLevel && toc_level<=SectionType::MaxLevel)
    {
      out+="@tableofcontents{html:";
      out+=QCString().setNum(toc_level);
      out+="}";
    }
  }
  else if (isImageLink)
  {
    bool ambig = false;
    FileDef *fd=nullptr;
    if (link.find("@ref ")!=-1 || link.find("\\ref ")!=-1 ||
        (fd=findFileDef(Doxygen::imageNameLinkedMap,link,ambig)))
        // assume doxygen symbol link or local image link
    {
      // check if different handling is needed per format
      writeMarkdownImage("html",    isImageInline, explicitTitle, title, content, link, attributes, fd);
      writeMarkdownImage("latex",   isImageInline, explicitTitle, title, content, link, attributes, fd);
      writeMarkdownImage("rtf",     isImageInline, explicitTitle, title, content, link, attributes, fd);
      writeMarkdownImage("docbook", isImageInline, explicitTitle, title, content, link, attributes, fd);
      writeMarkdownImage("xml",     isImageInline, explicitTitle, title, content, link, attributes, fd);
    }
    else
    {
      out+="<img src=\"";
      out+=link;
      out+="\" alt=\"";
      out+=content;
      out+="\"";
      if (!title.isEmpty())
      {
        out+=" title=\"";
        out+=substitute(title.simplifyWhiteSpace(),"\"","&quot;");
        out+="\"";
      }
      out+="/>";
    }
  }
  else
  {
    SrcLangExt lang = getLanguageFromFileName(link);
    int lp=-1;
    if ((lp=link.find("@ref "))!=-1 || (lp=link.find("\\ref "))!=-1 || (lang==SrcLangExt::Markdown && !isURL(link)))
        // assume doxygen symbol link
    {
      if (lp==-1) // link to markdown page
      {
        out+="@ref \"";
        if (!(Portable::isAbsolutePath(link) || isURL(link)))
        {
          FileInfo forg(link.str());
          if (forg.exists() && forg.isReadable())
          {
            link = forg.absFilePath();
          }
          else if (!(forg.exists() && forg.isReadable()))
          {
            FileInfo fi(fileName.str());
            QCString mdFile = fileName.left(fileName.length()-fi.fileName().length()) + link;
            FileInfo fmd(mdFile.str());
            if (fmd.exists() && fmd.isReadable())
            {
              link = fmd.absFilePath().data();
            }
          }
        }
        out+=link;
        out+="\"";
      }
      else
      {
        out+=link;
      }
      out+=" \"";
      if (explicitTitle && !title.isEmpty())
      {
        out+=substitute(title,"\"","&quot;");
      }
      else
      {
        processInline(std::string_view(substitute(content,"\"","&quot;").str()));
      }
      out+="\"";
    }
    else if ((lp=link.find('#'))!=-1 || link.find('/')!=-1 || link.find('.')!=-1)
    { // file/url link
      if (lp==0 || (lp>0 && !isURL(link) && Config_getEnum(MARKDOWN_ID_STYLE)==MARKDOWN_ID_STYLE_t::GITHUB))
      {
        out+="@ref \"";
        out+=AnchorGenerator::addPrefixIfNeeded(link.mid(lp+1).str());
        out+="\" \"";
        out+=substitute(content.simplifyWhiteSpace(),"\"","&quot;");
        out+="\"";
      }
      else
      {
        out+="<a href=\"";
        out+=link;
        out+="\"";
        for (int ii = 0; ii < nlTotal; ii++) out+="\n";
        if (!title.isEmpty())
        {
          out+=" title=\"";
          out+=substitute(title.simplifyWhiteSpace(),"\"","&quot;");
          out+="\"";
        }
        out+=" ";
        out+=externalLinkTarget();
        out+=">";
        content = content.simplifyWhiteSpace();
        processInline(std::string_view(content.str()));
        out+="</a>";
      }
    }
    else // avoid link to e.g. F[x](y)
    {
      //printf("no link for '%s'\n",qPrint(link));
      return 0;
    }
  }
  AUTO_TRACE_EXIT("result={}",i);
  return static_cast<int>(i);
}

References FileInfo::absFilePath(), AnchorGenerator::addPrefixIfNeeded(), QCString::at(), AUTO_TRACE, AUTO_TRACE_EXIT, Config_getEnum, Config_getInt, FileInfo::exists(), externalLinkTarget(), FALSE, FileInfo::fileName(), fileName, QCString::find(), findFileDef(), getLanguageFromFileName(), Doxygen::imageNameLinkedMap, Portable::isAbsolutePath(), QCString::isEmpty(), FileInfo::isReadable(), isURL(), QCString::left(), QCString::length(), linkRefs, QCString::lower(), SectionType::MaxLevel, QCString::mid(), SectionType::MinLevel, out, processInline(), QCString::setNum(), QCString::simplifyWhiteSpace(), QCString::str(), QCString::stripWhiteSpace(), substitute(), TRUE, Trace::trunc(), and writeMarkdownImage().

processNmdash()

int Markdown::Private::processNmdash	(	std::string_view	data,
		size_t	offset )

Process ndash and mdashes.

Definition at line 943 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  const size_t size = data.size();
  // precondition: data[0]=='-'
  size_t i=1;
  int count=1;
  if (i<size && data[i]=='-') // found --
  {
    count++,i++;
  }
  if (i<size && data[i]=='-') // found ---
  {
    count++,i++;
  }
  if (i<size && data[i]=='-') // found ----
  {
    count++;
  }
  if (count>=2 && offset>=2 && literal_at(data.data()-2,"<!"))
  { AUTO_TRACE_EXIT("result={}",1-count); return 1-count; } // start HTML comment
  if (count==2 && size > 2 && data[2]=='>')
  { return 0; } // end HTML comment
  if (count==3 && size > 3 && data[3]=='>')
  { return 0; } // end HTML comment
  if (count==2 && (offset<8 || !literal_at(data.data()-8,"operator"))) // -- => ndash
  {
    out+="&ndash;";
    AUTO_TRACE_EXIT("result=2");
    return 2;
  }
  else if (count==3) // --- => ndash
  {
    out+="&mdash;";
    AUTO_TRACE_EXIT("result=3");
    return 3;
  }
  // not an ndash or mdash
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, literal_at(), out, and Trace::trunc().

processQuotations()

QCString Markdown::Private::processQuotations	(	std::string_view	data,
		size_t	refIndent )

Definition at line 3126 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' refIndex='{}'",Trace::trunc(data),refIndent);
  out.clear();
  size_t i=0,end=0;
  size_t pi=std::string::npos;
  bool newBlock = false;
  bool insideList = false;
  size_t currentIndent = refIndent;
  size_t listIndent = refIndent;
  const size_t size = data.size();
  QCString lang;
  while (i<size)
  {
    end = findEndOfLine(data,i);
    // line is now found at [i..end)
 
    size_t lineIndent=0;
    while (lineIndent<end && data[i+lineIndent]==' ') lineIndent++;
    //printf("** lineIndent=%d line=(%s)\n",lineIndent,qPrint(QCString(data+i).left(end-i)));
 
    if (newBlock)
    {
      //printf("** end of block\n");
      if (insideList && lineIndent<currentIndent) // end of list
      {
        //printf("** end of list\n");
        currentIndent = refIndent;
        insideList = false;
      }
      newBlock = false;
    }
 
    if ((listIndent=isListMarker(data.substr(i,end-i)))) // see if we need to increase the indent level
    {
      if (listIndent<currentIndent+4)
      {
        //printf("** start of list\n");
        insideList = true;
        currentIndent = listIndent;
      }
    }
    else if (isEndOfList(data.substr(i,end-i)))
    {
      //printf("** end of list\n");
      insideList = false;
      currentIndent = listIndent;
    }
    else if (isEmptyLine(data.substr(i,end-i)))
    {
      //printf("** new block\n");
      newBlock = true;
    }
    //printf("currentIndent=%d listIndent=%d refIndent=%d\n",currentIndent,listIndent,refIndent);
 
    if (pi!=std::string::npos)
    {
      size_t blockStart=0, blockEnd=0, blockOffset=0;
      if (isFencedCodeBlock(data.substr(pi),currentIndent,lang,blockStart,blockEnd,blockOffset))
      {
        auto addSpecialCommand = [&](const QCString &startCmd,const QCString &endCmd)
        {
          size_t cmdPos  = pi+blockStart+1;
          QCString pl = data.substr(cmdPos,blockEnd-blockStart-1);
          size_t ii = 0;
          int nl = 1;
          // check for absence of start command, either @start<cmd>, or \\start<cmd>
          while (ii<pl.length() && qisspace(pl[ii]))
          {
            if (pl[ii]=='\n') nl++;
            ii++; // skip leading whitespace
          }
          bool addNewLines = false;
          if (ii+startCmd.length()>=pl.length() || // no room for start command
              (pl[ii]!='\\' && pl[ii]!='@')     || // no @ or \ after whitespace
              qstrncmp(pl.data()+ii+1,startCmd.data(),startCmd.length())!=0) // no start command
          {
            // input:                            output:
            // ----------------------------------------------------
            // ```{plantuml}            =>       @startuml
            // A->B                              A->B
            // ```                               @enduml
            // ----------------------------------------------------
            pl = "@"+startCmd+"\n" + pl + "@"+endCmd;
            addNewLines = false;
          }
          else // we have a @start... command inside the code block
          {
            // input:                            output:
            // ----------------------------------------------------
            // ```{plantuml}                     \n
            //                                   \n
            // @startuml                =>       @startuml
            // A->B                              A->B
            // @enduml                           @enduml
            // ```                               \n
            // ----------------------------------------------------
            addNewLines = true;
          }
          if (addNewLines) for (int j=0;j<nl;j++) out+='\n';
          processSpecialCommand(pl.view().substr(ii),ii);
          if (addNewLines) out+='\n';
        };
 
        if (!Config_getString(PLANTUML_JAR_PATH).isEmpty() && lang=="plantuml")
        {
          addSpecialCommand("startuml","enduml");
        }
        else if (Config_getBool(HAVE_DOT) && lang=="dot")
        {
          addSpecialCommand("dot","enddot");
        }
        else if (lang=="msc") // msc is built-in
        {
          addSpecialCommand("msc","endmsc");
        }
        else // normal code block
        {
          writeFencedCodeBlock(data.substr(pi),lang.view(),blockStart,blockEnd);
        }
        i=pi+blockOffset;
        pi=std::string::npos;
        end=i+1;
        continue;
      }
      else if (isBlockQuote(data.substr(pi,i-pi),currentIndent))
      {
        i = pi+writeBlockQuote(data.substr(pi));
        pi=std::string::npos;
        end=i+1;
        continue;
      }
      else
      {
        //printf("quote out={%s}\n",QCString(data+pi).left(i-pi).data());
        out+=data.substr(pi,i-pi);
      }
    }
    pi=i;
    i=end;
  }
  if (pi!=std::string::npos && pi<size) // deal with the last line
  {
    if (isBlockQuote(data.substr(pi),currentIndent))
    {
      writeBlockQuote(data.substr(pi));
    }
    else
    {
      out+=data.substr(pi);
    }
  }
 
  //printf("Process quotations\n---- input ----\n%s\n---- output ----\n%s\n------------\n",
  //    qPrint(s),prv->out.get());
 
  return out;
}

References AUTO_TRACE, Config_getBool, Config_getString, QCString::data(), end(), findEndOfLine(), isBlockQuote(), isEmptyLine(), isEndOfList(), isFencedCodeBlock(), isListMarker(), QCString::length(), out, processSpecialCommand(), qisspace(), qstrncmp(), Trace::trunc(), QCString::view(), writeBlockQuote(), and writeFencedCodeBlock().

processQuoted()

int Markdown::Private::processQuoted	(	std::string_view	data,
		size_t	offset )

Process quoted section "...", can contain one embedded newline.

Definition at line 985 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  const size_t size = data.size();
  size_t i=1;
  int nl=0;
  while (i<size && data[i]!='"' && nl<2)
  {
    if (data[i]=='\n') nl++;
    i++;
  }
  if (i<size && data[i]=='"' && nl<2)
  {
    out+=data.substr(0,i+1);
    AUTO_TRACE_EXIT("result={}",i+2);
    return static_cast<int>(i+1);
  }
  // not a quoted section
  return 0;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, out, and Trace::trunc().

processSpecialCommand()

int Markdown::Private::processSpecialCommand	(	std::string_view	data,
		size_t	offset )

Definition at line 1755 of file markdown.cpp.

{
  AUTO_TRACE("{}",Trace::trunc(data));
  const size_t size = data.size();
  size_t i=1;
  QCString endBlockName = isBlockCommand(data,offset);
  if (!endBlockName.isEmpty())
  {
    AUTO_TRACE_ADD("endBlockName={}",endBlockName);
    size_t l = endBlockName.length();
    while (i+l<size)
    {
      if ((data[i]=='\\' || data[i]=='@') && // command
          data[i-1]!='\\' && data[i-1]!='@') // not escaped
      {
        if (qstrncmp(&data[i+1],endBlockName.data(),l)==0)
        {
          //printf("found end at %d\n",i);
          addStrEscapeUtf8Nbsp(data.substr(0,i+1+l));
          AUTO_TRACE_EXIT("result={}",i+1+l);
          return static_cast<int>(i+1+l);
        }
      }
      i++;
    }
  }
  size_t endPos = isSpecialCommand(data,offset);
  if (endPos>0)
  {
    out+=data.substr(0,endPos);
    return static_cast<int>(endPos);
  }
  if (size>1 && data[0]=='\\') // escaped characters
  {
    char c=data[1];
    if (c=='[' || c==']' || c=='*' || c=='(' || c==')' || c=='`' || c=='_')
    {
      out+=data[1];
      AUTO_TRACE_EXIT("2");
      return 2;
    }
    else if (c=='\\' || c=='@')
    {
      out+=data.substr(0,2);
      AUTO_TRACE_EXIT("2");
      return 2;
    }
    else if (c=='-' && size>3 && data[2]=='-' && data[3]=='-') // \---
    {
      out+=data.substr(1,3);
      AUTO_TRACE_EXIT("2");
      return 4;
    }
    else if (c=='-' && size>2 && data[2]=='-') // \--
    {
      out+=data.substr(1,2);
      AUTO_TRACE_EXIT("3");
      return 3;
    }
  }
  else if (size>1 && data[0]=='@') // escaped characters
  {
    char c=data[1];
    if (c=='\\' || c=='@')
    {
      out+=data.substr(0,2);
      AUTO_TRACE_EXIT("2");
      return 2;
    }
  }
  return 0;
}

References addStrEscapeUtf8Nbsp(), AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, QCString::data(), isBlockCommand(), QCString::isEmpty(), isSpecialCommand(), QCString::length(), out, qstrncmp(), and Trace::trunc().

Referenced by processQuotations().

writeBlockQuote()

size_t Markdown::Private::writeBlockQuote

(

std::string_view

data

)

Definition at line 2811 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  int curLevel=0;
  size_t end=0;
  const size_t size = data.size();
  std::string startCmd;
  int isGitHubAlert = false;
  int isGitHubFirst = false;
  while (i<size)
  {
    // find end of this line
    end=i+1;
    while (end<=size && data[end-1]!='\n') end++;
    size_t j=i;
    int level=0;
    size_t indent=i;
    // compute the quoting level
    while (j<end && (data[j]==' ' || data[j]=='>'))
    {
      if (data[j]=='>') { level++; indent=j+1; }
      else if (j>0 && data[j-1]=='>') indent=j+1;
      j++;
    }
    if (indent>0 && j>0 && data[j-1]=='>' &&
        !(j==size || data[j]=='\n')) // disqualify last > if not followed by space
    {
      indent--;
      level--;
      j--;
    }
    AUTO_TRACE_ADD("indent={} i={} j={} end={} level={} line={}",indent,i,j,end,level,Trace::trunc(&data[i]));
    if (level==0 && j<end-1 && !isListMarker(data.substr(j)) && !isHRuler(data.substr(j)))
    {
      level = curLevel; // lazy
    }
    if (level==1)
    {
      QCString txt = stripWhiteSpace(data.substr(indent,end-indent));
      auto it = g_quotationHeaderMap.find(txt.lower().str()); // TODO: in C++20 the std::string can be dropped
      if (it != g_quotationHeaderMap.end())
      {
        isGitHubAlert = true;
        isGitHubFirst = true;
        startCmd = it->second;
      }
    }
    if (level>curLevel) // quote level increased => add start markers
    {
      if (level!=1 || !isGitHubAlert) // normal block quote
      {
        for (int l=curLevel;l<level-1;l++)
        {
          out+="<blockquote>";
        }
        out += "<blockquote>&zwj;"; // empty blockquotes are also shown
      }
      else if (!startCmd.empty()) // GitHub style alert
      {
        out += startCmd + " ";
      }
    }
    else if (level<curLevel) // quote level decreased => add end markers
    {
      int decrLevel = curLevel;
      if (level==0 && isGitHubAlert)
      {
        decrLevel--;
      }
      for (int l=level;l<decrLevel;l++)
      {
        out += "</blockquote>\\ilinebr ";
      }
    }
    if (level==0)
    {
      curLevel=0;
      break; // end of quote block
    }
    // copy line without quotation marks
    if (curLevel!=0 || !isGitHubAlert)
    {
      std::string_view txt = data.substr(indent,end-indent);
      if (stripWhiteSpace(txt).empty() && !startCmd.empty())
      {
        if (!isGitHubFirst) out += "<br>";
        out += "<br>\n";
      }
      else
      {
        out += txt;
      }
      isGitHubFirst = false;
    }
    else // GitHub alert section
    {
      out+= "\n";
    }
    curLevel=level;
    // proceed with next line
    i=end;
  }
  // end of comment within blockquote => add end markers
  if (isGitHubAlert) // GitHub alert doesn't have a blockquote
  {
    curLevel--;
  }
  for (int l=0;l<curLevel;l++)
  {
    out+="</blockquote>";
  }
  AUTO_TRACE_EXIT("i={}",i);
  return i;
}

References AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, decrLevel(), end(), g_quotationHeaderMap, isHRuler(), isListMarker(), QCString::lower(), out, QCString::str(), stripWhiteSpace(), and Trace::trunc().

Referenced by processQuotations().

writeCodeBlock()

size_t Markdown::Private::writeCodeBlock	(	std::string_view	data,
		size_t	refIndent )

Definition at line 2963 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' refIndent={}",Trace::trunc(data),refIndent);
  const size_t size = data.size();
  size_t i=0;
  // no need for \ilinebr here as the previous line was empty and was skipped
  out+="@iverbatim\n";
  int emptyLines=0;
  std::string location;
  while (i<size)
  {
    // find end of this line
    size_t end=i+1;
    while (end<=size && data[end-1]!='\n') end++;
    size_t j=i;
    size_t indent=0;
    while (j<end && data[j]==' ') j++,indent++;
    //printf("j=%d end=%d indent=%d refIndent=%d tabSize=%d data={%s}\n",
    //    j,end,indent,refIndent,Config_getInt(TAB_SIZE),qPrint(QCString(data+i).left(end-i-1)));
    if (j==end-1) // empty line
    {
      emptyLines++;
      i=end;
    }
    else if (indent>=refIndent+codeBlockIndent) // enough indent to continue the code block
    {
      while (emptyLines>0) // write skipped empty lines
      {
        // add empty line
        out+="\n";
        emptyLines--;
      }
      // add code line minus the indent
      size_t offset = i+refIndent+codeBlockIndent;
      std::string lineLoc;
      if (skipOverFileAndLineCommands(data,codeBlockIndent,offset,lineLoc))
      {
        location = lineLoc;
      }
      out+=data.substr(offset,end-offset);
      i=end;
    }
    else // end of code block
    {
      break;
    }
  }
  out+="@endiverbatim";
  if (!location.empty())
  {
    out+=location;
  }
  else
  {
    out+="\\ilinebr ";
  }
  while (emptyLines>0) // write skipped empty lines
  {
    // add empty line
    out+="\n";
    emptyLines--;
  }
  AUTO_TRACE_EXIT("i={}",i);
  return i;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, codeBlockIndent, end(), out, skipOverFileAndLineCommands(), and Trace::trunc().

Referenced by processBlocks().

writeFencedCodeBlock()

void Markdown::Private::writeFencedCodeBlock	(	std::string_view	data,
		std::string_view	lang,
		size_t	blockStart,
		size_t	blockEnd )

Definition at line 3103 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' lang={} blockStart={} blockEnd={}",Trace::trunc(data),lang,blockStart,blockEnd);
  if (!lang.empty() && lang[0]=='.') lang=lang.substr(1);
  const size_t size=data.size();
  size_t i=0;
  while (i<size && (data[i]==' ' || data[i]=='\t'))
  {
    out+=data[i++];
    blockStart--;
    blockEnd--;
  }
  out+="@icode";
  if (!lang.empty())
  {
    out+="{"+lang+"}";
  }
  out+=" ";
  addStrEscapeUtf8Nbsp(data.substr(blockStart+i,blockEnd-blockStart));
  out+="@endicode ";
}

References addStrEscapeUtf8Nbsp(), AUTO_TRACE, out, and Trace::trunc().

Referenced by processBlocks(), and processQuotations().

writeMarkdownImage()

void Markdown::Private::writeMarkdownImage	(	std::string_view	fmt,
		bool	inline_img,
		bool	explicitTitle,
		const QCString &	title,
		const QCString &	content,
		const QCString &	link,
		const QCString &	attributes,
		const FileDef *	fd )

Definition at line 1154 of file markdown.cpp.

{
  AUTO_TRACE("fmt={} inline_img={} explicitTitle={} title={} content={} link={} attrs={}",
              fmt,inline_img,explicitTitle,Trace::trunc(title),Trace::trunc(content),link,attrs);
  QCString attributes = getFilteredImageAttributes(fmt, attrs);
  out+="@image";
  if (inline_img)
  {
    out+="{inline}";
  }
  out+=" ";
  out+=fmt;
  out+=" ";
  out+=link.mid(fd ? 0 : 5);
  if (!explicitTitle && !content.isEmpty())
  {
    out+=" \"";
    out+=escapeDoubleQuotes(content);
    out+="\"";
  }
  else if ((content.isEmpty() || explicitTitle) && !title.isEmpty())
  {
    out+=" \"";
    out+=escapeDoubleQuotes(title);
    out+="\"";
  }
  else
  {
    out+=" ";// so the line break will not be part of the image name
  }
  if (!attributes.isEmpty())
  {
    out+=" ";
    out+=attributes;
    out+=" ";
  }
  out+="\\ilinebr ";
}

References AUTO_TRACE, escapeDoubleQuotes(), getFilteredImageAttributes(), QCString::isEmpty(), QCString::mid(), out, and Trace::trunc().

Referenced by processLink().

writeOneLineHeaderOrRuler()

void Markdown::Private::writeOneLineHeaderOrRuler

(

std::string_view

data

)

Definition at line 2751 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  int level=0;
  QCString header;
  QCString id;
  if (isHRuler(data))
  {
    out+="<hr>\n";
  }
  else if ((level=isAtxHeader(data,header,id,TRUE)))
  {
    QCString hTag;
    if (!id.isEmpty())
    {
      switch (level)
      {
        case SectionType::Section:         out+="@section ";         break;
        case SectionType::Subsection:      out+="@subsection ";      break;
        case SectionType::Subsubsection:   out+="@subsubsection ";   break;
        case SectionType::Paragraph:       out+="@paragraph ";       break;
        case SectionType::Subparagraph:    out+="@subparagraph ";    break;
        case SectionType::Subsubparagraph: out+="@subsubparagraph "; break;
      }
      out+=id;
      out+=" ";
      out+=header;
      out+="\n";
    }
    else
    {
      hTag.sprintf("h%d",level);
      out+="<"+hTag+">";
      out+=header;
      out+="</"+hTag+">\n";
    }
  }
  else if (data.size()>0) // nothing interesting -> just output the line
  {
    size_t tmpSize = data.size();
    if (data[data.size()-1] == '\n') tmpSize--;
    out+=data.substr(0,tmpSize);
 
    if (hasLineBreak(data))
    {
      out+="\\ilinebr<br>";
    }
    if (tmpSize != data.size()) out+='\n';
  }
}

References AUTO_TRACE, hasLineBreak(), isAtxHeader(), isHRuler(), out, SectionType::Paragraph, SectionType::Section, QCString::sprintf(), SectionType::Subparagraph, SectionType::Subsection, SectionType::Subsubparagraph, SectionType::Subsubsection, TRUE, and Trace::trunc().

Referenced by processBlocks().

writeTableBlock()

size_t Markdown::Private::writeTableBlock

(

std::string_view

data

)

Definition at line 2532 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  const size_t size = data.size();
 
  size_t columns=0, start=0, end=0;
  size_t i = findTableColumns(data,start,end,columns);
  size_t headerStart = start;
  size_t headerEnd   = end;
 
  // read cell alignments
  size_t cc = 0;
  size_t ret = findTableColumns(data.substr(i),start,end,cc);
  size_t k=0;
  std::vector<int> columnAlignment(columns);
 
  bool leftMarker=false, rightMarker=false, startFound=false;
  size_t j=start+i;
  while (j<=end+i)
  {
    if (!startFound)
    {
      if (data[j]==':') { leftMarker=TRUE; startFound=TRUE; }
      if (data[j]=='-') startFound=TRUE;
      //printf("  data[%d]=%c startFound=%d\n",j,data[j],startFound);
    }
    if      (data[j]=='-') rightMarker=FALSE;
    else if (data[j]==':') rightMarker=TRUE;
    if (j<=end+i && (data[j]=='|' && (j==0 || data[j-1]!='\\')))
    {
      if (k<columns)
      {
        columnAlignment[k] = markersToAlignment(leftMarker,rightMarker);
        //printf("column[%d] alignment=%d\n",k,columnAlignment[k]);
        leftMarker=FALSE;
        rightMarker=FALSE;
        startFound=FALSE;
      }
      k++;
    }
    j++;
  }
  if (k<columns)
  {
    columnAlignment[k] = markersToAlignment(leftMarker,rightMarker);
    //printf("column[%d] alignment=%d\n",k,columnAlignment[k]);
  }
  // proceed to next line
  i+=ret;
 
  // Store the table cell information by row then column.  This
  // allows us to handle row spanning.
  std::vector<std::vector<TableCell> > tableContents;
 
  size_t m = headerStart;
  std::vector<TableCell> headerContents(columns);
  for (k=0;k<columns;k++)
  {
    while (m<=headerEnd && (data[m]!='|' || (m>0 && data[m-1]=='\\')))
    {
      headerContents[k].cellText += data[m++];
    }
    m++;
    // do the column span test before stripping white space
    // || is spanning columns, | | is not
    headerContents[k].colSpan = headerContents[k].cellText.isEmpty();
    headerContents[k].cellText = headerContents[k].cellText.stripWhiteSpace();
  }
  tableContents.push_back(headerContents);
 
  // write table cells
  while (i<size)
  {
    ret = findTableColumns(data.substr(i),start,end,cc);
    if (cc!=columns) break; // end of table
 
    j=start+i;
    k=0;
    std::vector<TableCell> rowContents(columns);
    while (j<=end+i)
    {
      if (j<=end+i && (data[j]=='|' && (j==0 || data[j-1]!='\\')))
      {
        // do the column span test before stripping white space
        // || is spanning columns, | | is not
        rowContents[k].colSpan = rowContents[k].cellText.isEmpty();
        rowContents[k].cellText = rowContents[k].cellText.stripWhiteSpace();
        k++;
      } // if (j<=end+i && (data[j]=='|' && (j==0 || data[j-1]!='\\')))
      else
      {
        rowContents[k].cellText += data[j];
      } // else { if (j<=end+i && (data[j]=='|' && (j==0 || data[j-1]!='\\'))) }
      j++;
    } // while (j<=end+i)
    // do the column span test before stripping white space
    // || is spanning columns, | | is not
    rowContents[k].colSpan  = rowContents[k].cellText.isEmpty();
    rowContents[k].cellText = rowContents[k].cellText.stripWhiteSpace();
    tableContents.push_back(rowContents);
 
    // proceed to next line
    i+=ret;
  }
 
  out+="<table class=\"markdownTable\">";
  QCString cellTag("th"), cellClass("class=\"markdownTableHead");
  for (size_t row = 0; row < tableContents.size(); row++)
  {
    if (row)
    {
      if (row % 2)
      {
        out+="\n<tr class=\"markdownTableRowOdd\">";
      }
      else
      {
        out+="\n<tr class=\"markdownTableRowEven\">";
      }
    }
    else
    {
      out+="\n  <tr class=\"markdownTableHead\">";
    }
    for (size_t c = 0; c < columns; c++)
    {
      // save the cell text for use after column span computation
      QCString cellText(tableContents[row][c].cellText);
 
      // Row span handling.  Spanning rows will contain a caret ('^').
      // If the current cell contains just a caret, this is part of an
      // earlier row's span and the cell should not be added to the
      // output.
      if (tableContents[row][c].cellText == "^")
      {
        continue;
      }
      if (tableContents[row][c].colSpan)
      {
        int cr = static_cast<int>(c);
        while ( cr >= 0 && tableContents[row][cr].colSpan)
        {
          cr--;
        };
        if (cr >= 0 && tableContents[row][cr].cellText == "^") continue;
      }
      size_t rowSpan = 1, spanRow = row+1;
      while ((spanRow < tableContents.size()) &&
             (tableContents[spanRow][c].cellText == "^"))
      {
        spanRow++;
        rowSpan++;
      }
 
      out+="    <" + cellTag + " " + cellClass;
      // use appropriate alignment style
      switch (columnAlignment[c])
      {
        case AlignLeft:   out+="Left\""; break;
        case AlignRight:  out+="Right\""; break;
        case AlignCenter: out+="Center\""; break;
        case AlignNone:   out+="None\""; break;
      }
 
      if (rowSpan > 1)
      {
        QCString spanStr;
        spanStr.setNum(rowSpan);
        out+=" rowspan=\"" + spanStr + "\"";
      }
      // Column span handling, assumes that column spans will have
      // empty strings, which would indicate the sequence "||", used
      // to signify spanning columns.
      size_t colSpan = 1;
      while ((c+1 < columns) && tableContents[row][c+1].colSpan)
      {
        c++;
        colSpan++;
      }
      if (colSpan > 1)
      {
        QCString spanStr;
        spanStr.setNum(colSpan);
        out+=" colspan=\"" + spanStr + "\"";
      }
      // need at least one space on either side of the cell text in
      // order for doxygen to do other formatting
      out+="> " + cellText + " \\ilinebr </" + cellTag + ">";
    }
    cellTag = "td";
    cellClass = "class=\"markdownTableBody";
    out+="  </tr>";
  }
  out+="</table>\n";
 
  AUTO_TRACE_EXIT("i={}",i);
  return i;
}

References AlignCenter, AlignLeft, AlignNone, AlignRight, AUTO_TRACE, AUTO_TRACE_EXIT, end(), FALSE, findTableColumns(), markersToAlignment(), out, QCString::setNum(), TRUE, and Trace::trunc().

Referenced by processBlocks().

Member Data Documentation

actions

std::array<Action_t,256> Markdown::Private::actions

Definition at line 179 of file markdown.cpp.

Referenced by processInline().

fileName

QCString Markdown::Private::fileName

Definition at line 175 of file markdown.cpp.

Referenced by extractTitleId(), and processLink().

indentLevel

int Markdown::Private::indentLevel =0

Definition at line 177 of file markdown.cpp.

Referenced by isAtxHeader(), and isHeaderline().

lineNr

int Markdown::Private::lineNr = 0

Definition at line 176 of file markdown.cpp.

Referenced by extractTitleId().

linkRefs

std::unordered_map<std::string,LinkRef> Markdown::Private::linkRefs

Definition at line 174 of file markdown.cpp.

Referenced by processBlocks(), and processLink().

out

QCString Markdown::Private::out

Definition at line 178 of file markdown.cpp.

Referenced by addStrEscapeUtf8Nbsp(), processBlocks(), processCodeSpan(), processEmphasis1(), processEmphasis2(), processEmphasis3(), processHtmlTagWrite(), processInline(), processLink(), processNmdash(), processQuotations(), processQuoted(), processSpecialCommand(), writeBlockQuote(), writeCodeBlock(), writeFencedCodeBlock(), writeMarkdownImage(), writeOneLineHeaderOrRuler(), and writeTableBlock().

---

The documentation for this struct was generated from the following file:

• src/markdown.cpp