Fossil SCM
Decouple parsing and HTML-specific rendering. Add support for back references in the list of footnotes. WIP - inline and multiline footnotes are not yet implemented.
Commit
e3710ccd3a5af6ad7b784f5ac42b78105f87932f85d598afe4b5daabfe905696
Parent
b9393a4e640d3ab…
3 files changed
+4
+79
-59
+91
+4
| --- src/default.css | ||
| +++ src/default.css | ||
| @@ -1670,10 +1670,14 @@ | ||
| 1670 | 1670 | div.content div.markdown > ol.footnotes { |
| 1671 | 1671 | font-size: 90%; |
| 1672 | 1672 | } |
| 1673 | 1673 | div.content div.markdown > ol.footnotes > li { |
| 1674 | 1674 | margin-bottom: 0.5em; |
| 1675 | +} | |
| 1676 | +div.content div.markdown > ol.footnotes > li > .footnote-backrefs { | |
| 1677 | + margin-right: 1em; | |
| 1678 | + font-weight: bold; | |
| 1675 | 1679 | } |
| 1676 | 1680 | |
| 1677 | 1681 | /* Objects in the "desktoponly" class are invisible on mobile */ |
| 1678 | 1682 | @media screen and (max-width: 600px) { |
| 1679 | 1683 | .desktoponly { |
| 1680 | 1684 |
| --- src/default.css | |
| +++ src/default.css | |
| @@ -1670,10 +1670,14 @@ | |
| 1670 | div.content div.markdown > ol.footnotes { |
| 1671 | font-size: 90%; |
| 1672 | } |
| 1673 | div.content div.markdown > ol.footnotes > li { |
| 1674 | margin-bottom: 0.5em; |
| 1675 | } |
| 1676 | |
| 1677 | /* Objects in the "desktoponly" class are invisible on mobile */ |
| 1678 | @media screen and (max-width: 600px) { |
| 1679 | .desktoponly { |
| 1680 |
| --- src/default.css | |
| +++ src/default.css | |
| @@ -1670,10 +1670,14 @@ | |
| 1670 | div.content div.markdown > ol.footnotes { |
| 1671 | font-size: 90%; |
| 1672 | } |
| 1673 | div.content div.markdown > ol.footnotes > li { |
| 1674 | margin-bottom: 0.5em; |
| 1675 | } |
| 1676 | div.content div.markdown > ol.footnotes > li > .footnote-backrefs { |
| 1677 | margin-right: 1em; |
| 1678 | font-weight: bold; |
| 1679 | } |
| 1680 | |
| 1681 | /* Objects in the "desktoponly" class are invisible on mobile */ |
| 1682 | @media screen and (max-width: 600px) { |
| 1683 | .desktoponly { |
| 1684 |
+79
-59
| --- src/markdown.c | ||
| +++ src/markdown.c | ||
| @@ -45,10 +45,11 @@ | ||
| 45 | 45 | /* mkd_renderer -- functions for rendering parsed data */ |
| 46 | 46 | struct mkd_renderer { |
| 47 | 47 | /* document level callbacks */ |
| 48 | 48 | void (*prolog)(struct Blob *ob, void *opaque); |
| 49 | 49 | void (*epilog)(struct Blob *ob, void *opaque); |
| 50 | + void (*footnotes)(struct Blob *ob, const struct Blob *items, void *opaque); | |
| 50 | 51 | |
| 51 | 52 | /* block level callbacks - NULL skips the block */ |
| 52 | 53 | void (*blockcode)(struct Blob *ob, struct Blob *text, void *opaque); |
| 53 | 54 | void (*blockquote)(struct Blob *ob, struct Blob *text, void *opaque); |
| 54 | 55 | void (*blockhtml)(struct Blob *ob, struct Blob *text, void *opaque); |
| @@ -63,10 +64,12 @@ | ||
| 63 | 64 | void *opaque); |
| 64 | 65 | void (*table_cell)(struct Blob *ob, struct Blob *text, int flags, |
| 65 | 66 | void *opaque); |
| 66 | 67 | void (*table_row)(struct Blob *ob, struct Blob *cells, int flags, |
| 67 | 68 | void *opaque); |
| 69 | + void (*footnote_item)(struct Blob *ob, const struct Blob *text, | |
| 70 | + int index, int nUsed, void *opaque); | |
| 68 | 71 | |
| 69 | 72 | /* span level callbacks - NULL or return 0 prints the span verbatim */ |
| 70 | 73 | int (*autolink)(struct Blob *ob, struct Blob *link, |
| 71 | 74 | enum mkd_autolink type, void *opaque); |
| 72 | 75 | int (*codespan)(struct Blob *ob, struct Blob *text, int nSep, void *opaque); |
| @@ -79,10 +82,11 @@ | ||
| 79 | 82 | int (*link)(struct Blob *ob, struct Blob *link, struct Blob *title, |
| 80 | 83 | struct Blob *content, void *opaque); |
| 81 | 84 | int (*raw_html_tag)(struct Blob *ob, struct Blob *tag, void *opaque); |
| 82 | 85 | int (*triple_emphasis)(struct Blob *ob, struct Blob *text, |
| 83 | 86 | char c, void *opaque); |
| 87 | + int (*footnote_ref)(struct Blob *ob, int index, int locus, void *opaque); | |
| 84 | 88 | |
| 85 | 89 | /* low level callbacks - NULL copies input directly into the output */ |
| 86 | 90 | void (*entity)(struct Blob *ob, struct Blob *entity, void *opaque); |
| 87 | 91 | void (*normal_text)(struct Blob *ob, struct Blob *text, void *opaque); |
| 88 | 92 | |
| @@ -122,10 +126,12 @@ | ||
| 122 | 126 | const struct mkd_renderer *rndr); |
| 123 | 127 | |
| 124 | 128 | |
| 125 | 129 | #endif /* INTERFACE */ |
| 126 | 130 | |
| 131 | +#define BLOB_COUNT(blob_ptr,el_type) (blob_size(blob_ptr)/sizeof(el_type)) | |
| 132 | +#define COUNT_FOOTNOTES(blob_ptr) BLOB_COUNT(blob_ptr,struct footnote) | |
| 127 | 133 | |
| 128 | 134 | /*************** |
| 129 | 135 | * LOCAL TYPES * |
| 130 | 136 | ***************/ |
| 131 | 137 | |
| @@ -138,10 +144,11 @@ | ||
| 138 | 144 | |
| 139 | 145 | struct footnote { |
| 140 | 146 | struct Blob id; /* must be the first field as in link_ref struct */ |
| 141 | 147 | struct Blob text; /* footnote's content that is rendered at the end */ |
| 142 | 148 | int index; /* serial number, in the order of appearance */ |
| 149 | + int nUsed; /* number of references to this note */ | |
| 143 | 150 | }; |
| 144 | 151 | |
| 145 | 152 | |
| 146 | 153 | /* char_trigger -- function pointer to render active chars */ |
| 147 | 154 | /* returns the number of chars taken care of */ |
| @@ -158,16 +165,17 @@ | ||
| 158 | 165 | |
| 159 | 166 | /* render -- structure containing one particular render */ |
| 160 | 167 | struct render { |
| 161 | 168 | struct mkd_renderer make; |
| 162 | 169 | struct Blob refs; |
| 163 | - struct Blob footnotes; | |
| 164 | 170 | char_trigger active_char[256]; |
| 165 | 171 | int iDepth; /* Depth of recursion */ |
| 166 | 172 | int nBlobCache; /* Number of entries in aBlobCache */ |
| 167 | 173 | struct Blob *aBlobCache[20]; /* Cache of Blobs available for reuse */ |
| 168 | - int nLabels; /* Footnotes counter for the second pass */ | |
| 174 | + | |
| 175 | + struct Blob notes; /* array of footnotes */ | |
| 176 | + int iNotesCount; /* count distinct indices found in the second pass */ | |
| 169 | 177 | }; |
| 170 | 178 | |
| 171 | 179 | /* html_tag -- structure for quick HTML tag search (inspired from discount) */ |
| 172 | 180 | struct html_tag { |
| 173 | 181 | const char *text; |
| @@ -254,15 +262,18 @@ | ||
| 254 | 262 | struct link_ref *lra = (void *)a; |
| 255 | 263 | struct link_ref *lrb = (void *)b; |
| 256 | 264 | return blob_compare(&lra->id, &lrb->id); |
| 257 | 265 | } |
| 258 | 266 | |
| 259 | -/* cmp_footnote_sort -- comparison function for footnotes qsort */ | |
| 267 | +/* cmp_footnote_sort -- comparison function for footnotes qsort. | |
| 268 | + * Unused footnotes (when index == 0) sort last */ | |
| 260 | 269 | static int cmp_footnote_sort(const void *a, const void *b){ |
| 261 | 270 | const struct footnote *fna = (void *)a, *fnb = (void *)b; |
| 262 | - assert( fna->index > 0 && fnb->index > 0 ); | |
| 271 | + assert( fna->index >= 0 && fnb->index >= 0 ); | |
| 263 | 272 | if( fna->index == fnb->index ) return 0; |
| 273 | + if( fna->index == 0 ) return 1; | |
| 274 | + if( fnb->index == 0 ) return -1; | |
| 264 | 275 | return ( fna->index < fnb->index ? -1 : 1 ); |
| 265 | 276 | } |
| 266 | 277 | |
| 267 | 278 | /* cmp_html_tag -- comparison function for bsearch() (stolen from discount) */ |
| 268 | 279 | static int cmp_html_tag(const void *a, const void *b){ |
| @@ -1017,38 +1028,37 @@ | ||
| 1017 | 1028 | blob_append(link, blob_buffer(&lr->link), blob_size(&lr->link)); |
| 1018 | 1029 | blob_append(title, blob_buffer(&lr->title), blob_size(&lr->title)); |
| 1019 | 1030 | return 0; |
| 1020 | 1031 | } |
| 1021 | 1032 | |
| 1022 | -/* get_footnote -- resolve footnote by its id | |
| 1033 | +/* get_footnote() is invoked during the second pass | |
| 1023 | 1034 | * on success: fill text and return positive footnote's index |
| 1024 | 1035 | * on failure: return -1 */ |
| 1025 | -static int get_footnote( | |
| 1036 | +static const struct footnote* get_footnote( | |
| 1026 | 1037 | struct render *rndr, |
| 1027 | - struct Blob *text, | |
| 1028 | 1038 | const char *data, |
| 1029 | 1039 | size_t size |
| 1030 | 1040 | ){ |
| 1031 | - struct footnote *fn; | |
| 1032 | - | |
| 1033 | - blob_reset(text); /* use text for temporary storage */ | |
| 1034 | - if( build_ref_id(text, data, size)<0 ) return -1; | |
| 1035 | - | |
| 1036 | - fn = bsearch(text, | |
| 1037 | - blob_buffer(&rndr->footnotes), | |
| 1038 | - blob_size(&rndr->footnotes)/sizeof(struct footnote), | |
| 1041 | + struct footnote *fn = NULL; | |
| 1042 | + struct Blob *id = new_work_buffer(rndr); | |
| 1043 | + if( build_ref_id(id, data, size)<0 ) goto cleanup; | |
| 1044 | + fn = bsearch(id, blob_buffer(&rndr->notes), | |
| 1045 | + COUNT_FOOTNOTES(&rndr->notes), | |
| 1039 | 1046 | sizeof (struct footnote), |
| 1040 | 1047 | cmp_link_ref); |
| 1041 | - if( !fn ) return -1; | |
| 1048 | + if( !fn ) goto cleanup; | |
| 1042 | 1049 | |
| 1043 | 1050 | if( fn->index == 0 ){ /* the first reference to the footnote */ |
| 1044 | - fn->index = ++(rndr->nLabels); | |
| 1051 | + assert( fn->nUsed == 0 ); | |
| 1052 | + fn->index = ++(rndr->iNotesCount); | |
| 1045 | 1053 | } |
| 1054 | + fn->nUsed++; | |
| 1046 | 1055 | assert( fn->index > 0 ); |
| 1047 | - blob_reset(text); | |
| 1048 | - blob_append(text, blob_buffer(&fn->text), blob_size(&fn->text)); | |
| 1049 | - return fn->index; | |
| 1056 | + assert( fn->nUsed > 0 ); | |
| 1057 | +cleanup: | |
| 1058 | + release_work_buffer( rndr, id ); | |
| 1059 | + return fn; | |
| 1050 | 1060 | } |
| 1051 | 1061 | |
| 1052 | 1062 | /* char_link -- '[': parsing a link or an image */ |
| 1053 | 1063 | static size_t char_link( |
| 1054 | 1064 | struct Blob *ob, |
| @@ -1055,17 +1065,19 @@ | ||
| 1055 | 1065 | struct render *rndr, |
| 1056 | 1066 | char *data, |
| 1057 | 1067 | size_t offset, |
| 1058 | 1068 | size_t size |
| 1059 | 1069 | ){ |
| 1060 | - int is_img = (offset && data[-1] == '!'), level; | |
| 1070 | + const int is_img = (offset && data[-1] == '!'); | |
| 1071 | + const int is_inline = (offset && data[-1]=='^'); | |
| 1072 | + const int is_note = !is_img && (is_inline || (size>1 && data[1]=='^')); | |
| 1061 | 1073 | size_t i = 1, txt_e; |
| 1062 | 1074 | struct Blob *content = 0; |
| 1063 | 1075 | struct Blob *link = 0; |
| 1064 | 1076 | struct Blob *title = 0; |
| 1065 | - const int is_note = (size && data[1] == '^'); | |
| 1066 | - int ret; | |
| 1077 | + const struct footnote *fn = 0; | |
| 1078 | + int level, ret; | |
| 1067 | 1079 | |
| 1068 | 1080 | /* checking whether the correct renderer exists */ |
| 1069 | 1081 | if( (is_img && !rndr->make.image) || (!is_img && !rndr->make.link) ){ |
| 1070 | 1082 | return 0; |
| 1071 | 1083 | } |
| @@ -1135,17 +1147,16 @@ | ||
| 1135 | 1147 | i = id_end+1; |
| 1136 | 1148 | |
| 1137 | 1149 | /* shortcut reference style link */ |
| 1138 | 1150 | }else{ |
| 1139 | 1151 | if( is_note ){ |
| 1140 | - const int lbl = get_footnote(rndr, link, data+1, txt_e-1); | |
| 1141 | - if( lbl <= 0 ){ | |
| 1142 | - goto char_link_cleanup; | |
| 1152 | + if( is_inline ){ | |
| 1153 | + //fn = put_footnote(rndr, data+1, txt_e-1); | |
| 1154 | + }else{ | |
| 1155 | + fn = get_footnote(rndr, data+1, txt_e-1); | |
| 1143 | 1156 | } |
| 1144 | - blob_reset(link); | |
| 1145 | - blob_appendf(link, "#footnote-%i", lbl); | |
| 1146 | - blob_appendf(content,"<sup class='footnote'>%i</sup>",lbl); | |
| 1157 | + if( !fn ) goto char_link_cleanup; | |
| 1147 | 1158 | }else if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){ |
| 1148 | 1159 | goto char_link_cleanup; |
| 1149 | 1160 | } |
| 1150 | 1161 | |
| 1151 | 1162 | /* rewinding the whitespace */ |
| @@ -1153,17 +1164,21 @@ | ||
| 1153 | 1164 | } |
| 1154 | 1165 | |
| 1155 | 1166 | /* building content: img alt is escaped, link content is parsed */ |
| 1156 | 1167 | if( txt_e>1 ){ |
| 1157 | 1168 | if( is_img ) blob_append(content, data+1, txt_e-1); |
| 1158 | - else if(!is_note) parse_inline(content, rndr, data+1, txt_e-1); | |
| 1169 | + else if(is_inline) parse_inline(content, rndr, data+1, txt_e-1); | |
| 1159 | 1170 | } |
| 1160 | 1171 | |
| 1161 | 1172 | /* calling the relevant rendering function */ |
| 1162 | 1173 | if( is_img ){ |
| 1163 | 1174 | if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--; |
| 1164 | 1175 | ret = rndr->make.image(ob, link, title, content, rndr->make.opaque); |
| 1176 | + }else if(fn){ | |
| 1177 | + if(rndr->make.footnote_ref){ | |
| 1178 | + ret = rndr->make.footnote_ref(ob,fn->index,fn->nUsed,rndr->make.opaque); | |
| 1179 | + } | |
| 1165 | 1180 | }else{ |
| 1166 | 1181 | ret = rndr->make.link(ob, link, title, content, rndr->make.opaque); |
| 1167 | 1182 | } |
| 1168 | 1183 | |
| 1169 | 1184 | /* cleanup */ |
| @@ -2250,11 +2265,11 @@ | ||
| 2250 | 2265 | ){ |
| 2251 | 2266 | size_t i = 0; |
| 2252 | 2267 | size_t id_offset, id_end; |
| 2253 | 2268 | size_t note_offset, note_end; |
| 2254 | 2269 | size_t line_end; |
| 2255 | - struct footnote fn = { empty_blob, empty_blob, 0 }; | |
| 2270 | + struct footnote fn = { empty_blob, empty_blob, 0, 0 }; | |
| 2256 | 2271 | |
| 2257 | 2272 | /* footnote definition must start at the begining of a line */ |
| 2258 | 2273 | if( beg+4>=end ) return 0; |
| 2259 | 2274 | i += beg; |
| 2260 | 2275 | |
| @@ -2311,20 +2326,21 @@ | ||
| 2311 | 2326 | ){ |
| 2312 | 2327 | struct link_ref *lr; |
| 2313 | 2328 | struct footnote *fn; |
| 2314 | 2329 | size_t i, beg, end = 0; |
| 2315 | 2330 | struct render rndr; |
| 2316 | - Blob text = BLOB_INITIALIZER; /* input after the first pass */ | |
| 2331 | + Blob text = BLOB_INITIALIZER; /* input after the first pass */ | |
| 2332 | + int nLabeled; /* number of footnotes found by the first pass */ | |
| 2317 | 2333 | |
| 2318 | 2334 | /* filling the render structure */ |
| 2319 | 2335 | if( !rndrer ) return; |
| 2320 | 2336 | rndr.make = *rndrer; |
| 2321 | 2337 | rndr.nBlobCache = 0; |
| 2322 | 2338 | rndr.iDepth = 0; |
| 2323 | - rndr.refs = empty_blob; | |
| 2324 | - rndr.footnotes = empty_blob; | |
| 2325 | - rndr.nLabels = 0; | |
| 2339 | + rndr.refs = empty_blob; | |
| 2340 | + rndr.notes = empty_blob; | |
| 2341 | + rndr.iNotesCount = 0; | |
| 2326 | 2342 | for(i=0; i<256; i++) rndr.active_char[i] = 0; |
| 2327 | 2343 | if( (rndr.make.emphasis |
| 2328 | 2344 | || rndr.make.double_emphasis |
| 2329 | 2345 | || rndr.make.triple_emphasis) |
| 2330 | 2346 | && rndr.make.emph_chars |
| @@ -2345,11 +2361,11 @@ | ||
| 2345 | 2361 | beg = 0; |
| 2346 | 2362 | for(const size_t size = blob_size(ib); beg<size ;){ |
| 2347 | 2363 | const char* const data = blob_buffer(ib); |
| 2348 | 2364 | if( is_ref(data, beg, size, &end, &rndr.refs) ){ |
| 2349 | 2365 | beg = end; |
| 2350 | - }else if( is_footnote(data, beg, size, &end, &rndr.footnotes) ){ | |
| 2366 | + }else if(is_footnote(data, beg, size, &end, &rndr.notes)){ | |
| 2351 | 2367 | /* FIXME: fossil_print("\nfootnote found at %i\n", beg); */ |
| 2352 | 2368 | beg = end; |
| 2353 | 2369 | }else{ /* skipping to the next line */ |
| 2354 | 2370 | end = beg; |
| 2355 | 2371 | while( end<size && data[end]!='\n' && data[end]!='\r' ){ |
| @@ -2373,41 +2389,39 @@ | ||
| 2373 | 2389 | qsort(blob_buffer(&rndr.refs), |
| 2374 | 2390 | blob_size(&rndr.refs)/sizeof(struct link_ref), |
| 2375 | 2391 | sizeof(struct link_ref), |
| 2376 | 2392 | cmp_link_ref_sort); |
| 2377 | 2393 | } |
| 2394 | + nLabeled = COUNT_FOOTNOTES(&rndr.notes); | |
| 2378 | 2395 | /* sorting the footnotes array by id */ |
| 2379 | - if( blob_size(&rndr.footnotes) ){ | |
| 2380 | - qsort(blob_buffer(&rndr.footnotes), | |
| 2381 | - blob_size(&rndr.footnotes)/sizeof(struct footnote), | |
| 2382 | - sizeof(struct footnote), | |
| 2396 | + if( nLabeled ){ | |
| 2397 | + qsort(blob_buffer(&rndr.notes), nLabeled, sizeof(struct footnote), | |
| 2383 | 2398 | cmp_link_ref_sort); |
| 2384 | 2399 | } |
| 2385 | 2400 | |
| 2386 | 2401 | /* second pass: actual rendering */ |
| 2387 | 2402 | if( rndr.make.prolog ) rndr.make.prolog(ob, rndr.make.opaque); |
| 2388 | 2403 | parse_block(ob, &rndr, blob_buffer(&text), blob_size(&text)); |
| 2389 | 2404 | |
| 2390 | - /* sorting the footnotes array by index */ | |
| 2391 | - if( blob_size(&rndr.footnotes) ){ | |
| 2392 | - qsort(blob_buffer(&rndr.footnotes), | |
| 2393 | - blob_size(&rndr.footnotes)/sizeof(struct footnote), | |
| 2394 | - sizeof(struct footnote), | |
| 2395 | - cmp_footnote_sort); | |
| 2396 | - } | |
| 2397 | - /* FIXME: decouple parsing and HTML-specific rendering of footnotes */ | |
| 2398 | - if( rndr.nLabels ){ | |
| 2399 | - fn = (struct footnote *)blob_buffer(&rndr.footnotes); | |
| 2400 | - end = blob_size(&rndr.footnotes)/sizeof(struct footnote); | |
| 2401 | - blob_appendf(ob, "\n<ol class='footnotes'>\n"); | |
| 2402 | - for(i=0; i<end; i++){ | |
| 2403 | - if(fn[i].index == 0) continue; | |
| 2404 | - blob_appendf(ob, "<li id='footnote-%i'>\n ", fn[i].index ); | |
| 2405 | - parse_inline(ob,&rndr,blob_buffer(&fn[i].text),blob_size(&fn[i].text)); | |
| 2406 | - blob_append(ob,"\n</li>\n",7); | |
| 2407 | - } | |
| 2408 | - blob_append(ob, "</ol>\n", 7); | |
| 2405 | + fn = (struct footnote*)blob_buffer(&rndr.notes); | |
| 2406 | + if(rndr.iNotesCount && rndr.make.footnote_item && rndr.make.footnotes){ | |
| 2407 | + Blob * one_item = new_work_buffer(&rndr); | |
| 2408 | + Blob * all_items = new_work_buffer(&rndr); | |
| 2409 | + qsort( fn, COUNT_FOOTNOTES(&rndr.notes), sizeof(struct footnote), | |
| 2410 | + cmp_footnote_sort /* sort footnotes by index */ ); | |
| 2411 | + blob_reset( all_items ); | |
| 2412 | + for(i=0; i<rndr.iNotesCount; i++){ | |
| 2413 | + assert( fn[i].index == i+1 ); | |
| 2414 | + | |
| 2415 | + blob_reset( one_item ); | |
| 2416 | + parse_inline( one_item, &rndr, blob_buffer(&fn[i].text), | |
| 2417 | + blob_size(&fn[i].text)); | |
| 2418 | + rndr.make.footnote_item( all_items, one_item, i+1, fn[i].nUsed, rndr.make.opaque); | |
| 2419 | + } | |
| 2420 | + rndr.make.footnotes(ob, all_items, rndr.make.opaque ); | |
| 2421 | + release_work_buffer( &rndr, one_item ); | |
| 2422 | + release_work_buffer( &rndr, all_items ); | |
| 2409 | 2423 | } |
| 2410 | 2424 | if( rndr.make.epilog ) rndr.make.epilog(ob, rndr.make.opaque); |
| 2411 | 2425 | |
| 2412 | 2426 | /* clean-up */ |
| 2413 | 2427 | assert( rndr.iDepth==0 ); |
| @@ -2418,9 +2432,15 @@ | ||
| 2418 | 2432 | blob_reset(&lr[i].id); |
| 2419 | 2433 | blob_reset(&lr[i].link); |
| 2420 | 2434 | blob_reset(&lr[i].title); |
| 2421 | 2435 | } |
| 2422 | 2436 | blob_reset(&rndr.refs); |
| 2437 | + end = COUNT_FOOTNOTES(&rndr.notes); | |
| 2438 | + for(i=0; i<end; i++){ | |
| 2439 | + blob_reset(&fn[i].id); | |
| 2440 | + blob_reset(&fn[i].text); | |
| 2441 | + } | |
| 2442 | + blob_reset(&rndr.notes); | |
| 2423 | 2443 | for(i=0; i<rndr.nBlobCache; i++){ |
| 2424 | 2444 | fossil_free(rndr.aBlobCache[i]); |
| 2425 | 2445 | } |
| 2426 | 2446 | } |
| 2427 | 2447 |
| --- src/markdown.c | |
| +++ src/markdown.c | |
| @@ -45,10 +45,11 @@ | |
| 45 | /* mkd_renderer -- functions for rendering parsed data */ |
| 46 | struct mkd_renderer { |
| 47 | /* document level callbacks */ |
| 48 | void (*prolog)(struct Blob *ob, void *opaque); |
| 49 | void (*epilog)(struct Blob *ob, void *opaque); |
| 50 | |
| 51 | /* block level callbacks - NULL skips the block */ |
| 52 | void (*blockcode)(struct Blob *ob, struct Blob *text, void *opaque); |
| 53 | void (*blockquote)(struct Blob *ob, struct Blob *text, void *opaque); |
| 54 | void (*blockhtml)(struct Blob *ob, struct Blob *text, void *opaque); |
| @@ -63,10 +64,12 @@ | |
| 63 | void *opaque); |
| 64 | void (*table_cell)(struct Blob *ob, struct Blob *text, int flags, |
| 65 | void *opaque); |
| 66 | void (*table_row)(struct Blob *ob, struct Blob *cells, int flags, |
| 67 | void *opaque); |
| 68 | |
| 69 | /* span level callbacks - NULL or return 0 prints the span verbatim */ |
| 70 | int (*autolink)(struct Blob *ob, struct Blob *link, |
| 71 | enum mkd_autolink type, void *opaque); |
| 72 | int (*codespan)(struct Blob *ob, struct Blob *text, int nSep, void *opaque); |
| @@ -79,10 +82,11 @@ | |
| 79 | int (*link)(struct Blob *ob, struct Blob *link, struct Blob *title, |
| 80 | struct Blob *content, void *opaque); |
| 81 | int (*raw_html_tag)(struct Blob *ob, struct Blob *tag, void *opaque); |
| 82 | int (*triple_emphasis)(struct Blob *ob, struct Blob *text, |
| 83 | char c, void *opaque); |
| 84 | |
| 85 | /* low level callbacks - NULL copies input directly into the output */ |
| 86 | void (*entity)(struct Blob *ob, struct Blob *entity, void *opaque); |
| 87 | void (*normal_text)(struct Blob *ob, struct Blob *text, void *opaque); |
| 88 | |
| @@ -122,10 +126,12 @@ | |
| 122 | const struct mkd_renderer *rndr); |
| 123 | |
| 124 | |
| 125 | #endif /* INTERFACE */ |
| 126 | |
| 127 | |
| 128 | /*************** |
| 129 | * LOCAL TYPES * |
| 130 | ***************/ |
| 131 | |
| @@ -138,10 +144,11 @@ | |
| 138 | |
| 139 | struct footnote { |
| 140 | struct Blob id; /* must be the first field as in link_ref struct */ |
| 141 | struct Blob text; /* footnote's content that is rendered at the end */ |
| 142 | int index; /* serial number, in the order of appearance */ |
| 143 | }; |
| 144 | |
| 145 | |
| 146 | /* char_trigger -- function pointer to render active chars */ |
| 147 | /* returns the number of chars taken care of */ |
| @@ -158,16 +165,17 @@ | |
| 158 | |
| 159 | /* render -- structure containing one particular render */ |
| 160 | struct render { |
| 161 | struct mkd_renderer make; |
| 162 | struct Blob refs; |
| 163 | struct Blob footnotes; |
| 164 | char_trigger active_char[256]; |
| 165 | int iDepth; /* Depth of recursion */ |
| 166 | int nBlobCache; /* Number of entries in aBlobCache */ |
| 167 | struct Blob *aBlobCache[20]; /* Cache of Blobs available for reuse */ |
| 168 | int nLabels; /* Footnotes counter for the second pass */ |
| 169 | }; |
| 170 | |
| 171 | /* html_tag -- structure for quick HTML tag search (inspired from discount) */ |
| 172 | struct html_tag { |
| 173 | const char *text; |
| @@ -254,15 +262,18 @@ | |
| 254 | struct link_ref *lra = (void *)a; |
| 255 | struct link_ref *lrb = (void *)b; |
| 256 | return blob_compare(&lra->id, &lrb->id); |
| 257 | } |
| 258 | |
| 259 | /* cmp_footnote_sort -- comparison function for footnotes qsort */ |
| 260 | static int cmp_footnote_sort(const void *a, const void *b){ |
| 261 | const struct footnote *fna = (void *)a, *fnb = (void *)b; |
| 262 | assert( fna->index > 0 && fnb->index > 0 ); |
| 263 | if( fna->index == fnb->index ) return 0; |
| 264 | return ( fna->index < fnb->index ? -1 : 1 ); |
| 265 | } |
| 266 | |
| 267 | /* cmp_html_tag -- comparison function for bsearch() (stolen from discount) */ |
| 268 | static int cmp_html_tag(const void *a, const void *b){ |
| @@ -1017,38 +1028,37 @@ | |
| 1017 | blob_append(link, blob_buffer(&lr->link), blob_size(&lr->link)); |
| 1018 | blob_append(title, blob_buffer(&lr->title), blob_size(&lr->title)); |
| 1019 | return 0; |
| 1020 | } |
| 1021 | |
| 1022 | /* get_footnote -- resolve footnote by its id |
| 1023 | * on success: fill text and return positive footnote's index |
| 1024 | * on failure: return -1 */ |
| 1025 | static int get_footnote( |
| 1026 | struct render *rndr, |
| 1027 | struct Blob *text, |
| 1028 | const char *data, |
| 1029 | size_t size |
| 1030 | ){ |
| 1031 | struct footnote *fn; |
| 1032 | |
| 1033 | blob_reset(text); /* use text for temporary storage */ |
| 1034 | if( build_ref_id(text, data, size)<0 ) return -1; |
| 1035 | |
| 1036 | fn = bsearch(text, |
| 1037 | blob_buffer(&rndr->footnotes), |
| 1038 | blob_size(&rndr->footnotes)/sizeof(struct footnote), |
| 1039 | sizeof (struct footnote), |
| 1040 | cmp_link_ref); |
| 1041 | if( !fn ) return -1; |
| 1042 | |
| 1043 | if( fn->index == 0 ){ /* the first reference to the footnote */ |
| 1044 | fn->index = ++(rndr->nLabels); |
| 1045 | } |
| 1046 | assert( fn->index > 0 ); |
| 1047 | blob_reset(text); |
| 1048 | blob_append(text, blob_buffer(&fn->text), blob_size(&fn->text)); |
| 1049 | return fn->index; |
| 1050 | } |
| 1051 | |
| 1052 | /* char_link -- '[': parsing a link or an image */ |
| 1053 | static size_t char_link( |
| 1054 | struct Blob *ob, |
| @@ -1055,17 +1065,19 @@ | |
| 1055 | struct render *rndr, |
| 1056 | char *data, |
| 1057 | size_t offset, |
| 1058 | size_t size |
| 1059 | ){ |
| 1060 | int is_img = (offset && data[-1] == '!'), level; |
| 1061 | size_t i = 1, txt_e; |
| 1062 | struct Blob *content = 0; |
| 1063 | struct Blob *link = 0; |
| 1064 | struct Blob *title = 0; |
| 1065 | const int is_note = (size && data[1] == '^'); |
| 1066 | int ret; |
| 1067 | |
| 1068 | /* checking whether the correct renderer exists */ |
| 1069 | if( (is_img && !rndr->make.image) || (!is_img && !rndr->make.link) ){ |
| 1070 | return 0; |
| 1071 | } |
| @@ -1135,17 +1147,16 @@ | |
| 1135 | i = id_end+1; |
| 1136 | |
| 1137 | /* shortcut reference style link */ |
| 1138 | }else{ |
| 1139 | if( is_note ){ |
| 1140 | const int lbl = get_footnote(rndr, link, data+1, txt_e-1); |
| 1141 | if( lbl <= 0 ){ |
| 1142 | goto char_link_cleanup; |
| 1143 | } |
| 1144 | blob_reset(link); |
| 1145 | blob_appendf(link, "#footnote-%i", lbl); |
| 1146 | blob_appendf(content,"<sup class='footnote'>%i</sup>",lbl); |
| 1147 | }else if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){ |
| 1148 | goto char_link_cleanup; |
| 1149 | } |
| 1150 | |
| 1151 | /* rewinding the whitespace */ |
| @@ -1153,17 +1164,21 @@ | |
| 1153 | } |
| 1154 | |
| 1155 | /* building content: img alt is escaped, link content is parsed */ |
| 1156 | if( txt_e>1 ){ |
| 1157 | if( is_img ) blob_append(content, data+1, txt_e-1); |
| 1158 | else if(!is_note) parse_inline(content, rndr, data+1, txt_e-1); |
| 1159 | } |
| 1160 | |
| 1161 | /* calling the relevant rendering function */ |
| 1162 | if( is_img ){ |
| 1163 | if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--; |
| 1164 | ret = rndr->make.image(ob, link, title, content, rndr->make.opaque); |
| 1165 | }else{ |
| 1166 | ret = rndr->make.link(ob, link, title, content, rndr->make.opaque); |
| 1167 | } |
| 1168 | |
| 1169 | /* cleanup */ |
| @@ -2250,11 +2265,11 @@ | |
| 2250 | ){ |
| 2251 | size_t i = 0; |
| 2252 | size_t id_offset, id_end; |
| 2253 | size_t note_offset, note_end; |
| 2254 | size_t line_end; |
| 2255 | struct footnote fn = { empty_blob, empty_blob, 0 }; |
| 2256 | |
| 2257 | /* footnote definition must start at the begining of a line */ |
| 2258 | if( beg+4>=end ) return 0; |
| 2259 | i += beg; |
| 2260 | |
| @@ -2311,20 +2326,21 @@ | |
| 2311 | ){ |
| 2312 | struct link_ref *lr; |
| 2313 | struct footnote *fn; |
| 2314 | size_t i, beg, end = 0; |
| 2315 | struct render rndr; |
| 2316 | Blob text = BLOB_INITIALIZER; /* input after the first pass */ |
| 2317 | |
| 2318 | /* filling the render structure */ |
| 2319 | if( !rndrer ) return; |
| 2320 | rndr.make = *rndrer; |
| 2321 | rndr.nBlobCache = 0; |
| 2322 | rndr.iDepth = 0; |
| 2323 | rndr.refs = empty_blob; |
| 2324 | rndr.footnotes = empty_blob; |
| 2325 | rndr.nLabels = 0; |
| 2326 | for(i=0; i<256; i++) rndr.active_char[i] = 0; |
| 2327 | if( (rndr.make.emphasis |
| 2328 | || rndr.make.double_emphasis |
| 2329 | || rndr.make.triple_emphasis) |
| 2330 | && rndr.make.emph_chars |
| @@ -2345,11 +2361,11 @@ | |
| 2345 | beg = 0; |
| 2346 | for(const size_t size = blob_size(ib); beg<size ;){ |
| 2347 | const char* const data = blob_buffer(ib); |
| 2348 | if( is_ref(data, beg, size, &end, &rndr.refs) ){ |
| 2349 | beg = end; |
| 2350 | }else if( is_footnote(data, beg, size, &end, &rndr.footnotes) ){ |
| 2351 | /* FIXME: fossil_print("\nfootnote found at %i\n", beg); */ |
| 2352 | beg = end; |
| 2353 | }else{ /* skipping to the next line */ |
| 2354 | end = beg; |
| 2355 | while( end<size && data[end]!='\n' && data[end]!='\r' ){ |
| @@ -2373,41 +2389,39 @@ | |
| 2373 | qsort(blob_buffer(&rndr.refs), |
| 2374 | blob_size(&rndr.refs)/sizeof(struct link_ref), |
| 2375 | sizeof(struct link_ref), |
| 2376 | cmp_link_ref_sort); |
| 2377 | } |
| 2378 | /* sorting the footnotes array by id */ |
| 2379 | if( blob_size(&rndr.footnotes) ){ |
| 2380 | qsort(blob_buffer(&rndr.footnotes), |
| 2381 | blob_size(&rndr.footnotes)/sizeof(struct footnote), |
| 2382 | sizeof(struct footnote), |
| 2383 | cmp_link_ref_sort); |
| 2384 | } |
| 2385 | |
| 2386 | /* second pass: actual rendering */ |
| 2387 | if( rndr.make.prolog ) rndr.make.prolog(ob, rndr.make.opaque); |
| 2388 | parse_block(ob, &rndr, blob_buffer(&text), blob_size(&text)); |
| 2389 | |
| 2390 | /* sorting the footnotes array by index */ |
| 2391 | if( blob_size(&rndr.footnotes) ){ |
| 2392 | qsort(blob_buffer(&rndr.footnotes), |
| 2393 | blob_size(&rndr.footnotes)/sizeof(struct footnote), |
| 2394 | sizeof(struct footnote), |
| 2395 | cmp_footnote_sort); |
| 2396 | } |
| 2397 | /* FIXME: decouple parsing and HTML-specific rendering of footnotes */ |
| 2398 | if( rndr.nLabels ){ |
| 2399 | fn = (struct footnote *)blob_buffer(&rndr.footnotes); |
| 2400 | end = blob_size(&rndr.footnotes)/sizeof(struct footnote); |
| 2401 | blob_appendf(ob, "\n<ol class='footnotes'>\n"); |
| 2402 | for(i=0; i<end; i++){ |
| 2403 | if(fn[i].index == 0) continue; |
| 2404 | blob_appendf(ob, "<li id='footnote-%i'>\n ", fn[i].index ); |
| 2405 | parse_inline(ob,&rndr,blob_buffer(&fn[i].text),blob_size(&fn[i].text)); |
| 2406 | blob_append(ob,"\n</li>\n",7); |
| 2407 | } |
| 2408 | blob_append(ob, "</ol>\n", 7); |
| 2409 | } |
| 2410 | if( rndr.make.epilog ) rndr.make.epilog(ob, rndr.make.opaque); |
| 2411 | |
| 2412 | /* clean-up */ |
| 2413 | assert( rndr.iDepth==0 ); |
| @@ -2418,9 +2432,15 @@ | |
| 2418 | blob_reset(&lr[i].id); |
| 2419 | blob_reset(&lr[i].link); |
| 2420 | blob_reset(&lr[i].title); |
| 2421 | } |
| 2422 | blob_reset(&rndr.refs); |
| 2423 | for(i=0; i<rndr.nBlobCache; i++){ |
| 2424 | fossil_free(rndr.aBlobCache[i]); |
| 2425 | } |
| 2426 | } |
| 2427 |
| --- src/markdown.c | |
| +++ src/markdown.c | |
| @@ -45,10 +45,11 @@ | |
| 45 | /* mkd_renderer -- functions for rendering parsed data */ |
| 46 | struct mkd_renderer { |
| 47 | /* document level callbacks */ |
| 48 | void (*prolog)(struct Blob *ob, void *opaque); |
| 49 | void (*epilog)(struct Blob *ob, void *opaque); |
| 50 | void (*footnotes)(struct Blob *ob, const struct Blob *items, void *opaque); |
| 51 | |
| 52 | /* block level callbacks - NULL skips the block */ |
| 53 | void (*blockcode)(struct Blob *ob, struct Blob *text, void *opaque); |
| 54 | void (*blockquote)(struct Blob *ob, struct Blob *text, void *opaque); |
| 55 | void (*blockhtml)(struct Blob *ob, struct Blob *text, void *opaque); |
| @@ -63,10 +64,12 @@ | |
| 64 | void *opaque); |
| 65 | void (*table_cell)(struct Blob *ob, struct Blob *text, int flags, |
| 66 | void *opaque); |
| 67 | void (*table_row)(struct Blob *ob, struct Blob *cells, int flags, |
| 68 | void *opaque); |
| 69 | void (*footnote_item)(struct Blob *ob, const struct Blob *text, |
| 70 | int index, int nUsed, void *opaque); |
| 71 | |
| 72 | /* span level callbacks - NULL or return 0 prints the span verbatim */ |
| 73 | int (*autolink)(struct Blob *ob, struct Blob *link, |
| 74 | enum mkd_autolink type, void *opaque); |
| 75 | int (*codespan)(struct Blob *ob, struct Blob *text, int nSep, void *opaque); |
| @@ -79,10 +82,11 @@ | |
| 82 | int (*link)(struct Blob *ob, struct Blob *link, struct Blob *title, |
| 83 | struct Blob *content, void *opaque); |
| 84 | int (*raw_html_tag)(struct Blob *ob, struct Blob *tag, void *opaque); |
| 85 | int (*triple_emphasis)(struct Blob *ob, struct Blob *text, |
| 86 | char c, void *opaque); |
| 87 | int (*footnote_ref)(struct Blob *ob, int index, int locus, void *opaque); |
| 88 | |
| 89 | /* low level callbacks - NULL copies input directly into the output */ |
| 90 | void (*entity)(struct Blob *ob, struct Blob *entity, void *opaque); |
| 91 | void (*normal_text)(struct Blob *ob, struct Blob *text, void *opaque); |
| 92 | |
| @@ -122,10 +126,12 @@ | |
| 126 | const struct mkd_renderer *rndr); |
| 127 | |
| 128 | |
| 129 | #endif /* INTERFACE */ |
| 130 | |
| 131 | #define BLOB_COUNT(blob_ptr,el_type) (blob_size(blob_ptr)/sizeof(el_type)) |
| 132 | #define COUNT_FOOTNOTES(blob_ptr) BLOB_COUNT(blob_ptr,struct footnote) |
| 133 | |
| 134 | /*************** |
| 135 | * LOCAL TYPES * |
| 136 | ***************/ |
| 137 | |
| @@ -138,10 +144,11 @@ | |
| 144 | |
| 145 | struct footnote { |
| 146 | struct Blob id; /* must be the first field as in link_ref struct */ |
| 147 | struct Blob text; /* footnote's content that is rendered at the end */ |
| 148 | int index; /* serial number, in the order of appearance */ |
| 149 | int nUsed; /* number of references to this note */ |
| 150 | }; |
| 151 | |
| 152 | |
| 153 | /* char_trigger -- function pointer to render active chars */ |
| 154 | /* returns the number of chars taken care of */ |
| @@ -158,16 +165,17 @@ | |
| 165 | |
| 166 | /* render -- structure containing one particular render */ |
| 167 | struct render { |
| 168 | struct mkd_renderer make; |
| 169 | struct Blob refs; |
| 170 | char_trigger active_char[256]; |
| 171 | int iDepth; /* Depth of recursion */ |
| 172 | int nBlobCache; /* Number of entries in aBlobCache */ |
| 173 | struct Blob *aBlobCache[20]; /* Cache of Blobs available for reuse */ |
| 174 | |
| 175 | struct Blob notes; /* array of footnotes */ |
| 176 | int iNotesCount; /* count distinct indices found in the second pass */ |
| 177 | }; |
| 178 | |
| 179 | /* html_tag -- structure for quick HTML tag search (inspired from discount) */ |
| 180 | struct html_tag { |
| 181 | const char *text; |
| @@ -254,15 +262,18 @@ | |
| 262 | struct link_ref *lra = (void *)a; |
| 263 | struct link_ref *lrb = (void *)b; |
| 264 | return blob_compare(&lra->id, &lrb->id); |
| 265 | } |
| 266 | |
| 267 | /* cmp_footnote_sort -- comparison function for footnotes qsort. |
| 268 | * Unused footnotes (when index == 0) sort last */ |
| 269 | static int cmp_footnote_sort(const void *a, const void *b){ |
| 270 | const struct footnote *fna = (void *)a, *fnb = (void *)b; |
| 271 | assert( fna->index >= 0 && fnb->index >= 0 ); |
| 272 | if( fna->index == fnb->index ) return 0; |
| 273 | if( fna->index == 0 ) return 1; |
| 274 | if( fnb->index == 0 ) return -1; |
| 275 | return ( fna->index < fnb->index ? -1 : 1 ); |
| 276 | } |
| 277 | |
| 278 | /* cmp_html_tag -- comparison function for bsearch() (stolen from discount) */ |
| 279 | static int cmp_html_tag(const void *a, const void *b){ |
| @@ -1017,38 +1028,37 @@ | |
| 1028 | blob_append(link, blob_buffer(&lr->link), blob_size(&lr->link)); |
| 1029 | blob_append(title, blob_buffer(&lr->title), blob_size(&lr->title)); |
| 1030 | return 0; |
| 1031 | } |
| 1032 | |
| 1033 | /* get_footnote() is invoked during the second pass |
| 1034 | * on success: fill text and return positive footnote's index |
| 1035 | * on failure: return -1 */ |
| 1036 | static const struct footnote* get_footnote( |
| 1037 | struct render *rndr, |
| 1038 | const char *data, |
| 1039 | size_t size |
| 1040 | ){ |
| 1041 | struct footnote *fn = NULL; |
| 1042 | struct Blob *id = new_work_buffer(rndr); |
| 1043 | if( build_ref_id(id, data, size)<0 ) goto cleanup; |
| 1044 | fn = bsearch(id, blob_buffer(&rndr->notes), |
| 1045 | COUNT_FOOTNOTES(&rndr->notes), |
| 1046 | sizeof (struct footnote), |
| 1047 | cmp_link_ref); |
| 1048 | if( !fn ) goto cleanup; |
| 1049 | |
| 1050 | if( fn->index == 0 ){ /* the first reference to the footnote */ |
| 1051 | assert( fn->nUsed == 0 ); |
| 1052 | fn->index = ++(rndr->iNotesCount); |
| 1053 | } |
| 1054 | fn->nUsed++; |
| 1055 | assert( fn->index > 0 ); |
| 1056 | assert( fn->nUsed > 0 ); |
| 1057 | cleanup: |
| 1058 | release_work_buffer( rndr, id ); |
| 1059 | return fn; |
| 1060 | } |
| 1061 | |
| 1062 | /* char_link -- '[': parsing a link or an image */ |
| 1063 | static size_t char_link( |
| 1064 | struct Blob *ob, |
| @@ -1055,17 +1065,19 @@ | |
| 1065 | struct render *rndr, |
| 1066 | char *data, |
| 1067 | size_t offset, |
| 1068 | size_t size |
| 1069 | ){ |
| 1070 | const int is_img = (offset && data[-1] == '!'); |
| 1071 | const int is_inline = (offset && data[-1]=='^'); |
| 1072 | const int is_note = !is_img && (is_inline || (size>1 && data[1]=='^')); |
| 1073 | size_t i = 1, txt_e; |
| 1074 | struct Blob *content = 0; |
| 1075 | struct Blob *link = 0; |
| 1076 | struct Blob *title = 0; |
| 1077 | const struct footnote *fn = 0; |
| 1078 | int level, ret; |
| 1079 | |
| 1080 | /* checking whether the correct renderer exists */ |
| 1081 | if( (is_img && !rndr->make.image) || (!is_img && !rndr->make.link) ){ |
| 1082 | return 0; |
| 1083 | } |
| @@ -1135,17 +1147,16 @@ | |
| 1147 | i = id_end+1; |
| 1148 | |
| 1149 | /* shortcut reference style link */ |
| 1150 | }else{ |
| 1151 | if( is_note ){ |
| 1152 | if( is_inline ){ |
| 1153 | //fn = put_footnote(rndr, data+1, txt_e-1); |
| 1154 | }else{ |
| 1155 | fn = get_footnote(rndr, data+1, txt_e-1); |
| 1156 | } |
| 1157 | if( !fn ) goto char_link_cleanup; |
| 1158 | }else if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){ |
| 1159 | goto char_link_cleanup; |
| 1160 | } |
| 1161 | |
| 1162 | /* rewinding the whitespace */ |
| @@ -1153,17 +1164,21 @@ | |
| 1164 | } |
| 1165 | |
| 1166 | /* building content: img alt is escaped, link content is parsed */ |
| 1167 | if( txt_e>1 ){ |
| 1168 | if( is_img ) blob_append(content, data+1, txt_e-1); |
| 1169 | else if(is_inline) parse_inline(content, rndr, data+1, txt_e-1); |
| 1170 | } |
| 1171 | |
| 1172 | /* calling the relevant rendering function */ |
| 1173 | if( is_img ){ |
| 1174 | if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--; |
| 1175 | ret = rndr->make.image(ob, link, title, content, rndr->make.opaque); |
| 1176 | }else if(fn){ |
| 1177 | if(rndr->make.footnote_ref){ |
| 1178 | ret = rndr->make.footnote_ref(ob,fn->index,fn->nUsed,rndr->make.opaque); |
| 1179 | } |
| 1180 | }else{ |
| 1181 | ret = rndr->make.link(ob, link, title, content, rndr->make.opaque); |
| 1182 | } |
| 1183 | |
| 1184 | /* cleanup */ |
| @@ -2250,11 +2265,11 @@ | |
| 2265 | ){ |
| 2266 | size_t i = 0; |
| 2267 | size_t id_offset, id_end; |
| 2268 | size_t note_offset, note_end; |
| 2269 | size_t line_end; |
| 2270 | struct footnote fn = { empty_blob, empty_blob, 0, 0 }; |
| 2271 | |
| 2272 | /* footnote definition must start at the begining of a line */ |
| 2273 | if( beg+4>=end ) return 0; |
| 2274 | i += beg; |
| 2275 | |
| @@ -2311,20 +2326,21 @@ | |
| 2326 | ){ |
| 2327 | struct link_ref *lr; |
| 2328 | struct footnote *fn; |
| 2329 | size_t i, beg, end = 0; |
| 2330 | struct render rndr; |
| 2331 | Blob text = BLOB_INITIALIZER; /* input after the first pass */ |
| 2332 | int nLabeled; /* number of footnotes found by the first pass */ |
| 2333 | |
| 2334 | /* filling the render structure */ |
| 2335 | if( !rndrer ) return; |
| 2336 | rndr.make = *rndrer; |
| 2337 | rndr.nBlobCache = 0; |
| 2338 | rndr.iDepth = 0; |
| 2339 | rndr.refs = empty_blob; |
| 2340 | rndr.notes = empty_blob; |
| 2341 | rndr.iNotesCount = 0; |
| 2342 | for(i=0; i<256; i++) rndr.active_char[i] = 0; |
| 2343 | if( (rndr.make.emphasis |
| 2344 | || rndr.make.double_emphasis |
| 2345 | || rndr.make.triple_emphasis) |
| 2346 | && rndr.make.emph_chars |
| @@ -2345,11 +2361,11 @@ | |
| 2361 | beg = 0; |
| 2362 | for(const size_t size = blob_size(ib); beg<size ;){ |
| 2363 | const char* const data = blob_buffer(ib); |
| 2364 | if( is_ref(data, beg, size, &end, &rndr.refs) ){ |
| 2365 | beg = end; |
| 2366 | }else if(is_footnote(data, beg, size, &end, &rndr.notes)){ |
| 2367 | /* FIXME: fossil_print("\nfootnote found at %i\n", beg); */ |
| 2368 | beg = end; |
| 2369 | }else{ /* skipping to the next line */ |
| 2370 | end = beg; |
| 2371 | while( end<size && data[end]!='\n' && data[end]!='\r' ){ |
| @@ -2373,41 +2389,39 @@ | |
| 2389 | qsort(blob_buffer(&rndr.refs), |
| 2390 | blob_size(&rndr.refs)/sizeof(struct link_ref), |
| 2391 | sizeof(struct link_ref), |
| 2392 | cmp_link_ref_sort); |
| 2393 | } |
| 2394 | nLabeled = COUNT_FOOTNOTES(&rndr.notes); |
| 2395 | /* sorting the footnotes array by id */ |
| 2396 | if( nLabeled ){ |
| 2397 | qsort(blob_buffer(&rndr.notes), nLabeled, sizeof(struct footnote), |
| 2398 | cmp_link_ref_sort); |
| 2399 | } |
| 2400 | |
| 2401 | /* second pass: actual rendering */ |
| 2402 | if( rndr.make.prolog ) rndr.make.prolog(ob, rndr.make.opaque); |
| 2403 | parse_block(ob, &rndr, blob_buffer(&text), blob_size(&text)); |
| 2404 | |
| 2405 | fn = (struct footnote*)blob_buffer(&rndr.notes); |
| 2406 | if(rndr.iNotesCount && rndr.make.footnote_item && rndr.make.footnotes){ |
| 2407 | Blob * one_item = new_work_buffer(&rndr); |
| 2408 | Blob * all_items = new_work_buffer(&rndr); |
| 2409 | qsort( fn, COUNT_FOOTNOTES(&rndr.notes), sizeof(struct footnote), |
| 2410 | cmp_footnote_sort /* sort footnotes by index */ ); |
| 2411 | blob_reset( all_items ); |
| 2412 | for(i=0; i<rndr.iNotesCount; i++){ |
| 2413 | assert( fn[i].index == i+1 ); |
| 2414 | |
| 2415 | blob_reset( one_item ); |
| 2416 | parse_inline( one_item, &rndr, blob_buffer(&fn[i].text), |
| 2417 | blob_size(&fn[i].text)); |
| 2418 | rndr.make.footnote_item( all_items, one_item, i+1, fn[i].nUsed, rndr.make.opaque); |
| 2419 | } |
| 2420 | rndr.make.footnotes(ob, all_items, rndr.make.opaque ); |
| 2421 | release_work_buffer( &rndr, one_item ); |
| 2422 | release_work_buffer( &rndr, all_items ); |
| 2423 | } |
| 2424 | if( rndr.make.epilog ) rndr.make.epilog(ob, rndr.make.opaque); |
| 2425 | |
| 2426 | /* clean-up */ |
| 2427 | assert( rndr.iDepth==0 ); |
| @@ -2418,9 +2432,15 @@ | |
| 2432 | blob_reset(&lr[i].id); |
| 2433 | blob_reset(&lr[i].link); |
| 2434 | blob_reset(&lr[i].title); |
| 2435 | } |
| 2436 | blob_reset(&rndr.refs); |
| 2437 | end = COUNT_FOOTNOTES(&rndr.notes); |
| 2438 | for(i=0; i<end; i++){ |
| 2439 | blob_reset(&fn[i].id); |
| 2440 | blob_reset(&fn[i].text); |
| 2441 | } |
| 2442 | blob_reset(&rndr.notes); |
| 2443 | for(i=0; i<rndr.nBlobCache; i++){ |
| 2444 | fossil_free(rndr.aBlobCache[i]); |
| 2445 | } |
| 2446 | } |
| 2447 |
+91
| --- src/markdown_html.c | ||
| +++ src/markdown_html.c | ||
| @@ -29,17 +29,20 @@ | ||
| 29 | 29 | struct Blob *output_title, |
| 30 | 30 | struct Blob *output_body); |
| 31 | 31 | |
| 32 | 32 | #endif /* INTERFACE */ |
| 33 | 33 | |
| 34 | +typedef union { uint64_t u; char c[8]; unsigned char b[8]; } bitfield64_t; | |
| 35 | + | |
| 34 | 36 | /* |
| 35 | 37 | ** An instance of the following structure is passed through the |
| 36 | 38 | ** "opaque" pointer. |
| 37 | 39 | */ |
| 38 | 40 | typedef struct MarkdownToHtml MarkdownToHtml; |
| 39 | 41 | struct MarkdownToHtml { |
| 40 | 42 | Blob *output_title; /* Store the title here */ |
| 43 | + bitfield64_t unique; /* Enables construction of unique #id elements */ | |
| 41 | 44 | }; |
| 42 | 45 | |
| 43 | 46 | |
| 44 | 47 | /* INTER_BLOCK -- skip a line between block level elements */ |
| 45 | 48 | #define INTER_BLOCK(ob) \ |
| @@ -56,10 +59,26 @@ | ||
| 56 | 59 | |
| 57 | 60 | /* BLOB_APPEND_BLOB -- append blob contents to another */ |
| 58 | 61 | #define BLOB_APPEND_BLOB(dest, src) \ |
| 59 | 62 | blob_append((dest), blob_buffer(src), blob_size(src)) |
| 60 | 63 | |
| 64 | +/* Converts an integer to a null-terminated base26 representation | |
| 65 | + * Return empty string if that integer is negative. */ | |
| 66 | +static bitfield64_t to_base26(int i, int uppercase){ | |
| 67 | + bitfield64_t x; | |
| 68 | + int j; | |
| 69 | + x.u = 0; | |
| 70 | + if( i >= 0 ){ | |
| 71 | + for(j=7; j >= 0; j--){ | |
| 72 | + x.b[j] = (unsigned char)(uppercase?'A':'a') + i%26; | |
| 73 | + if( (i /= 26) == 0 ) break; | |
| 74 | + } | |
| 75 | + x.u >>= 8*j; | |
| 76 | + } | |
| 77 | + x.c[7] = 0; | |
| 78 | + return x; | |
| 79 | +} | |
| 61 | 80 | |
| 62 | 81 | /* HTML escapes |
| 63 | 82 | ** |
| 64 | 83 | ** html_escape() converts < to <, > to >, and & to &. |
| 65 | 84 | ** html_quote() goes further and converts " into " and ' in '. |
| @@ -303,11 +322,78 @@ | ||
| 303 | 322 | BLOB_APPEND_LITERAL(ob, " <tr>\n"); |
| 304 | 323 | BLOB_APPEND_BLOB(ob, cells); |
| 305 | 324 | BLOB_APPEND_LITERAL(ob, " </tr>\n"); |
| 306 | 325 | } |
| 307 | 326 | |
| 327 | +static int html_footnote_ref( | |
| 328 | + struct Blob *ob, int index, int locus, void *opaque | |
| 329 | +){ | |
| 330 | + const struct MarkdownToHtml *ctx = (struct MarkdownToHtml*)opaque; | |
| 331 | + const bitfield64_t l = to_base26(locus-1,0); | |
| 332 | + char pos[32]; | |
| 333 | + | |
| 334 | + /* expect BUGs if the following yields compiler warnings */ | |
| 335 | + memset(pos,0,32); | |
| 336 | + sprintf(pos, "%s%i-%s", ctx->unique.c, index, l.c); | |
| 337 | + | |
| 338 | + BLOB_APPEND_LITERAL(ob,"<a class='noteref' href='#footnote-"); | |
| 339 | + blob_appendf(ob,"%s' id='noteref-%s'><sup>%i</sup></a>", | |
| 340 | + pos, pos, index); | |
| 341 | + return 1; | |
| 342 | +} | |
| 343 | + | |
| 344 | +/* Render a single item of the footnotes list. | |
| 345 | + * Each backref gets a unique id to enable dynamic styling. */ | |
| 346 | +static void html_footnote_item( | |
| 347 | + struct Blob *ob, const struct Blob *text, int index, int nUsed, void *opaque | |
| 348 | +){ | |
| 349 | + const struct MarkdownToHtml *ctx = (struct MarkdownToHtml*)opaque; | |
| 350 | + char pos[24]; | |
| 351 | + if( index <= 0 || nUsed < 0 || !text || !blob_size(text) ){ | |
| 352 | + return; | |
| 353 | + } | |
| 354 | + | |
| 355 | + /* expect BUGs if the following yields compiler warnings */ | |
| 356 | + memset(pos,0,24); | |
| 357 | + sprintf(pos, "%s%i", ctx->unique.c, index); | |
| 308 | 358 | |
| 359 | + blob_appendf(ob, "<li id='footnote-%s'>", pos); | |
| 360 | + BLOB_APPEND_LITERAL(ob,"<sup class='footnote-backrefs'>"); | |
| 361 | + if( nUsed <= 1 ){ | |
| 362 | + blob_appendf(ob,"<a id='footnote-%s-a' " | |
| 363 | + "href='#noteref-%s-a'>^</a>", pos, pos); | |
| 364 | + }else{ | |
| 365 | + int i; | |
| 366 | + blob_append_char(ob, '^'); | |
| 367 | + for(i=0; i<nUsed && i<26; i++){ | |
| 368 | + const int c = i + (unsigned)'a'; | |
| 369 | + blob_appendf(ob," <a id='footnote-%s-%c'" | |
| 370 | + " href='#noteref-%s-%c'>%c</a>", pos,c, pos,c, c); | |
| 371 | + } | |
| 372 | + /* It's unlikely that so many backrefs will be usefull */ | |
| 373 | + /* but maybe for some machine generated documents... */ | |
| 374 | + for(; i<nUsed && i<676; i++){ | |
| 375 | + const bitfield64_t l = to_base26(i,0); | |
| 376 | + blob_appendf(ob," <a id='footnote-%s-%s'" | |
| 377 | + " href='#noteref-%s-%s'>%s</a>", | |
| 378 | + pos,l.c, pos,l.c, l.c); | |
| 379 | + } | |
| 380 | + if( i < nUsed ) BLOB_APPEND_LITERAL(ob," …"); | |
| 381 | + } | |
| 382 | + BLOB_APPEND_LITERAL(ob,"</sup>\n\t"); | |
| 383 | + BLOB_APPEND_BLOB(ob, text); | |
| 384 | + BLOB_APPEND_LITERAL(ob, "\n</li>\n"); | |
| 385 | +} | |
| 386 | +static void html_footnotes( | |
| 387 | + struct Blob *ob, const struct Blob *items, void *opaque | |
| 388 | +){ | |
| 389 | + if( items && blob_size(items) ){ | |
| 390 | + BLOB_APPEND_LITERAL(ob, "<ol class='footnotes'>\n"); | |
| 391 | + BLOB_APPEND_BLOB(ob, items); | |
| 392 | + BLOB_APPEND_LITERAL(ob, "</ol>\n"); | |
| 393 | + } | |
| 394 | +} | |
| 309 | 395 | |
| 310 | 396 | /* HTML span tags */ |
| 311 | 397 | |
| 312 | 398 | static int html_raw_html_tag(struct Blob *ob, struct Blob *text, void *opaque){ |
| 313 | 399 | blob_append(ob, blob_buffer(text), blob_size(text)); |
| @@ -563,10 +649,11 @@ | ||
| 563 | 649 | ){ |
| 564 | 650 | struct mkd_renderer html_renderer = { |
| 565 | 651 | /* prolog and epilog */ |
| 566 | 652 | html_prolog, |
| 567 | 653 | html_epilog, |
| 654 | + html_footnotes, | |
| 568 | 655 | |
| 569 | 656 | /* block level elements */ |
| 570 | 657 | html_blockcode, |
| 571 | 658 | html_blockquote, |
| 572 | 659 | html_blockhtml, |
| @@ -576,10 +663,11 @@ | ||
| 576 | 663 | html_list_item, |
| 577 | 664 | html_paragraph, |
| 578 | 665 | html_table, |
| 579 | 666 | html_table_cell, |
| 580 | 667 | html_table_row, |
| 668 | + html_footnote_item, | |
| 581 | 669 | |
| 582 | 670 | /* span level elements */ |
| 583 | 671 | html_autolink, |
| 584 | 672 | html_codespan, |
| 585 | 673 | html_double_emphasis, |
| @@ -587,22 +675,25 @@ | ||
| 587 | 675 | html_image, |
| 588 | 676 | html_linebreak, |
| 589 | 677 | html_link, |
| 590 | 678 | html_raw_html_tag, |
| 591 | 679 | html_triple_emphasis, |
| 680 | + html_footnote_ref, | |
| 592 | 681 | |
| 593 | 682 | /* low level elements */ |
| 594 | 683 | 0, /* entity */ |
| 595 | 684 | html_normal_text, |
| 596 | 685 | |
| 597 | 686 | /* misc. parameters */ |
| 598 | 687 | "*_", /* emph_chars */ |
| 599 | 688 | 0 /* opaque */ |
| 600 | 689 | }; |
| 690 | + static int invocation = -1; /* no marker for the first document */ | |
| 601 | 691 | MarkdownToHtml context; |
| 602 | 692 | memset(&context, 0, sizeof(context)); |
| 603 | 693 | context.output_title = output_title; |
| 694 | + context.unique = to_base26(invocation++,1); | |
| 604 | 695 | html_renderer.opaque = &context; |
| 605 | 696 | if( output_title ) blob_reset(output_title); |
| 606 | 697 | blob_reset(output_body); |
| 607 | 698 | markdown(output_body, input_markdown, &html_renderer); |
| 608 | 699 | } |
| 609 | 700 |
| --- src/markdown_html.c | |
| +++ src/markdown_html.c | |
| @@ -29,17 +29,20 @@ | |
| 29 | struct Blob *output_title, |
| 30 | struct Blob *output_body); |
| 31 | |
| 32 | #endif /* INTERFACE */ |
| 33 | |
| 34 | /* |
| 35 | ** An instance of the following structure is passed through the |
| 36 | ** "opaque" pointer. |
| 37 | */ |
| 38 | typedef struct MarkdownToHtml MarkdownToHtml; |
| 39 | struct MarkdownToHtml { |
| 40 | Blob *output_title; /* Store the title here */ |
| 41 | }; |
| 42 | |
| 43 | |
| 44 | /* INTER_BLOCK -- skip a line between block level elements */ |
| 45 | #define INTER_BLOCK(ob) \ |
| @@ -56,10 +59,26 @@ | |
| 56 | |
| 57 | /* BLOB_APPEND_BLOB -- append blob contents to another */ |
| 58 | #define BLOB_APPEND_BLOB(dest, src) \ |
| 59 | blob_append((dest), blob_buffer(src), blob_size(src)) |
| 60 | |
| 61 | |
| 62 | /* HTML escapes |
| 63 | ** |
| 64 | ** html_escape() converts < to <, > to >, and & to &. |
| 65 | ** html_quote() goes further and converts " into " and ' in '. |
| @@ -303,11 +322,78 @@ | |
| 303 | BLOB_APPEND_LITERAL(ob, " <tr>\n"); |
| 304 | BLOB_APPEND_BLOB(ob, cells); |
| 305 | BLOB_APPEND_LITERAL(ob, " </tr>\n"); |
| 306 | } |
| 307 | |
| 308 | |
| 309 | |
| 310 | /* HTML span tags */ |
| 311 | |
| 312 | static int html_raw_html_tag(struct Blob *ob, struct Blob *text, void *opaque){ |
| 313 | blob_append(ob, blob_buffer(text), blob_size(text)); |
| @@ -563,10 +649,11 @@ | |
| 563 | ){ |
| 564 | struct mkd_renderer html_renderer = { |
| 565 | /* prolog and epilog */ |
| 566 | html_prolog, |
| 567 | html_epilog, |
| 568 | |
| 569 | /* block level elements */ |
| 570 | html_blockcode, |
| 571 | html_blockquote, |
| 572 | html_blockhtml, |
| @@ -576,10 +663,11 @@ | |
| 576 | html_list_item, |
| 577 | html_paragraph, |
| 578 | html_table, |
| 579 | html_table_cell, |
| 580 | html_table_row, |
| 581 | |
| 582 | /* span level elements */ |
| 583 | html_autolink, |
| 584 | html_codespan, |
| 585 | html_double_emphasis, |
| @@ -587,22 +675,25 @@ | |
| 587 | html_image, |
| 588 | html_linebreak, |
| 589 | html_link, |
| 590 | html_raw_html_tag, |
| 591 | html_triple_emphasis, |
| 592 | |
| 593 | /* low level elements */ |
| 594 | 0, /* entity */ |
| 595 | html_normal_text, |
| 596 | |
| 597 | /* misc. parameters */ |
| 598 | "*_", /* emph_chars */ |
| 599 | 0 /* opaque */ |
| 600 | }; |
| 601 | MarkdownToHtml context; |
| 602 | memset(&context, 0, sizeof(context)); |
| 603 | context.output_title = output_title; |
| 604 | html_renderer.opaque = &context; |
| 605 | if( output_title ) blob_reset(output_title); |
| 606 | blob_reset(output_body); |
| 607 | markdown(output_body, input_markdown, &html_renderer); |
| 608 | } |
| 609 |
| --- src/markdown_html.c | |
| +++ src/markdown_html.c | |
| @@ -29,17 +29,20 @@ | |
| 29 | struct Blob *output_title, |
| 30 | struct Blob *output_body); |
| 31 | |
| 32 | #endif /* INTERFACE */ |
| 33 | |
| 34 | typedef union { uint64_t u; char c[8]; unsigned char b[8]; } bitfield64_t; |
| 35 | |
| 36 | /* |
| 37 | ** An instance of the following structure is passed through the |
| 38 | ** "opaque" pointer. |
| 39 | */ |
| 40 | typedef struct MarkdownToHtml MarkdownToHtml; |
| 41 | struct MarkdownToHtml { |
| 42 | Blob *output_title; /* Store the title here */ |
| 43 | bitfield64_t unique; /* Enables construction of unique #id elements */ |
| 44 | }; |
| 45 | |
| 46 | |
| 47 | /* INTER_BLOCK -- skip a line between block level elements */ |
| 48 | #define INTER_BLOCK(ob) \ |
| @@ -56,10 +59,26 @@ | |
| 59 | |
| 60 | /* BLOB_APPEND_BLOB -- append blob contents to another */ |
| 61 | #define BLOB_APPEND_BLOB(dest, src) \ |
| 62 | blob_append((dest), blob_buffer(src), blob_size(src)) |
| 63 | |
| 64 | /* Converts an integer to a null-terminated base26 representation |
| 65 | * Return empty string if that integer is negative. */ |
| 66 | static bitfield64_t to_base26(int i, int uppercase){ |
| 67 | bitfield64_t x; |
| 68 | int j; |
| 69 | x.u = 0; |
| 70 | if( i >= 0 ){ |
| 71 | for(j=7; j >= 0; j--){ |
| 72 | x.b[j] = (unsigned char)(uppercase?'A':'a') + i%26; |
| 73 | if( (i /= 26) == 0 ) break; |
| 74 | } |
| 75 | x.u >>= 8*j; |
| 76 | } |
| 77 | x.c[7] = 0; |
| 78 | return x; |
| 79 | } |
| 80 | |
| 81 | /* HTML escapes |
| 82 | ** |
| 83 | ** html_escape() converts < to <, > to >, and & to &. |
| 84 | ** html_quote() goes further and converts " into " and ' in '. |
| @@ -303,11 +322,78 @@ | |
| 322 | BLOB_APPEND_LITERAL(ob, " <tr>\n"); |
| 323 | BLOB_APPEND_BLOB(ob, cells); |
| 324 | BLOB_APPEND_LITERAL(ob, " </tr>\n"); |
| 325 | } |
| 326 | |
| 327 | static int html_footnote_ref( |
| 328 | struct Blob *ob, int index, int locus, void *opaque |
| 329 | ){ |
| 330 | const struct MarkdownToHtml *ctx = (struct MarkdownToHtml*)opaque; |
| 331 | const bitfield64_t l = to_base26(locus-1,0); |
| 332 | char pos[32]; |
| 333 | |
| 334 | /* expect BUGs if the following yields compiler warnings */ |
| 335 | memset(pos,0,32); |
| 336 | sprintf(pos, "%s%i-%s", ctx->unique.c, index, l.c); |
| 337 | |
| 338 | BLOB_APPEND_LITERAL(ob,"<a class='noteref' href='#footnote-"); |
| 339 | blob_appendf(ob,"%s' id='noteref-%s'><sup>%i</sup></a>", |
| 340 | pos, pos, index); |
| 341 | return 1; |
| 342 | } |
| 343 | |
| 344 | /* Render a single item of the footnotes list. |
| 345 | * Each backref gets a unique id to enable dynamic styling. */ |
| 346 | static void html_footnote_item( |
| 347 | struct Blob *ob, const struct Blob *text, int index, int nUsed, void *opaque |
| 348 | ){ |
| 349 | const struct MarkdownToHtml *ctx = (struct MarkdownToHtml*)opaque; |
| 350 | char pos[24]; |
| 351 | if( index <= 0 || nUsed < 0 || !text || !blob_size(text) ){ |
| 352 | return; |
| 353 | } |
| 354 | |
| 355 | /* expect BUGs if the following yields compiler warnings */ |
| 356 | memset(pos,0,24); |
| 357 | sprintf(pos, "%s%i", ctx->unique.c, index); |
| 358 | |
| 359 | blob_appendf(ob, "<li id='footnote-%s'>", pos); |
| 360 | BLOB_APPEND_LITERAL(ob,"<sup class='footnote-backrefs'>"); |
| 361 | if( nUsed <= 1 ){ |
| 362 | blob_appendf(ob,"<a id='footnote-%s-a' " |
| 363 | "href='#noteref-%s-a'>^</a>", pos, pos); |
| 364 | }else{ |
| 365 | int i; |
| 366 | blob_append_char(ob, '^'); |
| 367 | for(i=0; i<nUsed && i<26; i++){ |
| 368 | const int c = i + (unsigned)'a'; |
| 369 | blob_appendf(ob," <a id='footnote-%s-%c'" |
| 370 | " href='#noteref-%s-%c'>%c</a>", pos,c, pos,c, c); |
| 371 | } |
| 372 | /* It's unlikely that so many backrefs will be usefull */ |
| 373 | /* but maybe for some machine generated documents... */ |
| 374 | for(; i<nUsed && i<676; i++){ |
| 375 | const bitfield64_t l = to_base26(i,0); |
| 376 | blob_appendf(ob," <a id='footnote-%s-%s'" |
| 377 | " href='#noteref-%s-%s'>%s</a>", |
| 378 | pos,l.c, pos,l.c, l.c); |
| 379 | } |
| 380 | if( i < nUsed ) BLOB_APPEND_LITERAL(ob," …"); |
| 381 | } |
| 382 | BLOB_APPEND_LITERAL(ob,"</sup>\n\t"); |
| 383 | BLOB_APPEND_BLOB(ob, text); |
| 384 | BLOB_APPEND_LITERAL(ob, "\n</li>\n"); |
| 385 | } |
| 386 | static void html_footnotes( |
| 387 | struct Blob *ob, const struct Blob *items, void *opaque |
| 388 | ){ |
| 389 | if( items && blob_size(items) ){ |
| 390 | BLOB_APPEND_LITERAL(ob, "<ol class='footnotes'>\n"); |
| 391 | BLOB_APPEND_BLOB(ob, items); |
| 392 | BLOB_APPEND_LITERAL(ob, "</ol>\n"); |
| 393 | } |
| 394 | } |
| 395 | |
| 396 | /* HTML span tags */ |
| 397 | |
| 398 | static int html_raw_html_tag(struct Blob *ob, struct Blob *text, void *opaque){ |
| 399 | blob_append(ob, blob_buffer(text), blob_size(text)); |
| @@ -563,10 +649,11 @@ | |
| 649 | ){ |
| 650 | struct mkd_renderer html_renderer = { |
| 651 | /* prolog and epilog */ |
| 652 | html_prolog, |
| 653 | html_epilog, |
| 654 | html_footnotes, |
| 655 | |
| 656 | /* block level elements */ |
| 657 | html_blockcode, |
| 658 | html_blockquote, |
| 659 | html_blockhtml, |
| @@ -576,10 +663,11 @@ | |
| 663 | html_list_item, |
| 664 | html_paragraph, |
| 665 | html_table, |
| 666 | html_table_cell, |
| 667 | html_table_row, |
| 668 | html_footnote_item, |
| 669 | |
| 670 | /* span level elements */ |
| 671 | html_autolink, |
| 672 | html_codespan, |
| 673 | html_double_emphasis, |
| @@ -587,22 +675,25 @@ | |
| 675 | html_image, |
| 676 | html_linebreak, |
| 677 | html_link, |
| 678 | html_raw_html_tag, |
| 679 | html_triple_emphasis, |
| 680 | html_footnote_ref, |
| 681 | |
| 682 | /* low level elements */ |
| 683 | 0, /* entity */ |
| 684 | html_normal_text, |
| 685 | |
| 686 | /* misc. parameters */ |
| 687 | "*_", /* emph_chars */ |
| 688 | 0 /* opaque */ |
| 689 | }; |
| 690 | static int invocation = -1; /* no marker for the first document */ |
| 691 | MarkdownToHtml context; |
| 692 | memset(&context, 0, sizeof(context)); |
| 693 | context.output_title = output_title; |
| 694 | context.unique = to_base26(invocation++,1); |
| 695 | html_renderer.opaque = &context; |
| 696 | if( output_title ) blob_reset(output_title); |
| 697 | blob_reset(output_body); |
| 698 | markdown(output_body, input_markdown, &html_renderer); |
| 699 | } |
| 700 |