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 "config.h"
#include "message.h"
#include "portable.h"
#include "regex.h"
#include "fileinfo.h"
#include "trace.h"
#include "anchor.h"
#include "stringutil.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	isIdChar(c)
#define	extraChar(c)
#define	isOpenEmphChar(c)
#define	ignoreCloseEmphChar(c, cn)
#define	isLiTag(i)
#define	OPC(x)

Enumerations
enum class	ExplicitPageResult { explicitPage , explicitMainPage , explicitOtherPage , notExplicit }
enum	Alignment { AlignNone , AlignLeft , AlignCenter , AlignRight }

Functions
size_t	isNewline (std::string_view data)
static QCString	escapeDoubleQuotes (const QCString &s)
static QCString	escapeSpecialChars (const QCString &s)
static Alignment	markersToAlignment (bool leftMarker, bool rightMarker)
	helper function to convert presence of left and/or right alignment markers to an alignment value
static QCString	getFilteredImageAttributes (std::string_view fmt, const QCString &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, QCString &refid, QCString &link, QCString &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, QCString &lang, size_t &start, size_t &end, size_t &offset)
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 QCString &docs)
QCString	markdownFileNameToId (const QCString &fileName)
	processes string s and converts markdown into doxygen/html commands.

Variables
const char *	g_utf8_nbsp = "\xc2\xa0"
const char *	g_doxy_nbsp = "&_doxy_nbsp;"
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 61 of file markdown.cpp.

Referenced by escapeDoubleQuotes(), escapeSpecialChars(), and getFilteredImageAttributes().

AUTO_TRACE_ADD

#define AUTO_TRACE_ADD

(

...

)

Value:

(void)0

Definition at line 62 of file markdown.cpp.

AUTO_TRACE_EXIT

#define AUTO_TRACE_EXIT

(

...

)

Value:

(void)0

Definition at line 63 of file markdown.cpp.

Referenced by escapeDoubleQuotes(), escapeSpecialChars(), and getFilteredImageAttributes().

extraChar

#define extraChar

(

c

)

Value:

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

Definition at line 84 of file markdown.cpp.

#define extraChar(c) \
  (c=='-' || c=='+' || c=='!' || \
   c=='?' || c=='$' || c=='@' || \
   c=='&' || c=='*' || c=='_' || c=='%' || \
   c=='[' || c=='(' || c=='.' || \
   c=='>' || c==':' || c==',' || \
   c==';' || c=='\'' || c=='"' || c=='`')

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

ignoreCloseEmphChar

#define ignoreCloseEmphChar	(		c,
			cn )

Value:

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

Definition at line 100 of file markdown.cpp.

#define ignoreCloseEmphChar(c,cn) \
  (c=='('  || c=='{' || c=='[' || (c=='<' && cn!='/') || \
   c=='\\' || \
   c=='@')

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

isIdChar

#define isIdChar

(

c

)

Value:

  ((c>='a' && c<='z') || \
   (c>='A' && c<='Z') || \
   (c>='0' && c<='9') || \
   (static_cast<unsigned char>(c)>=0x80))

Definition at line 77 of file markdown.cpp.

#define isIdChar(c) \
  ((c>='a' && c<='z') || \
   (c>='A' && c<='Z') || \
   (c>='0' && c<='9') || \
   (static_cast<unsigned char>(c)>=0x80)) // unicode characters

Referenced by Markdown::Private::findEmphasisChar(), reg::Ex::Private::matchAt(), Markdown::Private::processCodeSpan(), Markdown::Private::processEmphasis(), and Markdown::Private::processHtmlTagWrite().

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 2158 of file markdown.cpp.

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

Referenced by computeIndentExcludingListMarkers().

isOpenEmphChar

#define isOpenEmphChar

(

c

)

Value:

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

Definition at line 93 of file markdown.cpp.

#define isOpenEmphChar(c) \
  (c=='\n' || c==' ' || c=='\'' || c=='<' || \
   c=='>'  || c=='{' || c=='('  || c=='[' || \
   c==','  || c==':' || c==';')

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

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 Alignment

Enumerator
AlignNone
AlignLeft
AlignCenter
AlignRight

Definition at line 194 of file markdown.cpp.

{ AlignNone, AlignLeft, AlignCenter, AlignRight };

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 66 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 2166 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, data, FALSE, i, isLiTag, size, TRUE, and Trace::trunc().

Referenced by isCodeBlock(), and isListMarker().

escapeDoubleQuotes()

QCString escapeDoubleQuotes ( const QCString & s )

static

Definition at line 220 of file markdown.cpp.

