markdown.cpp File Reference

#include <stdio.h>
#include <unordered_map>
#include <functional>
#include <atomic>
#include <array>
#include <string_view>
#include "markdown.h"
#include "debug.h"
#include "util.h"
#include "doxygen.h"
#include "commentscan.h"
#include "entry.h"
#include "commentcnv.h"
#include "cmdmapper.h"
#include "config.h"
#include "message.h"
#include "portable.h"
#include "regex.h"
#include "filedef.h"
#include "fileinfo.h"
#include "trace.h"
#include "anchor.h"
#include "stringutil.h"
#include "filename.h"
#include "section.h"
#include "plantuml.h"

Include dependency graph for markdown.cpp:

Go to the source code of this file.

Classes
struct	TableCell
struct	Markdown::Private
struct	Markdown::Private::LinkRef
struct	MarkdownOutlineParser::Private

Macros
#define	AUTO_TRACE(...)
#define	AUTO_TRACE_ADD(...)
#define	AUTO_TRACE_EXIT(...)
#define	isLiTag(i)
#define	OPC(x)

Enumerations
enum class	ExplicitPageResult { explicitPage , explicitMainPage , explicitOtherPage , notExplicit }
enum class	Alignment { None , Left , Center , Right }

Functions
static constexpr bool	isIdChar (char c)
static constexpr bool	extraChar (char c)
static constexpr bool	isOpenEmphChar (char c)
static constexpr bool	isUtf8Nbsp (char c1, char c2)
static constexpr bool	isAllowedEmphStr (const std::string_view &data, size_t offset)
static constexpr bool	ignoreCloseEmphChar (char c, char cn)
size_t	isNewline (std::string_view data)
static DString	escapeDoubleQuotes (const DString &s)
static DString	escapeSpecialChars (const DString &s)
static constexpr Alignment	markersToAlignment (bool leftMarker, bool rightMarker)
	helper function to convert presence of left and/or right alignment markers to an alignment value
static DString	getFilteredImageAttributes (std::string_view fmt, const DString &attrs)
	parse the image attributes and return attributes for given format
static bool	isBlockQuote (std::string_view data, size_t indent)
	returns true if this line starts a block quote
static size_t	isLinkRef (std::string_view data, DString &refid, DString &link, DString &title)
	returns end of the link ref if this is indeed a link reference.
static bool	isHRuler (std::string_view data)
static bool	isEmptyLine (std::string_view data)
static size_t	computeIndentExcludingListMarkers (std::string_view data)
static size_t	isListMarker (std::string_view data)
static bool	isEndOfList (std::string_view data)
static bool	isFencedCodeBlock (std::string_view data, size_t refIndent, DString &lang, size_t &start, size_t &end, size_t &offset, DString &fileName, int lineNr)
static bool	isCodeBlock (std::string_view data, size_t offset, size_t &indent)
static size_t	findTableColumns (std::string_view data, size_t &start, size_t &end, size_t &columns)
	Finds the location of the table's contains in the string data.
static bool	isTableBlock (std::string_view data)
	Returns true iff data points to the start of a table block.
static bool	hasLineBreak (std::string_view data)
bool	skipOverFileAndLineCommands (std::string_view data, size_t indent, size_t &offset, std::string &location)
static bool	isOtherPage (std::string_view data)
static ExplicitPageResult	isExplicitPage (const DString &docs)
DString	markdownFileNameToId (const DString &fileName)
	processes string s and converts markdown into doxygen/html commands.

Variables
static const char *	g_utf8_nbsp = "\xc2\xa0"
static const char *	g_doxy_nbsp = "&_doxy_nbsp;"
static const size_t	codeBlockIndent = 4
static const std::unordered_map< std::string, std::string >	g_quotationHeaderMap

Macro Definition Documentation

AUTO_TRACE

#define AUTO_TRACE

(

...

)

Value:

(void)0

Definition at line 67 of file markdown.cpp.

AUTO_TRACE_ADD

#define AUTO_TRACE_ADD

(

...

)

Value:

(void)0

Definition at line 68 of file markdown.cpp.

AUTO_TRACE_EXIT

#define AUTO_TRACE_EXIT

(

...

)

Value:

(void)0

Definition at line 69 of file markdown.cpp.

isLiTag

#define isLiTag

(

i

)

Value:

(data[(i)]=='<' && \
(data[(i)+1]=='l' || data[(i)+1]=='L') && \
(data[(i)+2]=='i' || data[(i)+2]=='I') && \
(data[(i)+3]=='>'))

Definition at line 2250 of file markdown.cpp.

Referenced by computeIndentExcludingListMarkers().

OPC

#define OPC

(

x

)

Value:

