Fossil

** using an external renderer.
*/

#include "config.h"
#include "markdown.h"

#include <assert.h>

#include <string.h>
#include <stdlib.h>

#define MKD_LI_END 8  /* internal list flag */

/********************
 * TYPE DEFINITIONS *

  MKDA_EXPLICIT_EMAIL,  /* e-mail link with explicit mailto: */
  MKDA_IMPLICIT_EMAIL   /* e-mail link without mailto: */
};

/* mkd_tagspan -- type of tagged <span> */
enum mkd_tagspan {
  MKDT_ATREF,           /* @name references, as in /chat attention targeting */
  MKDT_HASHTAG,         /* #hash tags, message IDs, etc. */
};

/* mkd_renderer -- functions for rendering parsed data */
struct mkd_renderer {
  /* document level callbacks */
  void (*prolog)(struct Blob *ob, void *opaque);
  void (*epilog)(struct Blob *ob, void *opaque);

  char *data,
  size_t offset,
  size_t size
){
  size_t end;
  struct Blob work = BLOB_INITIALIZER;

  if(offset>0 && !fossil_isspace(data[-1])){
    /* Only ever match if the *previous* character is
       whitespace or we're at the start of the input. */
    return 0;
  }
  /*fprintf(stderr,"@-REF: %.*s\n", (int)size, data);*/
  if (size < 2 || !fossil_isalpha(data[1])) return 0;
  for (end = 2; (end < size)
         && (fossil_isalnum(data[end])
             /* TODO: email addresses are legal fossil user names, but
                parsing those is beyond our current ambitions.
                Similarly, non-ASCII names are legal, but not
                currently handled here. */
             /*|| data[end] == '.' || data[end] == '_'
               || data[end] == '-'*/);
       ++end);
  if(end<size){
    if(!fossil_isspace(data[end])){
      return 0;
    }
  }
  blob_init(&work, data + 1, end - 1);
  rndr->make.tagspan(ob, &work, MKDT_ATREF, rndr->make.opaque);
  return end;
}


/* char_hashref_tag -- '#' followed by "word" characters to tag
 * post numbers, hashtags, etc. */
static size_t char_hashref_tag(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t offset,
  size_t size
){
  size_t end;
  struct Blob work = BLOB_INITIALIZER;

  if(offset>0 && !fossil_isspace(data[-1])){
    /* Only ever match if the *previous* character is
       whitespace or we're at the start of the input. */
    return 0;
  }
  if(size < 2 || !fossil_isalnum(data[1])) return 0;
  /*fprintf(stderr,"HASHREF: %.*s\n", (int)size, data);*/
  for (end = 2; (end < size) && fossil_isalnum(data[end]); ++end);
  /*TODO: in order to support detection of forum post-style
    references, we need to recognize #X.Y, but only when X and Y are
    both purely numeric and Y ends on a word/sentence
    boundary.*/
  if(end<size){
    /* Only match if we end at a dot or space or end of input */
    if(data[end]!='.' && !fossil_isspace(data[end])){
      return 0;
    }
  }
  blob_init(&work, data + 1, end - 1);
  rndr->make.tagspan(ob, &work, MKDT_HASHTAG, rndr->make.opaque);
  return end;
  return 0;
}


/* char_langle_tag -- '<' when tags or autolinks are allowed */
static size_t char_langle_tag(
  struct Blob *ob,
  struct render *rndr,

  struct Blob *text,      /* The word after the tag character */
  enum mkd_tagspan type,  /* Which type of tagspan we're creating */
  void *opaque
){
  if( text==0 ){
    /* no-op */
  }else{
    char cPrefix = '!';
    BLOB_APPEND_LITERAL(ob, "<span data-");
    switch (type) {
      case MKDT_ATREF:
        cPrefix = '@'; BLOB_APPEND_LITERAL(ob, "atref"); break;
      case MKDT_HASHTAG:
        cPrefix = '#'; BLOB_APPEND_LITERAL(ob, "hashtag");  break;
    }
    BLOB_APPEND_LITERAL(ob, "=\"");
    html_quote(ob, blob_buffer(text), blob_size(text));
    BLOB_APPEND_LITERAL(ob, "\"");
    blob_appendf(ob, ">%c%b</span>", cPrefix,text);
  }
  return 1;
}

static int html_triple_emphasis(
  struct Blob *ob,
  struct Blob *text,