Fossil

  assert( ValidBklnk(srctype) );
  assert( ValidMTC(mimetype) );
  bklnk.srctype = srctype;
  bklnk.mtime = mtime;
  if( mimetype==MT_NONE || mimetype==MT_WIKI ){
    int flags;
    if( srctype==BKLNK_COMMENT ){
      flags = WIKI_INLINE | WIKI_MARKDOWN_LINK;
    }else{
      flags = 0;
    }
    wiki_extract_links(zSrc, &bklnk, flags);
  }else if( mimetype==MT_MARKDOWN ){
    markdown_extract_links(zSrc, &bklnk);
  }

  { "icon-image",             CONFIGSET_SKIN },
  { "timeline-block-markup",  CONFIGSET_SKIN },
  { "timeline-date-format",   CONFIGSET_SKIN },
  { "timeline-default-style", CONFIGSET_SKIN },
  { "timeline-dwelltime",     CONFIGSET_SKIN },
  { "timeline-closetime",     CONFIGSET_SKIN },
  { "timeline-hard-newlines", CONFIGSET_SKIN },
  { "timeline-markdown",      CONFIGSET_SKIN },
  { "timeline-max-comment",   CONFIGSET_SKIN },
  { "timeline-plaintext",     CONFIGSET_SKIN },
  { "timeline-truncate-at-blank", CONFIGSET_SKIN },
  { "timeline-tslink-info",   CONFIGSET_SKIN },
  { "timeline-utc",           CONFIGSET_SKIN },
  { "adunit",                 CONFIGSET_SKIN },
  { "adunit-omit-if-admin",   CONFIGSET_SKIN },

  static int wikiFlags = 0;
  if( wikiFlags==0 ){
    if( db_get_boolean("timeline-block-markup", 0) ){
      wikiFlags = WIKI_INLINE | WIKI_NOBADLINKS;
    }else{
      wikiFlags = WIKI_INLINE | WIKI_NOBLOCK | WIKI_NOBADLINKS;
    }
    if( db_get_boolean("timeline-plaintext", 0) ){
      wikiFlags |= WIKI_LINKSONLY;
      wikiFlags &= ~WIKI_MARKDOWN_INLINE;
    }else{
      int x = db_get_boolean("timeline-markdown", 0);
      if( x & 1 ) wikiFlags |= WIKI_MARKDOWN_LINK;
      if( x & 2 ) wikiFlags |= WIKI_MARKDOWN_FONT;
    }
    if( db_get_boolean("timeline-hard-newlines", 0) ){
      wikiFlags |= WIKI_NEWLINE;
    }
  }
  if( altForm2 ){
    /* block markup (ex: <p>, <table>) allowed */

  static const char *const azTimeFormats[] = {
      "0", "HH:MM",
      "1", "HH:MM:SS",
      "2", "YYYY-MM-DD HH:MM",
      "3", "YYMMDD HH:MM",
      "4", "(off)"
  };
  static const char *const azMarkdown[] = {
      "0", "none",
      "1", "hyperlinks only",
      "2", "styling only",
      "3", "links and styling",
  };
  login_check_credentials();
  if( !g.perm.Admin ){
    login_needed(0);
    return;
  }

  style_set_current_feature("setup");

  onoff_attribute("Allow block-markup in timeline",
                  "timeline-block-markup", "tbm", 0, 0);
  @ <p>In timeline displays, check-in comments can be displayed with or
  @ without block markup such as paragraphs, tables, etc.
  @ (Property: "timeline-block-markup")</p>

  @ <hr>
  multiple_choice_attribute("Allow Markdown in timeline comments",
                            "timeline-markdown", "tmkdn", "0",
                            count(azMarkdown)/2, azMarkdown);
  @ <p>Allow or disallow a limited amount of Markdown-style format marks
  @ for check-in comments displayed in the timeline.  Normally check-in
  @ comments use only <a href="%R/wiki_rules">Fossil Wiki</a>.  This option
  @ allows some types of Markdown to be used as well:
  @ <ul><li>hyperlinks: <b>(</b><i>display</i><b>)[</b><i>target</i><b>]</b> \
  @ and <b>&lt;</b><i>URL</i><b>&gt;</b>.
  @ <li>styling: *<i>emphasis</i>*, **<b>bold</b>**, `<tt>literal</tt>`, \
  @ <b>\</b>-escapes</ul>
  @ (Property: "timeline-markdown")</p>

  @ <hr>
  onoff_attribute("Plaintext comments on timelines",
                  "timeline-plaintext", "tpt", 0, 0);
  @ <p>In timeline displays, check-in comments are displayed literally,
  @ without any wiki or HTML interpretation.  This setting takes priority
  @ over the timeline-block-markup and timeline-markdown settings
  @ above.
  @ (Property: "timeline-plaintext")</p>

  @ <hr>
  onoff_attribute("Truncate comment at first blank line (Git-style)",
                  "timeline-truncate-at-blank", "ttb", 0, 0);
  @ <p>In timeline displays, check-in comments are displayed only through

#include <assert.h>
#include "wikiformat.h"

#if INTERFACE
/*
** Allowed wiki transformation operations
*/
#define WIKI_HTMLONLY         0x0001  /* HTML markup only.  No wiki */
#define WIKI_INLINE           0x0002  /* Do not surround with <p>..</p> */
#define WIKI_NOBLOCK          0x0004  /* No block markup of any kind */
#define WIKI_BUTTONS          0x0008  /* Allow sub-menu buttons */
#define WIKI_NOBADLINKS       0x0010  /* Ignore broken hyperlinks */
#define WIKI_LINKSONLY        0x0020  /* No markup.  Only decorate links */
#define WIKI_NEWLINE          0x0040  /* Honor \n - break lines at each \n */

#define WIKI_SAFE             0x0080  /* Make the result safe for embedding */
#define WIKI_TARGET_BLANK     0x0100  /* Hyperlinks go to a new window */
#define WIKI_NOBRACKET        0x0200  /* Omit extra [..] around hyperlinks */
#define WIKI_MARKDOWN_URL     0x0400  /* Process link targets as in markdown */
#define WIKI_MARKDOWN_FONT    0x0800  /* Accept markdown font/style markup */
#define WIKI_MARKDOWN_LINK    0x1000  /* Accept markdown hyperlinks */
#define WIKI_MARKDOWN_INLINE  0x1800  /* Combo of _FONT and _LINK */
#endif


/*
** These are the only markup attributes allowed.
*/
enum allowed_attr_t {

**
** Interesting characters are:
**
**      <
**      &
**      \n
**      [
**      _ * ` \    <-- WIKI_MARKDOWN_FONT only.
**
** The "[" is only considered if flags contain ALLOW_LINKS or ALLOW_WIKI.
** The "\n" is only considered interesting if the flags constains ALLOW_WIKI.
** The markdown span characters, _ * ` and \, are only considered if both
** ALLOW_WIKI and WIKI_MARKDOWN_FONT are set.
*/
static int textLength(const char *z, int flags){
  const char *zReject;
  if( flags & ALLOW_WIKI ){
    if( flags & WIKI_MARKDOWN_FONT ){
      zReject = "_*`\\\n[<&";
    }else{
      zReject = "\n[<&";
    }
  }else if( flags & ALLOW_LINKS ){
    zReject = "[<&";
  }else{

        int savedState;
        char zClose[20];
        char cS1 = 0;
        int iS1 = 0;

        startAutoParagraph(p);
        if( z[n]=='('
         && (p->state & WIKI_MARKDOWN_LINK)!=0
         && (zEnd = strchr(z+n+1,')'))!=0
        ){
          /* Markdown-style hyperlinks: [display-text](URL) or [](URL) */
          if( n>2 ){
            zDisplay = &z[1];
            z[n] = 0;
          }else{

          wiki_render(p, zDisplay);
          p->state = savedState;
          blob_append(p->pOut, zClose, -1);
        }
        break;
      }
      case TOKEN_BACKSLASH: {
        if( (p->state & WIKI_MARKDOWN_FONT)==0 ){
          /* Ignore backslashes in traditional Wiki */
          blob_append_char(p->pOut, '\\');
          n = 1;
        }else{
          blob_append_char(p->pOut, z[1]);
        }
        break;
      }
      case TOKEN_MDCODE: {
        if( (p->state & WIKI_MARKDOWN_FONT)==0 ){
          blob_append(p->pOut, z, n);
        }else{
          int x = verbatimLength(p, z+n, n);
          if( x==0 ){
            blob_append(p->pOut, z, n);
          }else{
            z[x+n] = 0;

        /* URL enclosed in <...>
        **
        ** Originally, Fossil-Wiki would just display this as literal
        ** text, but as of 2025-03-04, it actually inserts an <a>..</a>
        ** for the hyperlink.  The <...> delimiters are retained, however.
        ** Except in markdown-span mode, the <...> delimiters are omitted.
        */
        if( (p->state & WIKI_MARKDOWN_LINK)==0 ){
          blob_append(p->pOut, "&lt;", 4);
        }
        z[n-1] = 0;
        blob_appendf(p->pOut, "<a href=\"%h\">%h</a>", z+1, z+1);
        z[n-1] = '>';
        if( (p->state & WIKI_MARKDOWN_LINK)==0 ){
          blob_append(p->pOut, "&gt;", 4);
        }
        break;
      }
      case TOKEN_MARKUP: {
        const char *zId;
        int iDiv;

** Usage: %fossil test-wiki-render FILE [OPTIONS]
**
** Translate the input FILE from Fossil-wiki into HTML and write
** the resulting HTML on standard output.
**
** Options:
**    --buttons        Set the WIKI_BUTTONS flag
**    --dark-pikchr      Render pikchrs in dark mode
**    --htmlonly         Set the WIKI_HTMLONLY flag
**    --inline           Set the WIKI_INLINE flag
**    --linksonly         Set the WIKI_LINKSONLY flag
**    --markdown         Allow all in-line markdown syntax
**    --markdown-link    Allow markdown hyperlink syntax
**    --markdown-style   Allow markdown font and style markup
**    --nobadlinks       Set the WIKI_NOBADLINKS flag
**    --noblock          Set the WIKI_NOBLOCK flag
**    --text             Run the output through html_to_plaintext().
**    --tokenize         Output a tokenization of the input file
*/
void test_wiki_render(void){
  Blob in, out;
  int flags = 0;
  int bText, bTokenize;
  if( find_option("buttons",0,0)!=0 ) flags |= WIKI_BUTTONS;
  if( find_option("htmlonly",0,0)!=0 ) flags |= WIKI_HTMLONLY;
  if( find_option("linksonly",0,0)!=0 ) flags |= WIKI_LINKSONLY;
  if( find_option("nobadlinks",0,0)!=0 ) flags |= WIKI_NOBADLINKS;
  if( find_option("inline",0,0)!=0 ) flags |= WIKI_INLINE;
  if( find_option("noblock",0,0)!=0 ) flags |= WIKI_NOBLOCK;
  if( find_option("markdown",0,0)!=0 ) flags |= WIKI_MARKDOWN_INLINE;
  if( find_option("markdown-style",0,0)!=0 ) flags |= WIKI_MARKDOWN_FONT;
  if( find_option("markdown-link",0,0)!=0 ) flags |= WIKI_MARKDOWN_LINK;
  if( find_option("dark-pikchr",0,0)!=0 ){
    pikchr_to_html_add_flags( PIKCHR_PROCESS_DARK_MODE );
  }
  bText = find_option("text",0,0)!=0;
  bTokenize = find_option("tokenize",0,0)!=0;
  db_find_and_open_repository(OPEN_OK_NOT_FOUND|OPEN_SUBSTITUTE,0);
  verify_all_options();

    }
    switch( tokenType ){
      case TOKEN_LINK: {
        char *zTarget, *zEnd;
        int i;

        if( z[n]=='('
         && (flags & WIKI_MARKDOWN_LINK)!=0
         && (zEnd = strchr(z+n+1,')'))!=0
        ){
          /* Markdown-style hyperlinks: [display-text](URL) or [](URL) */
          z += n+1;
          zTarget = z;
          for(i=1; z[i] && z[i]!=')' && z[i]!=' '; i++){}
          n = (int)(zEnd - z) + 1;