if (literal_at(data,#x " ") || literal_at(data,#x "\n")) return true

Referenced by isOtherPage().

Enumeration Type Documentation

Alignment

enum class Alignment

strong

Enumerator
None
Left
Center
Right

Definition at line 218 of file markdown.cpp.

{ None, Left, Center, Right };

ExplicitPageResult

enum class ExplicitPageResult

strong

Enumerator
explicitPage	docs start with a page command
explicitMainPage	docs start with a mainpage command
explicitOtherPage	docs start with a dir / defgroup / addtogroup command
notExplicit	docs doesn't start with either page or mainpage

Definition at line 72 of file markdown.cpp.

{
  explicitPage,      /**< docs start with a page command */
  explicitMainPage,  /**< docs start with a mainpage command */
  explicitOtherPage, /**< docs start with a dir / defgroup / addtogroup command */
  notExplicit        /**< docs doesn't start with either page or mainpage */
};

Function Documentation

computeIndentExcludingListMarkers()

size_t computeIndentExcludingListMarkers ( std::string_view data )

static

Definition at line 2258 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  const size_t size=data.size();
  size_t indent=0;
  bool isDigit=false;
  bool isLi=false;
  bool listMarkerSkipped=false;
  while (i<size &&
         (data[i]==' ' ||                                    // space
          (!listMarkerSkipped &&                             // first list marker
           (data[i]=='+' || data[i]=='-' || data[i]=='*' ||  // unordered list char
            (data[i]=='#' && i>0 && data[i-1]=='-') ||       // -# item
            (isDigit=(data[i]>='1' && data[i]<='9')) ||      // ordered list marker?
            (isLi=(size>=3 && i+3<size && isLiTag(i)))       // <li> tag
           )
          )
         )
        )
  {
    if (isDigit) // skip over ordered list marker '10. '
    {
      size_t j=i+1;
      while (j<size && ((data[j]>='0' && data[j]<='9') || data[j]=='.'))
      {
        if (data[j]=='.') // should be end of the list marker
        {
          if (j+1<size && data[j+1]==' ') // valid list marker
          {
            listMarkerSkipped=true;
            indent+=j+1-i;
            i=j+1;
            break;
          }
          else // not a list marker
          {
            break;
          }
        }
        j++;
      }
    }
    else if (isLi)
    {
      i+=3; // skip over <li>
      indent+=3;
      listMarkerSkipped=true;
    }
    else if (data[i]=='-' && size>=2 && i+2<size && data[i+1]=='#' && data[i+2]==' ')
    { // case "-# "
      listMarkerSkipped=true; // only a single list marker is accepted
      i++; // skip over #
      indent++;
    }
    else if (data[i]!=' ' && i+1<size && data[i+1]==' ')
    { // case "- " or "+ " or "* "
      listMarkerSkipped=true; // only a single list marker is accepted
    }
    if (data[i]!=' ' && !listMarkerSkipped)
    { // end of indent
      break;
    }
    indent++;
    i++;
  }
  AUTO_TRACE_EXIT("result={}",indent);
  return indent;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, computeIndentExcludingListMarkers(), isLiTag, and Trace::trunc().

Referenced by computeIndentExcludingListMarkers(), isCodeBlock(), and isListMarker().

escapeDoubleQuotes()

DString escapeDoubleQuotes ( const DString & s )

static

Definition at line 244 of file markdown.cpp.

{
  AUTO_TRACE("s={}",Trace::trunc(s));
  if (s.empty()) return s;
  DString result;
  const char *p=s.data();
  char c=0, pc='\0';
  while ((c=*p++))
  {
    if (c=='"' && pc!='\\') result+='\\';
    result+=c;
    pc=c;
  }
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, DString::data(), DString::empty(), escapeDoubleQuotes(), and Trace::trunc().

Referenced by escapeDoubleQuotes(), and Markdown::Private::writeMarkdownImage().

escapeSpecialChars()

DString escapeSpecialChars ( const DString & s )

static

Definition at line 262 of file markdown.cpp.

{
  AUTO_TRACE("s={}",Trace::trunc(s));
  if (s.empty()) return s;
  bool insideQuote=false;
  DString result;
  const char *p=s.data();
  char c=0, pc='\0';
  while ((c=*p++))
  {
    switch (c)
    {
      case '"':
        if (pc!='\\')
        {
          if (Config_getBool(MARKDOWN_STRICT))
          {
            result+='\\';
          }
          else // For Doxygen's markup style a quoted text is left untouched
          {
            insideQuote=!insideQuote;
          }
        }
        result+=c;
        break;
      case '<':
        // fall through
      case '>':
        if (!insideQuote)
        {
          result+='\\';
          result+=c;
          if ((p[0]==':') && (p[1]==':'))
          {
            result+='\\';
            result+=':';
            p++;
          }
        }
        else
        {
          result+=c;
        }
        break;
      case '\\': if (!insideQuote) { result+='\\'; } result+='\\'; break;
      case '@':  if (!insideQuote) { result+='\\'; } result+='@'; break;
      // commented out next line due to regression when using % to suppress a link
      //case '%':  if (!insideQuote) { result+='\\'; } result+='%'; break;
      case '#':  if (!insideQuote) { result+='\\'; } result+='#'; break;
      case '$':  if (!insideQuote) { result+='\\'; } result+='$'; break;
      case '&':  if (!insideQuote) { result+='\\'; } result+='&'; break;
      default:
        result+=c; break;
    }
    pc=c;
  }
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, Config_getBool, DString::data(), DString::empty(), escapeSpecialChars(), and Trace::trunc().

Referenced by escapeSpecialChars(), and Markdown::Private::processCodeSpan().

extraChar()

constexpr bool extraChar ( char c )

staticconstexpr

Definition at line 92 of file markdown.cpp.

{
  return c=='-' || c=='+' || c=='!' || c=='?' || c=='$' || c=='@'  ||
         c=='&' || c=='*' || c=='_' || c=='%' || c=='[' || c=='('  ||
         c=='.' || c=='>' || c==':' || c==',' || c==';' || c=='\'' ||
         c=='"' || c=='`' || c=='\\';
}

References extraChar().

Referenced by extraChar(), and Markdown::Private::processEmphasis().

findTableColumns()

size_t findTableColumns ( std::string_view data, size_t & start, size_t & end, size_t & columns )

static

Finds the location of the table's contains in the string data.

Only one line will be inspected.

Parameters

[in]	data	pointer to the string buffer.
[out]	start	offset of the first character of the table content
[out]	end	offset of the last character of the table content
[out]	columns	number of table columns found

Returns

The offset until the next line in the buffer.

Definition at line 2564 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  const size_t size = data.size();
  size_t i=0,n=0;
  // find start character of the table line
  while (i<size && data[i]==' ') i++;
  if (i < size && data[i] == '|' && data[i] != '\n')
  {
    i++;
    n++; // leading | does not count
  }
  start = i;
 
  // find end character of the table line
  size_t j = 0;
  while (i<size && (j = isNewline(data.substr(i)))==0) i++;
  size_t eol=i+j;
 
  if (j>0 && i>0) i--; // move i to point before newline
  while (i>0 && data[i]==' ') i--;
  if (i > 0 && data[i - 1] != '\\' && data[i] == '|')
  {
    i--;
    n++; // trailing or escaped | does not count
  }
  end = i;
 
  // count columns between start and end
  columns=0;
  if (end>start)
  {
    i=start;
    while (i<=end) // look for more column markers
    {
      if (data[i]=='|' && (i==0 || data[i-1]!='\\')) columns++;
      if (columns==1) columns++; // first | make a non-table into a two column table
      i++;
    }
  }
  if (n==2 && columns==0) // table row has | ... |
  {
    columns++;
  }
  AUTO_TRACE_EXIT("eol={} start={} end={} columns={}",eol,start,end,columns);
  return eol;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, end(), eol, findTableColumns(), isNewline(), and Trace::trunc().

Referenced by findTableColumns(), isTableBlock(), and Markdown::Private::writeTableBlock().

getFilteredImageAttributes()

DString getFilteredImageAttributes ( std::string_view fmt, const DString & attrs )

static

parse the image attributes and return attributes for given format

Definition at line 347 of file markdown.cpp.

{
  AUTO_TRACE("fmt={} attrs={}",fmt,attrs);
  StringVector attrList = split(attrs.str(),",");
  for (const auto &attr_ : attrList)
  {
    DString attr = DString(attr_).stripWhiteSpace();
    if (size_t i = attr.find(':'); i!=DString::npos && i>0) // has format
    {
      DString format = attr.left(i).stripWhiteSpace().lower();
      if (format == fmt) // matching format
      {
        AUTO_TRACE_EXIT("result={}",attr.mid(i+1));
        return attr.mid(i+1); // keep part after :
      }
    }
    else // option that applies to all formats
    {
      AUTO_TRACE_EXIT("result={}",attr);
      return attr;
    }
  }
  return DString();
}

References AUTO_TRACE, AUTO_TRACE_EXIT, DString::DString(), DString::find(), getFilteredImageAttributes(), DString::left(), DString::lower(), DString::mid(), DString::npos, split(), DString::str(), and DString::stripWhiteSpace().

Referenced by getFilteredImageAttributes(), and Markdown::Private::writeMarkdownImage().

hasLineBreak()

bool hasLineBreak ( std::string_view data )

static

Definition at line 2853 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  size_t j=0;
  // search for end of line and also check if it is not a completely blank
  while (i<data.size() && data[i]!='\n')
  {
    if (data[i]!=' ' && data[i]!='\t') j++; // some non whitespace
    i++;
  }
  if (i>=data.size()) { return 0; } // empty line
  if (i<2)            { return 0; } // not long enough
  bool res = (j>0 && data[i-1]==' ' && data[i-2]==' '); // non blank line with at two spaces at the end
  AUTO_TRACE_EXIT("result={}",res);
  return res;
}

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

Referenced by hasLineBreak(), and Markdown::Private::writeOneLineHeaderOrRuler().

ignoreCloseEmphChar()

constexpr bool ignoreCloseEmphChar ( char c, char cn )

staticconstexpr

Definition at line 122 of file markdown.cpp.

{
  return c=='('  || c=='{' || c=='[' || (c=='<' && cn!='/') || c=='\\' || c=='@';
}

References ignoreCloseEmphChar().

Referenced by Markdown::Private::findEmphasisChar(), and ignoreCloseEmphChar().

isAllowedEmphStr()

constexpr bool isAllowedEmphStr ( const std::string_view & data, size_t offset )

staticconstexpr

Definition at line 114 of file markdown.cpp.

{
  return ((offset>0 && !isOpenEmphChar(data.data()[-1])) &&
          (offset>1 && !isUtf8Nbsp(data.data()[-2],data.data()[-1])));
}

References isAllowedEmphStr(), isOpenEmphChar(), and isUtf8Nbsp().

Referenced by isAllowedEmphStr(), and Markdown::Private::processEmphasis().

isBlockQuote()

bool isBlockQuote ( std::string_view data, size_t indent )

static

returns true if this line starts a block quote

Definition at line 1979 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' indent={}",Trace::trunc(data),indent);
  size_t i = 0;
  const size_t size = data.size();
  while (i<size && data[i]==' ') i++;
  if (i<indent+codeBlockIndent) // could be a quotation
  {
    // count >'s and skip spaces
    int level=0;
    while (i<size && (data[i]=='>' || data[i]==' '))
    {
      if (data[i]=='>') level++;
      i++;
    }
    // last characters should be a space or newline,
    // so a line starting with >= does not match, but only when level equals 1
    bool res = (level>0 && i<size && ((data[i-1]==' ') || data[i]=='\n')) || (level > 1);
    AUTO_TRACE_EXIT("result={}",res);
    return res;
  }
  else // too much indentation -> code block
  {
    AUTO_TRACE_EXIT("result=false: too much indentation");
    return false;
  }
}

References AUTO_TRACE, AUTO_TRACE_EXIT, codeBlockIndent, isBlockQuote(), and Trace::trunc().

Referenced by isBlockQuote(), and Markdown::Private::processQuotations().

isCodeBlock()

bool isCodeBlock ( std::string_view data, size_t offset, size_t & indent )

static

Definition at line 2467 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' offset={}",Trace::trunc(data),offset);
  //printf("<isCodeBlock(offset=%d,size=%d,indent=%d)\n",offset,size,indent);
  // determine the indent of this line
  size_t i=0;
  size_t indent0=0;
  const size_t size = data.size();
  while (i < size && data[i] == ' ')
  {
    indent0++;
    i++;
  }
 
  if (indent0<codeBlockIndent)
  {
    AUTO_TRACE_EXIT("result={}: line is not indented enough {}<4",false,indent0);
    return false;
  }
  if (indent0>=size || data[indent0]=='\n') // empty line does not start a code block
  {
    AUTO_TRACE_EXIT("result={}: only spaces at the end of a comment block",false);
    return false;
  }
 
  i=offset;
  int nl=0;
  int nl_pos[3];
  int offset_i = static_cast<int>(offset);
  // search back 3 lines and remember the start of lines -1 and -2
  while (i>0 && nl<3) // i counts down from offset to 1
  {
    int j = static_cast<int>(i)-offset_i-1; // j counts from -1 to -offset
    // since j can be negative we need to rewrap data in a std::string_view
    size_t nl_size = isNewline(std::string_view(data.data()+j,data.size()-j));
    if (nl_size>0)
    {
      nl_pos[nl++]=j+static_cast<int>(nl_size);
    }
    i--;
  }
 
  // if there are only 2 preceding lines, then line -2 starts at -offset
  if (i==0 && nl==2) nl_pos[nl++]=-offset_i;
 
  if (nl==3) // we have at least 2 preceding lines
  {
    //printf("  positions: nl_pos=[%d,%d,%d] line[-2]='%s' line[-1]='%s'\n",
    //    nl_pos[0],nl_pos[1],nl_pos[2],
    //    qPrint(DString(data+nl_pos[1]).left(nl_pos[0]-nl_pos[1]-1)),
    //    qPrint(DString(data+nl_pos[2]).left(nl_pos[1]-nl_pos[2]-1)));
 
    // check that line -1 is empty
    // Note that the offset is negative so we need to rewrap the string view
    if (!isEmptyLine(std::string_view(data.data()+nl_pos[1],nl_pos[0]-nl_pos[1]-1)))
    {
      AUTO_TRACE_EXIT("result={}",false);
      return false;
    }
 
    // determine the indent of line -2
    // Note that the offset is negative so we need to rewrap the string view
    indent=std::max(indent,computeIndentExcludingListMarkers(
          std::string_view(data.data()+nl_pos[2],nl_pos[1]-nl_pos[2])));
 
    //printf(">isCodeBlock local_indent %d>=%d+%d=%d\n",
    //    indent0,indent,codeBlockIndent,indent0>=indent+codeBlockIndent);
    // if the difference is >4 spaces -> code block
    bool res = indent0>=indent+codeBlockIndent;
    AUTO_TRACE_EXIT("result={}: code block if indent difference >4 spaces",res);
    return res;
  }
  else // not enough lines to determine the relative indent, use global indent
  {
    // check that line -1 is empty
    // Note that the offset is negative so we need to rewrap the string view
    if (nl==1 && !isEmptyLine(std::string_view(data.data()-offset,offset-1)))
    {
      AUTO_TRACE_EXIT("result=false");
      return false;
    }
    //printf(">isCodeBlock global indent %d>=%d+4=%d nl=%d\n",
    //    indent0,indent,indent0>=indent+4,nl);
    bool res = indent0>=indent+codeBlockIndent;
    AUTO_TRACE_EXIT("result={}: code block if indent difference >4 spaces",res);
    return res;
  }
}

References AUTO_TRACE, AUTO_TRACE_EXIT, codeBlockIndent, computeIndentExcludingListMarkers(), isCodeBlock(), isEmptyLine(), isNewline(), and Trace::trunc().

Referenced by isCodeBlock(), and Markdown::Private::processBlocks().

isEmptyLine()

bool isEmptyLine ( std::string_view data )

static

Definition at line 2236 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  while (i<data.size())
  {
    if (data[i]=='\n') { AUTO_TRACE_EXIT("true");  return true; }
    if (data[i]!=' ')  { AUTO_TRACE_EXIT("false"); return false; }
    i++;
  }
  AUTO_TRACE_EXIT("true");
  return true;
}

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

