Fossil

            char c, void *opaque);

  /* low level callbacks - NULL copies input directly into the output */
  void (*entity)(struct Blob *ob, struct Blob *entity, void *opaque);
  void (*normal_text)(struct Blob *ob, struct Blob *text, void *opaque);

  /* renderer data */
  int max_work_stack; /* prevent arbitrary deep recursion, cf README */
  const char *emph_chars; /* chars that trigger emphasis rendering */
  void *opaque; /* opaque data send to every rendering callback */
};



/*********

/* render -- structure containing one particular render */
struct render {
  struct mkd_renderer make;
  struct Blob refs;
  char_trigger active_char[256];
  int work_active;
  struct Blob *work;
  int nBlobCache;                /* Number of entries in aBlobCache */
  struct Blob *aBlobCache[20];   /* Cache of Blobs available for reuse */
};


/* html_tag -- structure for quick HTML tag search (inspired from discount) */
struct html_tag {
  const char *text;
  int size;

                 block_tags,
                 count(block_tags),
                 sizeof block_tags[0],
                 cmp_html_tag);
}


/* new_work_buffer -- get a new working buffer from the stack or create one */
/* get a new working buffer from the cache or create one */
static struct Blob *new_work_buffer(struct render *rndr){
  struct Blob *ret = 0;

  struct Blob *ret;
  if( rndr->nBlobCache ){
  if( rndr->work_active < rndr->make.max_work_stack ){
    ret = rndr->work + rndr->work_active;
    ret = rndr->aBlobCache[--rndr->nBlobCache];
    rndr->work_active += 1;
    blob_reset(ret);
  }else{
    ret = fossil_malloc(sizeof(*ret));
  }
  *ret = empty_blob;
  return ret;
}


/* release_work_buffer -- release the given working buffer */
/* release the given working buffer back to the cache */
static void release_work_buffer(struct render *rndr, struct Blob *buf){
  if( !buf ) return;
  assert(rndr->work_active>0 && buf==(rndr->work+rndr->work_active-1));
  rndr->work_active -= 1;
  blob_reset(buf);
  if( rndr->nBlobCache < sizeof(rndr->aBlobCache)/sizeof(rndr->aBlobCache[0]) ){
    rndr->aBlobCache[rndr->nBlobCache++] = buf;
  }else{
    fossil_free(buf);
  }
}



/****************************
 * INLINE PARSING FUNCTIONS *
 ****************************/

      }
      work_size += end-beg;
    }
    beg = end;
  }

  if( rndr->make.blockquote ){
    struct Blob fallback = BLOB_INITIALIZER;
    if( out ){
      parse_block(out, rndr, work_data, work_size);
    parse_block(out, rndr, work_data, work_size);
    }else{
      blob_init(&fallback, work_data, work_size);
    }
    rndr->make.blockquote(ob, out ? out : &fallback, rndr->make.opaque);
    rndr->make.blockquote(ob, out, rndr->make.opaque);
  }
  release_work_buffer(rndr, out);
  return end;
}