{
  AUTO_TRACE("s={}",Trace::trunc(s));
  if (s.isEmpty()) return s;
  QCString 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, s, and Trace::trunc().

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

escapeSpecialChars()

QCString escapeSpecialChars ( const QCString & s )

static

Definition at line 238 of file markdown.cpp.

{
  AUTO_TRACE("s={}",Trace::trunc(s));
  if (s.isEmpty()) return s;
  bool insideQuote=FALSE;
  QCString result;
  const char *p=s.data();
  char c=0, pc='\0';
  while ((c=*p++))
  {
    switch (c)
    {
      case '"':
        if (pc!='\\')  { 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, FALSE, s, and Trace::trunc().

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

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 2451 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, data, end(), eol, i, isNewline(), size, and Trace::trunc().

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

getFilteredImageAttributes()

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

static

parse the image attributes and return attributes for given format

Definition at line 313 of file markdown.cpp.

{
  AUTO_TRACE("fmt={} attrs={}",fmt,attrs);
  StringVector attrList = split(attrs.str(),",");
  for (const auto &attr_ : attrList)
  {
    QCString attr = QCString(attr_).stripWhiteSpace();
    int i = attr.find(':');
    if (i>0) // has format
    {
      QCString 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 QCString();
}

References AUTO_TRACE, AUTO_TRACE_EXIT, QCString::find(), i, QCString::left(), QCString::lower(), QCString::mid(), split(), QCString::str(), and QCString::stripWhiteSpace().

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

hasLineBreak()

bool hasLineBreak ( std::string_view data )

static

Definition at line 2732 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, data, i, and Trace::trunc().

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

isBlockQuote()

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

static

returns true if this line starts a block quote

Definition at line 1895 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, data, i, size, and Trace::trunc().

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

isCodeBlock()

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

static

Definition at line 2358 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(QCString(data+nl_pos[1]).left(nl_pos[0]-nl_pos[1]-1)),
    //    qPrint(QCString(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(), data, FALSE, i, isEmptyLine(), isNewline(), size, and Trace::trunc().

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

isEmptyLine()

bool isEmptyLine ( std::string_view data )

static

Definition at line 2144 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, data, i, and Trace::trunc().

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

isEndOfList()

bool isEndOfList ( std::string_view data )

static

Definition at line 2246 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, data, i, and Trace::trunc().

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

isExplicitPage()

ExplicitPageResult isExplicitPage ( const QCString & docs )

static

Definition at line 3503 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, data, explicitMainPage, explicitOtherPage, explicitPage, i, isOtherPage(), literal_at(), notExplicit, size, QCString::str(), and Trace::trunc().

Referenced by MarkdownOutlineParser::parseInput().

isFencedCodeBlock()

bool isFencedCodeBlock ( std::string_view data, size_t refIndent, QCString & lang, size_t & start, size_t & end, size_t & offset )

static

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

Definition at line 2273 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
  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++;
  }
  AUTO_TRACE_EXIT("result=false: no end marker found lang={}'",lang);
  return false;
}

References AUTO_TRACE, AUTO_TRACE_EXIT, data, end(), FALSE, i, size, and Trace::trunc().

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

isHRuler()

bool isHRuler ( std::string_view data )

static

Definition at line 2013 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, data, i, size, and Trace::trunc().

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

isLinkRef()

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

static

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

Definition at line 1924 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.isEmpty()) { 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, QCString::clear(), data, end(), eol, i, QCString::isEmpty(), size, and Trace::trunc().

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

isListMarker()

size_t isListMarker ( std::string_view data )

static

Definition at line 2235 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(), data, and Trace::trunc().

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

isNewline()

size_t isNewline ( std::string_view data )

inline

Definition at line 207 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 data, and literal_at().

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

isOtherPage()

bool isOtherPage ( std::string_view data )

static

Definition at line 3490 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 data, and OPC.

Referenced by isExplicitPage().

isTableBlock()

bool isTableBlock ( std::string_view data )

static

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

Definition at line 2492 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, data, end(), FALSE, findTableColumns(), i, and Trace::trunc().

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

markdownFileNameToId()

QCString markdownFileNameToId

(

const QCString &

fileName

)

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

Definition at line 3653 of file markdown.cpp.

{
  AUTO_TRACE("fileName={}",fileName);
  std::string absFileName = FileInfo(fileName.str()).absFilePath();
  QCString baseFn  = stripFromPath(absFileName.c_str());
  int i = baseFn.findRev('.');
  if (i!=-1) baseFn = baseFn.left(i);
  QCString baseName = escapeCharsInString(baseFn,false,false);
  //printf("markdownFileNameToId(%s)=md_%s\n",qPrint(fileName),qPrint(baseName));
  QCString res = "md_"+baseName;
  AUTO_TRACE_EXIT("result={}",res);
  return res;
}

References FileInfo::absFilePath(), AUTO_TRACE, AUTO_TRACE_EXIT, escapeCharsInString(), QCString::findRev(), i, QCString::left(), QCString::str(), and stripFromPath().

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

markersToAlignment()

Alignment markersToAlignment ( bool leftMarker, bool rightMarker )

static

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

Definition at line 292 of file markdown.cpp.

{
  if (leftMarker && rightMarker)
  {
    return AlignCenter;
  }
  else if (leftMarker)
  {
    return AlignLeft;
  }
  else if (rightMarker)
  {
    return AlignRight;
  }
  else
  {
    return AlignNone;
  }
}

References AlignCenter, AlignLeft, AlignNone, and AlignRight.

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

skipOverFileAndLineCommands()

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

Definition at line 2929 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 data, i, literal_at(), and size.

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

Variable Documentation

codeBlockIndent

const size_t codeBlockIndent = 4

Definition at line 201 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;"

Definition at line 200 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 2802 of file markdown.cpp.

                                                                          {
  // GitHub style   Doxygen command
  { "[!note]",      "\\note"      },
  { "[!warning]",   "\\warning"   },
  { "[!tip]",       "\\remark"    },
  { "[!caution]",   "\\attention" },
  { "[!important]", "\\important" }
};

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

g_utf8_nbsp

const char* g_utf8_nbsp = "\xc2\xa0"

Definition at line 199 of file markdown.cpp.

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