Referenced by isCodeBlock(), isEmptyLine(), Markdown::Private::processBlocks(), and Markdown::Private::processQuotations().

isEndOfList()

bool isEndOfList ( std::string_view data )

static

Definition at line 2339 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  int dots=0;
  size_t i=0;
  // end of list marker is an otherwise empty line with a dot.
  while (i<data.size())
  {
    if (data[i]=='.')
    {
      dots++;
    }
    else if (data[i]=='\n')
    {
      break;
    }
    else if (data[i]!=' ' && data[i]!='\t') // bail out if the line is not empty
    {
      AUTO_TRACE_EXIT("result=false");
      return false;
    }
    i++;
  }
  AUTO_TRACE_EXIT("result={}",dots==1);
  return dots==1;
}

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

Referenced by isEndOfList(), Markdown::Private::processBlocks(), and Markdown::Private::processQuotations().

isExplicitPage()

ExplicitPageResult isExplicitPage ( const DString & docs )

static

Definition at line 3649 of file markdown.cpp.

{
  AUTO_TRACE("docs={}",Trace::trunc(docs));
  size_t i=0;
  std::string_view data(docs.str());
  const size_t size = data.size();
  if (!data.empty())
  {
    while (i<size && (data[i]==' ' || data[i]=='\n'))
    {
      i++;
    }
    if (literal_at(data.substr(i),"<!--!")) // skip over <!--! marker
    {
      i+=5;
      while (i<size && (data[i]==' ' || data[i]=='\n')) // skip over spaces after the <!--! marker
      {
        i++;
      }
    }
    if (i+1<size &&
        (data[i]=='\\' || data[i]=='@') &&
        (literal_at(data.substr(i+1),"page ") || literal_at(data.substr(i+1),"mainpage"))
       )
    {
      if (literal_at(data.substr(i+1),"page "))
      {
        AUTO_TRACE_EXIT("result=ExplicitPageResult::explicitPage");
        return ExplicitPageResult::explicitPage;
      }
      else
      {
        AUTO_TRACE_EXIT("result=ExplicitPageResult::explicitMainPage");
        return ExplicitPageResult::explicitMainPage;
      }
    }
    else if (i+1<size && (data[i]=='\\' || data[i]=='@') && isOtherPage(data.substr(i+1)))
    {
      AUTO_TRACE_EXIT("result=ExplicitPageResult::explicitOtherPage");
      return ExplicitPageResult::explicitOtherPage;
    }
  }
  AUTO_TRACE_EXIT("result=ExplicitPageResult::notExplicit");
  return ExplicitPageResult::notExplicit;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, explicitMainPage, explicitOtherPage, explicitPage, isExplicitPage(), isOtherPage(), literal_at(), notExplicit, DString::str(), and Trace::trunc().

Referenced by isExplicitPage(), and MarkdownOutlineParser::parseInput().

isFencedCodeBlock()

bool isFencedCodeBlock ( std::string_view data, size_t refIndent, DString & lang, size_t & start, size_t & end, size_t & offset, DString & fileName, int lineNr )

static

extract python or .py from python... or .py...

Definition at line 2366 of file markdown.cpp.

{
  AUTO_TRACE("data='{}' refIndent={}",Trace::trunc(data),refIndent);
  const char dot = '.';
  auto isAlphaChar  = [ ](char c) { return (c>='A' && c<='Z') || (c>='a' && c<='z'); };
  auto isAlphaNChar = [ ](char c) { return (c>='A' && c<='Z') || (c>='a' && c<='z') || (c>='0' && c<='9') || (c=='+'); };
  auto isLangChar   = [&](char c) { return c==dot || isAlphaChar(c); };
  // rules: at least 3 ~~~, end of the block same amount of ~~~'s, otherwise
  // return false
  size_t i=0;
  size_t indent=0;
  int startTildes=0;
  const size_t size = data.size();
  while (i < size && data[i] == ' ')
  {
    indent++;
    i++;
  }
  if (indent>=refIndent+4)
  {
    AUTO_TRACE_EXIT("result=false: content is part of code block indent={} refIndent={}",indent,refIndent);
    return false;
  } // part of code block
  char tildaChar='~';
  if (i<size && data[i]=='`') tildaChar='`';
  while (i < size && data[i] == tildaChar)
  {
    startTildes++;
    i++;
  }
  if (startTildes<3)
  {
    AUTO_TRACE_EXIT("result=false: no fence marker found #tildes={}",startTildes);
    return false;
  } // not enough tildes
  // skip whitespace
  while (i<size && data[i]==' ') { i++; }
  if (i<size && data[i]=='{') // extract .py from ```{.py} ... ```
  {
    i++; // skip over {
    if (data[i] == dot) i++; // skip over initial dot
    size_t startLang=i;
    while (i<size && (data[i]!='\n' && data[i]!='}')) i++; // find matching }
    if (i<size && data[i]=='}')
    {
      lang = data.substr(startLang,i-startLang);
      i++;
    }
    else // missing closing bracket, treat `{` as part of the content
    {
      i=startLang-1;
      lang="";
    }
  }
  else if (i<size && isLangChar(data[i])) /// extract python or .py from ```python...``` or ```.py...```
  {
    if (data[i] == dot) i++; // skip over initial dot
    size_t startLang=i;
    if (i<size && isAlphaChar(data[i])) //check first character of language specifier
    {
      i++;
      while (i<size && isAlphaNChar(data[i])) i++; // find end of language specifier
    }
    lang = data.substr(startLang,i-startLang);
  }
  else // no language specified
  {
    lang="";
  }
 
  start=i;
  while (i<size)
  {
    if (data[i]==tildaChar)
    {
      end=i;
      int endTildes=0;
      while (i < size && data[i] == tildaChar)
      {
        endTildes++;
        i++;
      }
      while (i<size && data[i]==' ') i++;
      {
        if (endTildes==startTildes)
        {
          offset=i;
          AUTO_TRACE_EXIT("result=true: found end marker at offset {} lang='{}'",offset,lang);
          return true;
        }
      }
    }
    i++;
  }
  warn(fileName, lineNr, "Ending Inside a fenced code block. Maybe the end marker for the block is missing?");
  AUTO_TRACE_EXIT("result=false: no end marker found lang={}'",lang);
  return false;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, end(), isFencedCodeBlock(), DString::substr(), Trace::trunc(), and warn.

Referenced by isFencedCodeBlock(), Markdown::Private::processBlocks(), and Markdown::Private::processQuotations().

isHRuler()

bool isHRuler ( std::string_view data )

static

Definition at line 2097 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t i=0;
  size_t size = data.size();
  if (size>0 && data[size-1]=='\n') size--; // ignore newline character
  while (i<size && data[i]==' ') i++;
  if (i>=size) { AUTO_TRACE_EXIT("result=false: empty line"); return false; } // empty line
  char c=data[i];
  if (c!='*' && c!='-' && c!='_')
  {
    AUTO_TRACE_EXIT("result=false: {} is not a hrule character",c);
    return false; // not a hrule character
  }
  int n=0;
  while (i<size)
  {
    if (data[i]==c)
    {
      n++; // count rule character
    }
    else if (data[i]!=' ')
    {
      AUTO_TRACE_EXIT("result=false: line contains non hruler characters");
      return false; // line contains non hruler characters
    }
    i++;
  }
  AUTO_TRACE_EXIT("result={}",n>=3);
  return n>=3; // at least 3 characters needed for a hruler
}

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

Referenced by isHRuler(), Markdown::Private::writeBlockQuote(), and Markdown::Private::writeOneLineHeaderOrRuler().

isIdChar()

constexpr bool isIdChar ( char c )

staticconstexpr

Definition at line 83 of file markdown.cpp.

{
  return (c>='a' && c<='z') ||
         (c>='A' && c<='Z') ||
         (c>='0' && c<='9') ||
         (static_cast<unsigned char>(c)>=0x80); // unicode characters
}

References isIdChar().

Referenced by Markdown::Private::findEmphasisChar(), isIdChar(), Markdown::Private::processCodeSpan(), Markdown::Private::processEmphasis(), and Markdown::Private::processHtmlTagWrite().

isLinkRef()

size_t isLinkRef ( std::string_view data, DString & refid, DString & link, DString & title )

static

returns end of the link ref if this is indeed a link reference.

Definition at line 2008 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  const size_t size = data.size();
  // format: start with [some text]:
  size_t i = 0;
  while (i<size && data[i]==' ') i++;
  if (i>=size || data[i]!='[') { return 0; }
  i++;
  size_t refIdStart=i;
  while (i<size && data[i]!='\n' && data[i]!=']') i++;
  if (i>=size || data[i]!=']') { return 0; }
  refid = data.substr(refIdStart,i-refIdStart);
  if (refid.empty()) { return 0; }
  AUTO_TRACE_ADD("refid found {}",refid);
  //printf("  isLinkRef: found refid='%s'\n",qPrint(refid));
  i++;
  if (i>=size || data[i]!=':') { return 0; }
  i++;
 
  // format: whitespace* \n? whitespace* (<url> | url)
  while (i<size && data[i]==' ') i++;
  if (i<size && data[i]=='\n')
  {
    i++;
    while (i<size && data[i]==' ') i++;
  }
  if (i>=size) { return 0; }
 
  if (i<size && data[i]=='<') i++;
  size_t linkStart=i;
  while (i<size && data[i]!=' ' && data[i]!='\n') i++;
  size_t linkEnd=i;
  if (i<size && data[i]=='>') i++;
  if (linkStart==linkEnd) { return 0; } // empty link
  link = data.substr(linkStart,linkEnd-linkStart);
  AUTO_TRACE_ADD("link found {}",Trace::trunc(link));
  if (link=="@ref" || link=="\\ref")
  {
    size_t argStart=i;
    while (i<size && data[i]!='\n' && data[i]!='"') i++;
    link+=data.substr(argStart,i-argStart);
  }
 
  title.clear();
 
  // format: (whitespace* \n? whitespace* ( 'title' | "title" | (title) ))?
  size_t eol=0;
  while (i<size && data[i]==' ') i++;
  if (i<size && data[i]=='\n')
  {
    eol=i;
    i++;
    while (i<size && data[i]==' ') i++;
  }
  if (i>=size)
  {
    AUTO_TRACE_EXIT("result={}: end of isLinkRef while looking for title",i);
    return i; // end of buffer while looking for the optional title
  }
 
  char c = data[i];
  if (c=='\'' || c=='"' || c=='(') // optional title present?
  {
    //printf("  start of title found! char='%c'\n",c);
    i++;
    if (c=='(') c=')'; // replace c by end character
    size_t titleStart=i;
    // search for end of the line
    while (i<size && data[i]!='\n') i++;
    eol = i;
 
    // search back to matching character
    size_t end=i-1;
    while (end>titleStart && data[end]!=c) end--;
    if (end>titleStart)
    {
      title = data.substr(titleStart,end-titleStart);
    }
    AUTO_TRACE_ADD("title found {}",Trace::trunc(title));
  }
  while (i<size && data[i]==' ') i++;
  //printf("end of isLinkRef: i=%d size=%d data[i]='%c' eol=%d\n",
  //    i,size,data[i],eol);
  if      (i>=size)       { AUTO_TRACE_EXIT("result={}",i);   return i; }    // end of buffer while ref id was found
  else if (eol>0)         { AUTO_TRACE_EXIT("result={}",eol); return eol; }  // end of line while ref id was found
  return 0;                            // invalid link ref
}

