Fossil

  int nBlobCache;                /* Number of entries in aBlobCache */
  struct Blob *aBlobCache[20];   /* Cache of Blobs available for reuse */

  struct {
    Blob all;    /* array of footnotes */
    int nLbled;  /* number of labeled footnotes found during the first pass */
    int nMarks;  /* counts distinct indices found during the second pass    */
    struct footnote misref; /* nUsed counts misreferences, iMark must be -1 */
  } notes;
};

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

/* cmp_link_ref_sort -- comparison function for link_ref qsort */
static int cmp_link_ref_sort(const void *a, const void *b){
  struct link_ref *lra = (void *)a;
  struct link_ref *lrb = (void *)b;
  return blob_compare(&lra->id, &lrb->id);
}

/* cmp_footnote_id -- comparison function for footnotes qsort.
 * Empty IDs sort last (in undetermined order).
 * Equal IDs are sorted in the REVERSED order of definition in the source */
static int cmp_footnote_id(const void *fna, const void *fnb){
  const struct footnote *a = fna, *b = fnb;
  const int szA = blob_size(&a->id), szB = blob_size(&b->id);
  if( szA ){
    if( szB ){
      int cmp = blob_compare(&a->id, &b->id);
      if( cmp ) return cmp;
    }else return -1;
  }else return szB ? 1 : 0;
  /* ids are equal and non-empty */
  if( a->defno < b->defno ) return -1;
  if( a->defno > b->defno ) return  1;
  return 0; /* should never reach here */
}

/* cmp_footnote_sort -- comparison function for footnotes qsort.
 * Unreferenced footnotes (when nUsed == 0) sort last and
 * are sorted in the order of definition in the source */
static int cmp_footnote_sort(const void *fna, const void *fnb){
  const struct footnote *a = fna, *b = fnb;
  int i, j;

  blob_reset(link);
  blob_reset(title);
  blob_append(link, blob_buffer(&lr->link), blob_size(&lr->link));
  blob_append(title, blob_buffer(&lr->title), blob_size(&lr->title));
  return 0;
}

/* get_footnote() -- find a footnote by label, invoked during the 2nd pass.
 * On success returns a footnote (after incrementing its nUsed field),
 * otherwise returns NULL */
static const struct footnote* get_footnote(
  struct render *rndr,
  const char *data,
  size_t size
){
  struct footnote *fn = NULL;
  struct Blob *id = new_work_buffer(rndr);

  fn->nUsed++;
  assert( fn->iMark > 0 );
  assert( fn->nUsed > 0 );
cleanup:
  release_work_buffer( rndr, id );
  return fn;
}

/* Adds unlabeled footnote to the rndr.
 * If text is blank then returns 0,
 * otherwise returns the address of the added footnote. */
static inline const struct footnote* add_inline_footnote(
  struct render *rndr,
  const char *text,
  size_t size

          blob_append_char(&text, '\n');
        }
        end += 1;
      }
      beg = end;
    }
  }

  /* sorting the reference array */
  if( blob_size(&rndr.refs) ){
    qsort(blob_buffer(&rndr.refs),
          blob_size(&rndr.refs)/sizeof(struct link_ref),
          sizeof(struct link_ref),
          cmp_link_ref_sort);
  }
  rndr.notes.nLbled = COUNT_FOOTNOTES(&rndr.notes.all);

  /* sort footnotes by ID and join duplicates */
  if( rndr.notes.nLbled > 1 ){
    fn = CAST_AS_FOOTNOTES(&rndr.notes.all);
    qsort(fn, rndr.notes.nLbled, sizeof(struct footnote), cmp_footnote_id);

    /* concatenate footnotes with equal labels */
    for(i=0; i<rndr.notes.nLbled ;){
      struct footnote *x = fn + i;
      size_t j = i+1, k = blob_size(&x->text) + 64;
      while(j<rndr.notes.nLbled && !blob_compare(&x->id, &fn[j].id)){
        k += blob_size(&fn[j].text) + 10;
        j++;
      }
      if( i+1<j ){
        Blob tmp = empty_blob;
        blob_reserve(&tmp, k);
        blob_append_string(&tmp, "<ul class='footnote-joined'>\n");
        for(k=i; k<j; k++){
          struct footnote *y = fn + k;
          blob_append_string(&tmp, "<li>");
          blob_append(&tmp, blob_buffer(&y->text), blob_size(&y->text));
          blob_append_string(&tmp, "</li>\n");

          /* free memory buffer */
          blob_reset(&y->text);
          if( k!=i ){
            blob_reset(&y->id);
            /* invalidate redundant elements (this is optional) */
            memset(y,0,sizeof(struct footnote));
            y->index = y->defno = y->iMark = y->nUsed = -42;
          }
        }
        blob_append_string(&tmp, "</ul>\n");
        x->text = tmp;
      }
      i = j;
    }

    /* move redundant elements to the end of array and truncate/resize */
    qsort(fn, rndr.notes.nLbled, sizeof(struct footnote), cmp_footnote_id);
    i = rndr.notes.nLbled;
    while( i && !blob_size(&fn[i-1].id) ){ i--; }
    rndr.notes.nLbled = i;
    blob_truncate( &rndr.notes.all, i*sizeof(struct footnote) );
  }
  assert( COUNT_FOOTNOTES(&rndr.notes.all) == rndr.notes.nLbled );
  fn = CAST_AS_FOOTNOTES(&rndr.notes.all);
  for(i=0; i<rndr.notes.nLbled; i++){
    fn[i].index = i;
  }
  assert( rndr.notes.nMarks==0 );

  /* second pass: actual rendering */
  if( rndr.make.prolog ) rndr.make.prolog(ob, rndr.make.opaque);
  parse_block(ob, &rndr, blob_buffer(&text), blob_size(&text));

  if( (blob_size(&rndr.notes.all) || rndr.notes.misref.nUsed) ){