/* parse_paragraph -- handles parsing of a regular paragraph */
static size_t parse_paragraph(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t size
){
  size_t i = 0, end = 0;
  int level = 0;
  char *work_data = data;
  size_t work_size = 0;
  struct Blob fallback = BLOB_INITIALIZER;

  while( i<size ){
    for(end=i+1; end<size && data[end-1]!='\n'; end++);
    if( is_empty(data+i, size-i)
     || (level = is_headerline(data+i, size-i))!= 0
    ){
      break;

  work_size = i;
  while( work_size && data[work_size-1]=='\n' ){ work_size--; }

  if( !level ){
    if( rndr->make.paragraph ){
      struct Blob *tmp = new_work_buffer(rndr);
      if( tmp ){
        parse_inline(tmp, rndr, work_data, work_size);
      parse_inline(tmp, rndr, work_data, work_size);
      }else{
        blob_init(&fallback, work_data, work_size);
      }
      rndr->make.paragraph(ob, tmp ? tmp : &fallback, rndr->make.opaque);
      rndr->make.paragraph(ob, tmp, rndr->make.opaque);
      release_work_buffer(rndr, tmp);
    }
  }else{
    if( work_size ){
      size_t beg;
      i = work_size;
      work_size -= 1;
      while( work_size && data[work_size]!='\n' ){ work_size--; }
      beg = work_size+1;
      while( work_size && data[work_size-1]=='\n'){ work_size--; }
      if( work_size ){
        struct Blob *tmp = new_work_buffer(rndr);
        if( tmp ){
          parse_inline(tmp, rndr, work_data, work_size);
        parse_inline(tmp, rndr, work_data, work_size);
        }else{
          blob_init (&fallback, work_data, work_size);
        }
        if( rndr->make.paragraph ){
          rndr->make.paragraph(ob, tmp ? tmp : &fallback, rndr->make.opaque);
          rndr->make.paragraph(ob, tmp, rndr->make.opaque);
        }
        release_work_buffer(rndr, tmp);
        work_data += beg;
        work_size = i - beg;
      }else{
        work_size = i;
      }
    }

    if( rndr->make.header ){
      struct Blob *span = new_work_buffer(rndr);
      if( span ){
        parse_inline(span, rndr, work_data, work_size);
        rndr->make.header(ob, span, level, rndr->make.opaque);
      parse_inline(span, rndr, work_data, work_size);
      rndr->make.header(ob, span, level, rndr->make.opaque);
      }else{
        blob_init(&fallback, work_data, work_size);
        rndr->make.header(ob, &fallback, level, rndr->make.opaque);
      }
      release_work_buffer(rndr, span);
    }
  }
  return end;
}

static size_t parse_listitem(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t size,
  int *flags
){
  struct Blob fallback = BLOB_INITIALIZER;
  struct Blob *work = 0, *inter = 0;
  size_t beg = 0, end, pre, sublist = 0, orgpre = 0, i;
  int in_empty = 0, has_inside_empty = 0;

  /* keeping track of the first indentation prefix */
  if( size>1 && data[0]==' ' ){
    orgpre = 1;

  /* skipping to the beginning of the following line */
  end = beg;
  while( end<size && data[end-1]!='\n' ){ end++; }

  /* getting working buffers */
  work = new_work_buffer(rndr);
  inter = new_work_buffer(rndr);
  if( !work ) work = &fallback;

  /* putting the first line into the working buffer */
  blob_append(work, data+beg, end-beg);
  beg = end;

  /* process the following lines */
  while( beg<size ){

  }

  /* non-recursive fallback when working buffer stack is full */
  if( !inter ){
    if( rndr->make.listitem ){
      rndr->make.listitem(ob, work, *flags, rndr->make.opaque);
    }
    if( work!=&fallback ) release_work_buffer(rndr, work);
    release_work_buffer(rndr, work);
    blob_reset(&fallback);
    return beg;
  }

  /* render of li contents */
  if( has_inside_empty ) *flags |= MKD_LI_BLOCK;
  if( *flags & MKD_LI_BLOCK ){
    /* intermediate render of block li */

  }

  /* render of li itself */
  if( rndr->make.listitem ){
    rndr->make.listitem(ob, inter, *flags, rndr->make.opaque);
  }
  release_work_buffer(rndr, inter);
  if( work!=&fallback ) release_work_buffer(rndr, work);
  release_work_buffer(rndr, work);
  blob_reset(&fallback);
  return beg;
}


/* parse_list -- parsing ordered or unordered list block */
static size_t parse_list(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t size,
  int flags
){
  struct Blob fallback = BLOB_INITIALIZER;
  struct Blob *work = new_work_buffer(rndr);
  size_t i = 0, j;
  if( !work ) work = &fallback;

  while( i<size ){
    j = parse_listitem(work, rndr, data+i, size-i, &flags);
    i += j;
    if( !j || (flags & MKD_LI_END) ) break;
  }

  if( rndr->make.list ) rndr->make.list(ob, work, flags, rndr->make.opaque);
  if( work!=&fallback ) release_work_buffer(rndr, work);
  release_work_buffer(rndr, work);
  blob_reset(&fallback);
  return i;
}


/* parse_atxheader -- parsing of atx-style headers */
static size_t parse_atxheader(
  struct Blob *ob,

  if( end<=i ) return parse_paragraph(ob, rndr, data, size);
  while( end && data[end-1]=='#' ){ end--; }
  while( end && (data[end-1]==' ' || data[end-1]=='\t') ){ end--; }
  if( end<=i ) return parse_paragraph(ob, rndr, data, size);

  span_size = end-span_beg;
  if( rndr->make.header ){
    struct Blob fallback = BLOB_INITIALIZER;
    struct Blob *span = new_work_buffer(rndr);

    if( span ){
      parse_inline(span, rndr, data+span_beg, span_size);
    parse_inline(span, rndr, data+span_beg, span_size);
    }else{
      blob_init(&fallback, data+span_beg, span_size);
    }
    rndr->make.header(ob, span ? span : &fallback, level, rndr->make.opaque);
    rndr->make.header(ob, span, level, rndr->make.opaque);
    release_work_buffer(rndr, span);
  }
  return skip;
}


/* htmlblock_end -- checking end of HTML block : </tag>[ \t]*\n[ \t*]\n */

static void parse_table_cell(
  struct Blob *ob,     /* output blob */
  struct render *rndr, /* renderer description */
  char *data,          /* input text */
  size_t size,         /* input text size */
  int flags            /* table flags */
){
  struct Blob fallback = BLOB_INITIALIZER;
  struct Blob *span = new_work_buffer(rndr);

  if( span ){
    parse_inline(span, rndr, data, size);
  parse_inline(span, rndr, data, size);
  }else{
    blob_init(&fallback, data, size);
  }
  rndr->make.table_cell(ob, span ? span : &fallback, flags, rndr->make.opaque);
  rndr->make.table_cell(ob, span, flags, rndr->make.opaque);
  release_work_buffer(rndr, span);
}


/* parse_table_row -- parse an input line into a table row */
static size_t parse_table_row(
  struct Blob *ob,        /* output blob for rendering */

      parse_table_cell(cells, rndr, data+beg, end-beg, align|flags);
    }

    col++;
  }

  /* render the whole row and clean up */
  if( cells ){
    rndr->make.table_row(ob, cells, flags, rndr->make.opaque);
  rndr->make.table_row(ob, cells, flags, rndr->make.opaque);
  }else{
    struct Blob fallback = BLOB_INITIALIZER;
    blob_init(&fallback, data, total ? total : size);
    rndr->make.table_row(ob, &fallback, flags, rndr->make.opaque);
  }
  release_work_buffer(rndr, cells);
  return total ? total : size;
}


/* parse_table -- parsing of a whole table */
static size_t parse_table(
  struct Blob *ob,
  struct render *rndr,
  char *data,
  size_t size
){
  size_t i = 0, head_end, col;
  size_t align_size = 0;
  int *aligns = 0;
  struct Blob fallback = BLOB_INITIALIZER;
  struct Blob *head = 0;
  struct Blob *rows = new_work_buffer(rndr);
  if( !rows ) rows = &fallback;

  /* skip the first (presumably header) line */
  while( i<size && data[i]!='\n' ){ i++; }
  head_end = i;

  /* fallback on end of input */
  if( i>=size ){
    parse_table_row(rows, rndr, data, size, 0, 0, 0);
    rndr->make.table(ob, 0, rows, rndr->make.opaque);
    if( rows!=&fallback ) release_work_buffer(rndr, rows);
    release_work_buffer(rndr, rows);
    return i;
  }

  /* attempt to parse a table rule, i.e. blanks, dash, colons and sep */
  i++;
  col = 0;
  while( i<size

    i += parse_table_row(rows, rndr, data+i, size-i, aligns, align_size, 0);
  }

  /* render the full table */
  rndr->make.table(ob, head, rows, rndr->make.opaque);

  /* cleanup */
  if( head ) release_work_buffer(rndr, head);
  if( rows!=&fallback ) release_work_buffer(rndr, rows);
  release_work_buffer(rndr, head);
  release_work_buffer(rndr, rows);
  fossil_free(aligns);
  return i;
}


/* parse_block -- parsing of one block, returning next char to parse */
static void parse_block(

/* markdown -- parses the input buffer and renders it into the output buffer */
void markdown(
  struct Blob *ob,                   /* output blob for rendered text */
  struct Blob *ib,                   /* input blob in markdown */
  const struct mkd_renderer *rndrer  /* renderer descriptor (callbacks) */
){
  struct link_ref *lr;
  struct Blob text = BLOB_INITIALIZER;
  size_t i, beg, end = 0;
  struct render rndr;
  char *ib_data;
  Blob text = BLOB_INITIALIZER;

  /* filling the render structure */
  if( !rndrer ) return;
  rndr.make = *rndrer;
  if( rndr.make.max_work_stack<1 ) rndr.make.max_work_stack = 1;
  rndr.work_active = 0;
  rndr.nBlobCache = 0;
  rndr.work = fossil_malloc(rndr.make.max_work_stack * sizeof *rndr.work);
  for(i=0; i<rndr.make.max_work_stack; i++) rndr.work[i] = text;
  rndr.refs = text;
  rndr.refs = empty_blob;
  for(i=0; i<256; i++) rndr.active_char[i] = 0;
  if( (rndr.make.emphasis
    || rndr.make.double_emphasis
    || rndr.make.triple_emphasis)
   && rndr.make.emph_chars
  ){
    for(i=0; rndr.make.emph_chars[i]; i++){

  end = blob_size(&rndr.refs)/sizeof(struct link_ref);
  for(i=0; i<end; i++){
    blob_reset(&lr[i].id);
    blob_reset(&lr[i].link);
    blob_reset(&lr[i].title);
  }
  blob_reset(&rndr.refs);
  blobarray_zero(rndr.work, rndr.make.max_work_stack);
  fossil_free(rndr.work);
}
  for(i=0; i<rndr.nBlobCache; i++){
    fossil_free(rndr.aBlobCache[i]);
  }
}