References AUTO_TRACE, AUTO_TRACE_ADD, AUTO_TRACE_EXIT, DString::clear(), DString::empty(), end(), eol, isLinkRef(), DString::substr(), and Trace::trunc().

Referenced by isLinkRef(), and Markdown::Private::processBlocks().

isListMarker()

size_t isListMarker ( std::string_view data )

static

Definition at line 2328 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t normalIndent = 0;
  while (normalIndent<data.size() && data[normalIndent]==' ') normalIndent++;
  size_t listIndent = computeIndentExcludingListMarkers(data);
  size_t result = listIndent>normalIndent ? listIndent : 0;
  AUTO_TRACE_EXIT("result={}",result);
  return result;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, computeIndentExcludingListMarkers(), isListMarker(), and Trace::trunc().

Referenced by isListMarker(), Markdown::Private::processBlocks(), Markdown::Private::processQuotations(), and Markdown::Private::writeBlockQuote().

isNewline()

size_t isNewline ( std::string_view data )

inline

Definition at line 231 of file markdown.cpp.

{
  // normal newline
  if (data[0] == '\n') return 1;
  // artificial new line from ^^ in ALIASES
  if (literal_at(data,"\\ilinebr"))
  {
    return (data.size()>8 && data[8]==' ') ? 9 : 8; // also count space after \ilinebr if present
  }
  return 0;
}

References isNewline(), and literal_at().

Referenced by Markdown::Private::findEndOfLine(), findTableColumns(), isCodeBlock(), and isNewline().

isOpenEmphChar()

constexpr bool isOpenEmphChar ( char c )

staticconstexpr

Definition at line 101 of file markdown.cpp.

{
  return c=='\n' || c==' ' || c=='\'' || c=='<' ||
         c=='>'  || c=='{' || c=='('  || c=='[' ||
         c==','  || c==':' || c==';';
}

References isOpenEmphChar().

Referenced by isAllowedEmphStr(), and isOpenEmphChar().

isOtherPage()

bool isOtherPage ( std::string_view data )

static

Definition at line 3636 of file markdown.cpp.

{
#define OPC(x) if (literal_at(data,#x " ") || literal_at(data,#x "\n")) return true
  OPC(dir);       OPC(defgroup);  OPC(addtogroup); OPC(weakgroup); OPC(ingroup);
  OPC(fn);        OPC(property);  OPC(typedef);    OPC(var);       OPC(def);
  OPC(enum);      OPC(namespace); OPC(class);      OPC(concept);   OPC(module);
  OPC(protocol);  OPC(category);  OPC(union);      OPC(struct);    OPC(interface);
  OPC(idlexcept); OPC(file);
#undef OPC
 
  return false;
}

References isOtherPage(), and OPC.

Referenced by isExplicitPage(), and isOtherPage().

isTableBlock()

bool isTableBlock ( std::string_view data )

static

Returns true iff data points to the start of a table block.

Definition at line 2613 of file markdown.cpp.

{
  AUTO_TRACE("data='{}'",Trace::trunc(data));
  size_t cc0=0, start=0, end=0;
 
  // the first line should have at least two columns separated by '|'
  size_t i = findTableColumns(data,start,end,cc0);
  if (i>=data.size() || cc0<1)
  {
    AUTO_TRACE_EXIT("result=false: no |'s in the header");
    return false;
  }
 
  size_t cc1 = 0;
  size_t ret = findTableColumns(data.substr(i),start,end,cc1);
  size_t j=i+start;
  // separator line should consist of |, - and : and spaces only
  while (j<=end+i)
  {
    if (data[j]!=':' && data[j]!='-' && data[j]!='|' && data[j]!=' ')
    {
      AUTO_TRACE_EXIT("result=false: invalid character '{}'",data[j]);
      return false; // invalid characters in table separator
    }
    j++;
  }
  if (cc1!=cc0) // number of columns should be same as previous line
  {
    AUTO_TRACE_EXIT("result=false: different number of columns as previous line {}!={}",cc1,cc0);
    return false;
  }
 
  i+=ret; // goto next line
  size_t cc2 = 0;
  findTableColumns(data.substr(i),start,end,cc2);
 
  AUTO_TRACE_EXIT("result={}",cc1==cc2);
  return cc1==cc2;
}

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

Referenced by isTableBlock(), and Markdown::Private::processBlocks().

isUtf8Nbsp()

constexpr bool isUtf8Nbsp ( char c1, char c2 )

staticconstexpr

Definition at line 109 of file markdown.cpp.

{
  return c1==static_cast<char>(0xc2) && c2==static_cast<char>(0xa0);
}

References isUtf8Nbsp().

Referenced by isAllowedEmphStr(), and isUtf8Nbsp().

markdownFileNameToId()

DString markdownFileNameToId

(

const DString &

fileName

)

processes string s and converts markdown into doxygen/html commands.

Definition at line 3799 of file markdown.cpp.

{
  AUTO_TRACE("fileName={}",fileName);
  DString absFileName = FileInfo(fileName.str()).absFilePath();
  DString baseFn = stripFromPath(absFileName);
  if (size_t i = baseFn.rfind('.'); i!=DString::npos) baseFn = baseFn.left(i);
  DString baseName = escapeCharsInString(baseFn,false,false);
  //printf("markdownFileNameToId(%s)=md_%s\n",qPrint(fileName),qPrint(baseName));
  DString res = "md_"+baseName;
  AUTO_TRACE_EXIT("result={}",res);
  return res;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, escapeCharsInString(), FileInfo::FileInfo(), DString::left(), markdownFileNameToId(), DString::npos, DString::rfind(), DString::str(), and stripFromPath().

Referenced by DocRef::DocRef(), markdownFileNameToId(), DocSecRefItem::parse(), and MarkdownOutlineParser::parseInput().

markersToAlignment()

constexpr Alignment markersToAlignment ( bool leftMarker, bool rightMarker )

staticconstexpr

helper function to convert presence of left and/or right alignment markers to an alignment value

Definition at line 326 of file markdown.cpp.

{
  if (leftMarker && rightMarker)
  {
    return Alignment::Center;
  }
  else if (leftMarker)
  {
    return Alignment::Left;
  }
  else if (rightMarker)
  {
    return Alignment::Right;
  }
  else
  {
    return Alignment::None;
  }
}

References Center, Left, markersToAlignment(), None, and Right.

Referenced by markersToAlignment(), and Markdown::Private::writeTableBlock().

skipOverFileAndLineCommands()

bool skipOverFileAndLineCommands	(	std::string_view	data,
		size_t	indent,
		size_t &	offset,
		std::string &	location )

Definition at line 3050 of file markdown.cpp.

{
  size_t i = offset;
  size_t size = data.size();
  while (i<data.size() && data[i]==' ') i++;
  if (literal_at(data.substr(i),"\\ifile \""))
  {
    size_t locStart = i;
    if (i>offset) locStart--; // include the space before \ifile
    i+=8;
    bool found=false;
    while (i+9<size && data[i]!='\n')
    {
      if (literal_at(data.substr(i),"\\ilinebr "))
      {
        found=true;
        break;
      }
      i++;
    }
    if (found)
    {
      i+=9;
      location=data.substr(locStart,i-locStart);
      location+='\n';
      while (indent > 0 && i < size && data[i] == ' ')
      {
        i++;
        indent--;
      }
      if (i<size && data[i]=='\n') i++;
      offset = i;
      return true;
    }
  }
  return false;
}

References literal_at(), and skipOverFileAndLineCommands().

Referenced by skipOverFileAndLineCommands(), and Markdown::Private::writeCodeBlock().

Variable Documentation

codeBlockIndent

const size_t codeBlockIndent = 4

static

Definition at line 225 of file markdown.cpp.

Referenced by isBlockQuote(), isCodeBlock(), Markdown::Private::processBlocks(), and Markdown::Private::writeCodeBlock().

g_doxy_nbsp

const char* g_doxy_nbsp = "&_doxy_nbsp;"

static

Definition at line 224 of file markdown.cpp.

Referenced by Markdown::Private::addStrEscapeUtf8Nbsp(), and Markdown::process().

g_quotationHeaderMap

const std::unordered_map<std::string,std::string> g_quotationHeaderMap

static

Initial value:

                                                     = {
  
  { "[!note]",      "\\note"      },
  { "[!warning]",   "\\warning"   },
  { "[!tip]",       "\\remark"    },
  { "[!caution]",   "\\attention" },
  { "[!important]", "\\important" }
}

Definition at line 2923 of file markdown.cpp.

Referenced by Markdown::Private::writeBlockQuote().

g_utf8_nbsp

const char* g_utf8_nbsp = "\xc2\xa0"

static

Definition at line 223 of file markdown.cpp.

Referenced by Markdown::Private::addStrEscapeUtf8Nbsp().