Fossil SCM

Code style tweaks, typos, and resolved a couple footnotes-related cosmetic TODOs. No functional changes.

stephan 2022-04-19 12:35 markdown-footnotes

Commit 3a5b3d5e4956d36b470b0435bb9de7bc5adab8c1de968660058ba662e8e2114f

Parent 8a4b099fb42efb6…

4 files changed +99 -69 +1 -1 +84 -88 +4 -4

~ src/markdown.c ~ src/markdown.md ~ src/markdown_html.c ~ src/wikiformat.c

M src/markdown.c

+99 -69

		--- src/markdown.c
		+++ src/markdown.c
		@@ -118,11 +118,13 @@
118	118
119	119	/**********************
120	120	* EXPORTED FUNCTIONS *
121	121	**********************/
122	122
123		-/* markdown -- parses the input buffer and renders it into the output buffer */
	123	+/*
	124	+** markdown -- parses the input buffer and renders it into the output buffer.
	125	+*/
124	126	void markdown(
125	127	struct Blob *ob,
126	128	const struct Blob *ib,
127	129	const struct mkd_renderer *rndr);
128	130
		@@ -135,18 +137,21 @@
135	137
136	138	/***************
137	139	* LOCAL TYPES *
138	140	***************/
139	141
140		-/* link_ref -- reference to a link */
	142	+/*
	143	+** link_ref -- reference to a link.
	144	+*/
141	145	struct link_ref {
142	146	struct Blob id; /* must be the first field as in footnote struct */
143	147	struct Blob link;
144	148	struct Blob title;
145	149	};
146	150
147		-/* A footnote's data.
	151	+/*
	152	+** A footnote's data.
148	153	** id, text, and upc fields must be in that particular order.
149	154	*/
150	155	struct footnote {
151	156	struct Blob id; /* must be the first field as in link_ref struct */
152	157	struct Blob text; /* footnote's content that is rendered at the end */
		@@ -216,12 +221,14 @@
216	221
217	222	/***************************
218	223	* STATIC HELPER FUNCTIONS *
219	224	***************************/
220	225
221		-/* build_ref_id -- collapse whitespace from input text to make it a ref id */
222		-/* TODO: maybe also handle CR+LF line endings? */
	226	+/*
	227	+** build_ref_id -- collapse whitespace from input text to make it a ref id.
	228	+** Potential TODO: maybe also handle CR+LF line endings?
	229	+*/
223	230	static int build_ref_id(struct Blob id, const char data, size_t size){
224	231	size_t beg, i;
225	232	char *id_data;
226	233
227	234	/* skip leading whitespace */
		@@ -276,13 +283,15 @@
276	283	struct link_ref lra = (void )a;
277	284	struct link_ref lrb = (void )b;
278	285	return blob_compare(&lra->id, &lrb->id);
279	286	}
280	287
281		-/* cmp_footnote_id -- comparison function for footnotes qsort.
282		- * Empty IDs sort last (in undetermined order).
283		- * Equal IDs are sorted in the order of definition in the source */
	288	+/*
	289	+** cmp_footnote_id -- comparison function for footnotes qsort.
	290	+** Empty IDs sort last (in undetermined order).
	291	+** Equal IDs are sorted in the order of definition in the source.
	292	+*/
284	293	static int cmp_footnote_id(const void fna, const void fnb){
285	294	const struct footnote a = fna, b = fnb;
286	295	const int szA = blob_size(&a->id), szB = blob_size(&b->id);
287	296	if( szA ){
288	297	if( szB ){
		@@ -295,13 +304,15 @@
295	304	if( a->defno > b->defno ) return 1;
296	305	assert(!"reachable");
297	306	return 0; /* should never reach here */
298	307	}
299	308
300		-/* cmp_footnote_sort -- comparison function for footnotes qsort.
301		- * Unreferenced footnotes (when nUsed == 0) sort last and
302		- * are sorted in the order of definition in the source */
	309	+/*
	310	+** cmp_footnote_sort -- comparison function for footnotes qsort.
	311	+** Unreferenced footnotes (when nUsed == 0) sort last and
	312	+** are sorted in the order of definition in the source.
	313	+*/
303	314	static int cmp_footnote_sort(const void fna, const void fnb){
304	315	const struct footnote a = fna, b = fnb;
305	316	int i, j;
306	317	assert( a->nUsed >= 0 );
307	318	assert( b->nUsed >= 0 );
		@@ -652,12 +663,14 @@
652	663	if( fossil_isalnum(after) ) return 0;
653	664	return 1;
654	665	}
655	666
656	667
657		-/* parse_emph1 -- parsing single emphasis */
658		-/* closed by a symbol not preceded by whitespace and not followed by symbol */
	668	+/*
	669	+** parse_emph1 -- parsing single emphasis.
	670	+** closed by a symbol not preceded by whitespace and not followed by symbol.
	671	+*/
659	672	static size_t parse_emph1(
660	673	struct Blob *ob,
661	674	struct render *rndr,
662	675	char *data,
663	676	size_t size,
		@@ -697,12 +710,13 @@
697	710	}
698	711	}
699	712	return 0;
700	713	}
701	714
702		-
703		-/* parse_emph2 -- parsing single emphasis */
	715	+/*
	716	+** parse_emph2 -- parsing single emphasis.
	717	+*/
704	718	static size_t parse_emph2(
705	719	struct Blob *ob,
706	720	struct render *rndr,
707	721	char *data,
708	722	size_t size,
		@@ -736,13 +750,14 @@
736	750	i++;
737	751	}
738	752	return 0;
739	753	}
740	754
741		-
742		-/* parse_emph3 -- parsing single emphasis */
743		-/* finds the first closing tag, and delegates to the other emph */
	755	+/*
	756	+** parse_emph3 -- parsing single emphasis.
	757	+** finds the first closing tag, and delegates to the other emph.
	758	+*/
744	759	static size_t parse_emph3(
745	760	struct Blob *ob,
746	761	struct render *rndr,
747	762	char *data,
748	763	size_t size,
		@@ -784,12 +799,13 @@
784	799	}
785	800	}
786	801	return 0;
787	802	}
788	803
789		-
790		-/* char_emphasis -- single and double emphasis parsing */
	804	+/*
	805	+** char_emphasis -- single and double emphasis parsing.
	806	+*/
791	807	static size_t char_emphasis(
792	808	struct Blob *ob,
793	809	struct render *rndr,
794	810	char *data,
795	811	size_t offset,
		@@ -829,12 +845,13 @@
829	845	return ret+3;
830	846	}
831	847	return 0;
832	848	}
833	849
834		-
835		-/* char_linebreak -- '\n' preceded by two spaces (assuming linebreak != 0) */
	850	+/*
	851	+** char_linebreak -- '\n' preceded by two spaces (assuming linebreak != 0).
	852	+*/
836	853	static size_t char_linebreak(
837	854	struct Blob *ob,
838	855	struct render *rndr,
839	856	char *data,
840	857	size_t offset,
		@@ -844,12 +861,13 @@
844	861	/* removing the last space from ob and rendering */
845	862	if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]==' ' ) ob->nUsed--;
846	863	return rndr->make.linebreak(ob, rndr->make.opaque) ? 1 : 0;
847	864	}
848	865
849		-
850		-/* char_codespan -- '`' parsing a code span (assuming codespan != 0) */
	866	+/*
	867	+** char_codespan -- '`' parsing a code span (assuming codespan != 0).
	868	+*/
851	869	static size_t char_codespan(
852	870	struct Blob *ob,
853	871	struct render *rndr,
854	872	char *data,
855	873	size_t offset,
		@@ -886,11 +904,13 @@
886	904	}
887	905	return end;
888	906	}
889	907
890	908
891		-/* char_escape -- '\\' backslash escape */
	909	+/*
	910	+** char_escape -- '\\' backslash escape.
	911	+*/
892	912	static size_t char_escape(
893	913	struct Blob *ob,
894	914	struct render *rndr,
895	915	char *data,
896	916	size_t offset,
		@@ -906,13 +926,14 @@
906	926	}
907	927	}
908	928	return 2;
909	929	}
910	930
911		-
912		-/* char_entity -- '&' escaped when it doesn't belong to an entity */
913		-/* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */
	931	+/*
	932	+** char_entity -- '&' escaped when it doesn't belong to an entity.
	933	+** valid entities are assumed to be anything matching &#?[A-Za-z0-9]+;
	934	+*/
914	935	static size_t char_entity(
915	936	struct Blob *ob,
916	937	struct render *rndr,
917	938	char *data,
918	939	size_t offset,
		@@ -942,12 +963,13 @@
942	963	blob_append(ob, data, end);
943	964	}
944	965	return end;
945	966	}
946	967
947		-
948		-/* char_langle_tag -- '<' when tags or autolinks are allowed */
	968	+/*
	969	+** char_langle_tag -- '<' when tags or autolinks are allowed.
	970	+*/
949	971	static size_t char_langle_tag(
950	972	struct Blob *ob,
951	973	struct render *rndr,
952	974	char *data,
953	975	size_t offset,
		@@ -972,12 +994,12 @@
972	994	}else{
973	995	return end;
974	996	}
975	997	}
976	998
977		-
978		-/* get_link_inline -- extract inline-style link and title from
	999	+/*
	1000	+** get_link_inline -- extract inline-style link and title from
979	1001	** parenthesed data
980	1002	*/
981	1003	static int get_link_inline(
982	1004	struct Blob *link,
983	1005	struct Blob *title,
		@@ -1048,11 +1070,13 @@
1048	1070	/* this function always succeed */
1049	1071	return 0;
1050	1072	}
1051	1073
1052	1074
1053		-/* get_link_ref -- extract referenced link and title from id */
	1075	+/*
	1076	+** get_link_ref -- extract referenced link and title from id.
	1077	+*/
1054	1078	static int get_link_ref(
1055	1079	struct render *rndr,
1056	1080	struct Blob *link,
1057	1081	struct Blob *title,
1058	1082	char *data,
		@@ -1076,13 +1100,15 @@
1076	1100	blob_appendb(link, &lr->link);
1077	1101	blob_appendb(title, &lr->title);
1078	1102	return 0;
1079	1103	}
1080	1104
1081		-/* get_footnote() -- find a footnote by label, invoked during the 2nd pass.
1082		- * On success returns a footnote (after incrementing its nUsed field),
1083		- * otherwise returns NULL */
	1105	+/*
	1106	+** get_footnote() -- find a footnote by label, invoked during the 2nd pass.
	1107	+** On success returns a footnote (after incrementing its nUsed field),
	1108	+** otherwise returns NULL.
	1109	+*/
1084	1110	static const struct footnote* get_footnote(
1085	1111	struct render *rndr,
1086	1112	const char *data,
1087	1113	size_t size
1088	1114	){
		@@ -1105,14 +1131,15 @@
1105	1131	cleanup:
1106	1132	release_work_buffer( rndr, id );
1107	1133	return fn;
1108	1134	}
1109	1135
1110		-/* Counts characters in the blank prefix within at most nHalfLines.
	1136	+/*
	1137	+** Counts characters in the blank prefix within at most nHalfLines.
1111	1138	** A sequence of spaces and tabs counts as odd halfline,
1112	1139	** a newline counts as even halfline.
1113		-** If nHalfLines < 0 then procceed without constrains.
	1140	+** If nHalfLines < 0 then proceed without constraints.
1114	1141	*/
1115	1142	static inline size_t sizeof_blank_prefix(
1116	1143	const char *data, size_t size, int nHalfLines
1117	1144	){
1118	1145	const char *p = data;
		@@ -1134,22 +1161,24 @@
1134	1161	nHalfLines--;
1135	1162	}
1136	1163	return p-data;
1137	1164	}
1138	1165
1139		-/* Check if the data starts with a classlist token of the special form.
	1166	+/*
	1167	+** Check if the data starts with a classlist token of the special form.
1140	1168	** If so then return the length of that token, otherwise return 0.
1141	1169	**
1142	1170	** The token must start with a dot and must end with a colon;
1143	1171	** in between of these it must be a dot-separated list of words;
1144	1172	** each word may contain only alphanumeric characters and hyphens.
1145	1173	**
1146	1174	** If `bBlank` is non-zero then a blank character must follow
1147	1175	** the token's ending colon: otherwise function returns 0
1148		-** despite of the well-formed token.
	1176	+** despite the well-formed token.
1149	1177	*/
1150		-size_t is_footnote_classlist(const char * const data, size_t size, int bBlank){
	1178	+static size_t is_footnote_classlist(const char * const data, size_t size,
	1179	+ int bBlank){
1151	1180	const char *p;
1152	1181	const char * const end = data+size;
1153	1182	if( data==end \|\| *data != '.' ) return 0;
1154	1183	for(p=data+1; p!=end; p++){
1155	1184	if( fossil_isalnum(p) \|\| p=='-' ) continue;
		@@ -1164,13 +1193,16 @@
1164	1193	if( *p!='.' ) break;
1165	1194	}
1166	1195	return 0;
1167	1196	}
1168	1197
1169		-/* Adds unlabeled footnote to the rndr.
1170		- * If text is blank then returns 0,
1171		- * otherwise returns the address of the added footnote. */
	1198	+/*
	1199	+** Adds unlabeled footnote to the rndr. If text is blank then returns
	1200	+** 0, otherwise returns the address of the added footnote, which lives
	1201	+** in rndr->notes, noting that the pointer may be invalidated via
	1202	+** reallocation the next time a footnote is added to that member.
	1203	+*/
1172	1204	static inline const struct footnote* add_inline_footnote(
1173	1205	struct render *rndr,
1174	1206	const char *text,
1175	1207	size_t size
1176	1208	){
		@@ -1202,12 +1234,13 @@
1202	1234	blob_append(&rndr->notes.all, (char *)&fn, sizeof fn);
1203	1235	return (struct footnote*)( blob_buffer(&rndr->notes.all)
1204	1236	+( blob_size(&rndr->notes.all)-sizeof fn ));
1205	1237	}
1206	1238
1207		-/* Return the offset of the matching closing bracket or 0 if not found.
1208		-** begin[0] must be either '[' or '('
	1239	+/*
	1240	+** Return the byte offset of the matching closing bracket or 0 if not
	1241	+** found. begin[0] must be either '[' or '('.
1209	1242	**
1210	1243	** TODO: It seems that things like "\\(" are not handled correctly.
1211	1244	** That is historical behavior for a corner-case,
1212	1245	** so it's left as it is until somebody complains.
1213	1246	*/
		@@ -1229,11 +1262,13 @@
1229	1262	}
1230	1263	}
1231	1264	return 0;
1232	1265	}
1233	1266
1234		-/* char_footnote -- '(': parsing a standalone inline footnote */
	1267	+/*
	1268	+** char_footnote -- '(': parsing a standalone inline footnote.
	1269	+*/
1235	1270	static size_t char_footnote(
1236	1271	struct Blob *ob,
1237	1272	struct render *rndr,
1238	1273	char *data,
1239	1274	size_t offset,
		@@ -1251,11 +1286,13 @@
1251	1286	rndr->make.footnote_ref(ob,0,&fn->upc,fn->iMark,1,rndr->make.opaque);
1252	1287	}
1253	1288	return end+1;
1254	1289	}
1255	1290
1256		-/* char_link -- '[': parsing a link or an image */
	1291	+/*
	1292	+** char_link -- '[': parsing a link or an image.
	1293	+*/
1257	1294	static size_t char_link(
1258	1295	struct Blob *ob,
1259	1296	struct render *rndr,
1260	1297	char *data,
1261	1298	size_t offset,
		@@ -1288,11 +1325,11 @@
1288	1325	fn = &rndr->notes.misref;
1289	1326	}
1290	1327	}else{
1291	1328
1292	1329	/* skip "inter-bracket-whitespace" - any amount of whitespace or newline */
1293		- /* (this is much more laxist than original markdown syntax) */
	1330	+ /* (this is much more lax than original markdown syntax) */
1294	1331	while( i<size && (data[i]==' ' \|\| data[i]=='\t' \|\| data[i]=='\n') ){ i++; }
1295	1332
1296	1333	/* allocate temporary buffers to store content, link and title */
1297	1334	title = new_work_buffer(rndr);
1298	1335	content = new_work_buffer(rndr);
		@@ -1307,35 +1344,29 @@
1307	1344	fn = add_inline_footnote(rndr, data+(i+2), k-2);
1308	1345	i += k+1;
1309	1346	}else{ /* inline style link */
1310	1347	size_t span_end = i;
1311	1348	while( span_end<size
1312		- && !(data[span_end]==')' && (span_end==i \|\| data[span_end-1]!='\\'))
1313		- ){
	1349	+ && !(data[span_end]==')'
	1350	+ && (span_end==i \|\| data[span_end-1]!='\\')) ){
1314	1351	span_end++;
1315	1352	}
1316		-
1317	1353	if( span_end>=size
1318		- \|\| get_link_inline(link, title, data+i+1, span_end-(i+1))<0
1319		- ){
	1354	+ \|\| get_link_inline(link, title, data+i+1, span_end-(i+1))<0 ){
1320	1355	goto char_link_cleanup;
1321	1356	}
1322		-
1323	1357	i = span_end+1;
1324	1358	}
1325		-
1326	1359	/* reference style link or span-bounded footnote reference */
1327	1360	}else if( i<size && data[i]=='[' ){
1328	1361	char *id_data;
1329	1362	size_t id_size, id_end = i;
1330	1363	int bFootnote;
1331	1364
1332	1365	while( id_end<size && data[id_end]!=']' ){ id_end++; }
1333		-
1334	1366	if( id_end>=size ) goto char_link_cleanup;
1335	1367	bFootnote = data[i+1]=='^';
1336		-
1337	1368	if( i+1==id_end \|\| (bFootnote && i+2==id_end) ){
1338	1369	/* implicit id - use the contents */
1339	1370	id_data = data+1;
1340	1371	id_size = txt_e-1;
1341	1372	}else{
		@@ -1345,23 +1376,20 @@
1345	1376	if( bFootnote ){
1346	1377	id_data++;
1347	1378	id_size--;
1348	1379	}
1349	1380	}
1350		-
1351	1381	if( bFootnote ){
1352	1382	fn = get_footnote(rndr, id_data, id_size);
1353	1383	if( !fn ) {
1354	1384	rndr->notes.misref.nUsed++;
1355	1385	fn = &rndr->notes.misref;
1356	1386	}
1357	1387	}else if( get_link_ref(rndr, link, title, id_data, id_size)<0 ){
1358	1388	goto char_link_cleanup;
1359	1389	}
1360		-
1361	1390	i = id_end+1;
1362		-
1363	1391	/* shortcut reference style link */
1364	1392	}else{
1365	1393	if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){
1366	1394	goto char_link_cleanup;
1367	1395	}
		@@ -1375,16 +1403,18 @@
1375	1403	else parse_inline(content, rndr, data+1, txt_e-1);
1376	1404	}
1377	1405
1378	1406	/* calling the relevant rendering function */
1379	1407	if( is_img ){
1380		- if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--;
	1408	+ if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ){
	1409	+ ob->nUsed--;
	1410	+ }
1381	1411	ret = rndr->make.image(ob, link, title, content, rndr->make.opaque);
1382		- }else if(fn){
	1412	+ }else if( fn ){
1383	1413	if( rndr->make.footnote_ref ){
1384		- ret = rndr->make.footnote_ref(ob, content, &fn->upc, fn->iMark, fn->nUsed,
1385		- rndr->make.opaque);
	1414	+ ret = rndr->make.footnote_ref(ob, content, &fn->upc, fn->iMark,
	1415	+ fn->nUsed, rndr->make.opaque);
1386	1416	}
1387	1417	}else{
1388	1418	ret = rndr->make.link(ob, link, title, content, rndr->make.opaque);
1389	1419	}
1390	1420
		@@ -1393,11 +1423,10 @@
1393	1423	release_work_buffer(rndr, title);
1394	1424	release_work_buffer(rndr, link);
1395	1425	release_work_buffer(rndr, content);
1396	1426	return ret ? i : 0;
1397	1427	}
1398		-
1399	1428
1400	1429
1401	1430	/*********************************
1402	1431	* BLOCK-LEVEL PARSING FUNCTIONS *
1403	1432	*********************************/
		@@ -2532,18 +2561,19 @@
2532	2561	while( indent<end && data[indent]==' ' ){ indent++; }
2533	2562	if( indent>=end ) goto footnote_finish;
2534	2563	indent -= i;
2535	2564	if( indent<2 ) goto footnote_finish;
2536	2565
2537		- /* process the 2nd and the following lines */
	2566	+ /* process the 2nd and subsequent lines */
2538	2567	while( i+indent<end && memcmp(data+i,spaces,indent)==0 ){
2539	2568	size_t j;
2540	2569	i += indent;
2541	2570	if( !upc_offset ){
2542	2571	/* a classlist must be provided no later than at the 2nd line */
2543	2572	upc_offset = i + sizeof_blank_prefix(data+i, end-i, 1);
2544		- upc_size = is_footnote_classlist(data+upc_offset, end-upc_offset, 1);
	2573	+ upc_size = is_footnote_classlist(data+upc_offset,
	2574	+ end-upc_offset, 1);
2545	2575	if( upc_size ){
2546	2576	i = upc_offset + upc_size;
2547	2577	}
2548	2578	}
2549	2579	j = i;
		@@ -2599,11 +2629,11 @@
2599	2629	struct link_ref *lr;
2600	2630	struct footnote *fn;
2601	2631	size_t i, beg, end = 0;
2602	2632	struct render rndr;
2603	2633	Blob text = BLOB_INITIALIZER; /* input after the first pass */
2604		- Blob *allNotes = &rndr.notes.all;
	2634	+ Blob * const allNotes = &rndr.notes.all;
2605	2635
2606	2636	/* filling the render structure */
2607	2637	if( !rndrer ) return;
2608	2638	rndr.make = *rndrer;
2609	2639	rndr.nBlobCache = 0;
2610	2640

	--- src/markdown.c
	+++ src/markdown.c
	@@ -118,11 +118,13 @@
118
119	/**********************
120	* EXPORTED FUNCTIONS *
121	**********************/
122
123	/* markdown -- parses the input buffer and renders it into the output buffer */


124	void markdown(
125	struct Blob *ob,
126	const struct Blob *ib,
127	const struct mkd_renderer *rndr);
128
	@@ -135,18 +137,21 @@
135
136	/***************
137	* LOCAL TYPES *
138	***************/
139
140	/* link_ref -- reference to a link */


141	struct link_ref {
142	struct Blob id; /* must be the first field as in footnote struct */
143	struct Blob link;
144	struct Blob title;
145	};
146
147	/* A footnote's data.

148	** id, text, and upc fields must be in that particular order.
149	*/
150	struct footnote {
151	struct Blob id; /* must be the first field as in link_ref struct */
152	struct Blob text; /* footnote's content that is rendered at the end */
	@@ -216,12 +221,14 @@
216
217	/***************************
218	* STATIC HELPER FUNCTIONS *
219	***************************/
220
221	/* build_ref_id -- collapse whitespace from input text to make it a ref id */
222	/* TODO: maybe also handle CR+LF line endings? */


223	static int build_ref_id(struct Blob id, const char data, size_t size){
224	size_t beg, i;
225	char *id_data;
226
227	/* skip leading whitespace */
	@@ -276,13 +283,15 @@
276	struct link_ref lra = (void )a;
277	struct link_ref lrb = (void )b;
278	return blob_compare(&lra->id, &lrb->id);
279	}
280
281	/* cmp_footnote_id -- comparison function for footnotes qsort.
282	* Empty IDs sort last (in undetermined order).
283	* Equal IDs are sorted in the order of definition in the source */


284	static int cmp_footnote_id(const void fna, const void fnb){
285	const struct footnote a = fna, b = fnb;
286	const int szA = blob_size(&a->id), szB = blob_size(&b->id);
287	if( szA ){
288	if( szB ){
	@@ -295,13 +304,15 @@
295	if( a->defno > b->defno ) return 1;
296	assert(!"reachable");
297	return 0; /* should never reach here */
298	}
299
300	/* cmp_footnote_sort -- comparison function for footnotes qsort.
301	* Unreferenced footnotes (when nUsed == 0) sort last and
302	* are sorted in the order of definition in the source */


303	static int cmp_footnote_sort(const void fna, const void fnb){
304	const struct footnote a = fna, b = fnb;
305	int i, j;
306	assert( a->nUsed >= 0 );
307	assert( b->nUsed >= 0 );
	@@ -652,12 +663,14 @@
652	if( fossil_isalnum(after) ) return 0;
653	return 1;
654	}
655
656
657	/* parse_emph1 -- parsing single emphasis */
658	/* closed by a symbol not preceded by whitespace and not followed by symbol */


659	static size_t parse_emph1(
660	struct Blob *ob,
661	struct render *rndr,
662	char *data,
663	size_t size,
	@@ -697,12 +710,13 @@
697	}
698	}
699	return 0;
700	}
701
702
703	/* parse_emph2 -- parsing single emphasis */

704	static size_t parse_emph2(
705	struct Blob *ob,
706	struct render *rndr,
707	char *data,
708	size_t size,
	@@ -736,13 +750,14 @@
736	i++;
737	}
738	return 0;
739	}
740
741
742	/* parse_emph3 -- parsing single emphasis */
743	/* finds the first closing tag, and delegates to the other emph */

744	static size_t parse_emph3(
745	struct Blob *ob,
746	struct render *rndr,
747	char *data,
748	size_t size,
	@@ -784,12 +799,13 @@
784	}
785	}
786	return 0;
787	}
788
789
790	/* char_emphasis -- single and double emphasis parsing */

791	static size_t char_emphasis(
792	struct Blob *ob,
793	struct render *rndr,
794	char *data,
795	size_t offset,
	@@ -829,12 +845,13 @@
829	return ret+3;
830	}
831	return 0;
832	}
833
834
835	/* char_linebreak -- '\n' preceded by two spaces (assuming linebreak != 0) */

836	static size_t char_linebreak(
837	struct Blob *ob,
838	struct render *rndr,
839	char *data,
840	size_t offset,
	@@ -844,12 +861,13 @@
844	/* removing the last space from ob and rendering */
845	if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]==' ' ) ob->nUsed--;
846	return rndr->make.linebreak(ob, rndr->make.opaque) ? 1 : 0;
847	}
848
849
850	/* char_codespan -- '`' parsing a code span (assuming codespan != 0) */

851	static size_t char_codespan(
852	struct Blob *ob,
853	struct render *rndr,
854	char *data,
855	size_t offset,
	@@ -886,11 +904,13 @@
886	}
887	return end;
888	}
889
890
891	/* char_escape -- '\\' backslash escape */


892	static size_t char_escape(
893	struct Blob *ob,
894	struct render *rndr,
895	char *data,
896	size_t offset,
	@@ -906,13 +926,14 @@
906	}
907	}
908	return 2;
909	}
910
911
912	/* char_entity -- '&' escaped when it doesn't belong to an entity */
913	/* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */

914	static size_t char_entity(
915	struct Blob *ob,
916	struct render *rndr,
917	char *data,
918	size_t offset,
	@@ -942,12 +963,13 @@
942	blob_append(ob, data, end);
943	}
944	return end;
945	}
946
947
948	/* char_langle_tag -- '<' when tags or autolinks are allowed */

949	static size_t char_langle_tag(
950	struct Blob *ob,
951	struct render *rndr,
952	char *data,
953	size_t offset,
	@@ -972,12 +994,12 @@
972	}else{
973	return end;
974	}
975	}
976
977
978	/* get_link_inline -- extract inline-style link and title from
979	** parenthesed data
980	*/
981	static int get_link_inline(
982	struct Blob *link,
983	struct Blob *title,
	@@ -1048,11 +1070,13 @@
1048	/* this function always succeed */
1049	return 0;
1050	}
1051
1052
1053	/* get_link_ref -- extract referenced link and title from id */


1054	static int get_link_ref(
1055	struct render *rndr,
1056	struct Blob *link,
1057	struct Blob *title,
1058	char *data,
	@@ -1076,13 +1100,15 @@
1076	blob_appendb(link, &lr->link);
1077	blob_appendb(title, &lr->title);
1078	return 0;
1079	}
1080
1081	/* get_footnote() -- find a footnote by label, invoked during the 2nd pass.
1082	* On success returns a footnote (after incrementing its nUsed field),
1083	* otherwise returns NULL */


1084	static const struct footnote* get_footnote(
1085	struct render *rndr,
1086	const char *data,
1087	size_t size
1088	){
	@@ -1105,14 +1131,15 @@
1105	cleanup:
1106	release_work_buffer( rndr, id );
1107	return fn;
1108	}
1109
1110	/* Counts characters in the blank prefix within at most nHalfLines.

1111	** A sequence of spaces and tabs counts as odd halfline,
1112	** a newline counts as even halfline.
1113	** If nHalfLines < 0 then procceed without constrains.
1114	*/
1115	static inline size_t sizeof_blank_prefix(
1116	const char *data, size_t size, int nHalfLines
1117	){
1118	const char *p = data;
	@@ -1134,22 +1161,24 @@
1134	nHalfLines--;
1135	}
1136	return p-data;
1137	}
1138
1139	/* Check if the data starts with a classlist token of the special form.

1140	** If so then return the length of that token, otherwise return 0.
1141	**
1142	** The token must start with a dot and must end with a colon;
1143	** in between of these it must be a dot-separated list of words;
1144	** each word may contain only alphanumeric characters and hyphens.
1145	**
1146	** If `bBlank` is non-zero then a blank character must follow
1147	** the token's ending colon: otherwise function returns 0
1148	** despite of the well-formed token.
1149	*/
1150	size_t is_footnote_classlist(const char * const data, size_t size, int bBlank){

1151	const char *p;
1152	const char * const end = data+size;
1153	if( data==end \|\| *data != '.' ) return 0;
1154	for(p=data+1; p!=end; p++){
1155	if( fossil_isalnum(p) \|\| p=='-' ) continue;
	@@ -1164,13 +1193,16 @@
1164	if( *p!='.' ) break;
1165	}
1166	return 0;
1167	}
1168
1169	/* Adds unlabeled footnote to the rndr.
1170	* If text is blank then returns 0,
1171	* otherwise returns the address of the added footnote. */



1172	static inline const struct footnote* add_inline_footnote(
1173	struct render *rndr,
1174	const char *text,
1175	size_t size
1176	){
	@@ -1202,12 +1234,13 @@
1202	blob_append(&rndr->notes.all, (char *)&fn, sizeof fn);
1203	return (struct footnote*)( blob_buffer(&rndr->notes.all)
1204	+( blob_size(&rndr->notes.all)-sizeof fn ));
1205	}
1206
1207	/* Return the offset of the matching closing bracket or 0 if not found.
1208	** begin[0] must be either '[' or '('

1209	**
1210	** TODO: It seems that things like "\\(" are not handled correctly.
1211	** That is historical behavior for a corner-case,
1212	** so it's left as it is until somebody complains.
1213	*/
	@@ -1229,11 +1262,13 @@
1229	}
1230	}
1231	return 0;
1232	}
1233
1234	/* char_footnote -- '(': parsing a standalone inline footnote */


1235	static size_t char_footnote(
1236	struct Blob *ob,
1237	struct render *rndr,
1238	char *data,
1239	size_t offset,
	@@ -1251,11 +1286,13 @@
1251	rndr->make.footnote_ref(ob,0,&fn->upc,fn->iMark,1,rndr->make.opaque);
1252	}
1253	return end+1;
1254	}
1255
1256	/* char_link -- '[': parsing a link or an image */


1257	static size_t char_link(
1258	struct Blob *ob,
1259	struct render *rndr,
1260	char *data,
1261	size_t offset,
	@@ -1288,11 +1325,11 @@
1288	fn = &rndr->notes.misref;
1289	}
1290	}else{
1291
1292	/* skip "inter-bracket-whitespace" - any amount of whitespace or newline */
1293	/* (this is much more laxist than original markdown syntax) */
1294	while( i<size && (data[i]==' ' \|\| data[i]=='\t' \|\| data[i]=='\n') ){ i++; }
1295
1296	/* allocate temporary buffers to store content, link and title */
1297	title = new_work_buffer(rndr);
1298	content = new_work_buffer(rndr);
	@@ -1307,35 +1344,29 @@
1307	fn = add_inline_footnote(rndr, data+(i+2), k-2);
1308	i += k+1;
1309	}else{ /* inline style link */
1310	size_t span_end = i;
1311	while( span_end<size
1312	&& !(data[span_end]==')' && (span_end==i \|\| data[span_end-1]!='\\'))
1313	){
1314	span_end++;
1315	}
1316
1317	if( span_end>=size
1318	\|\| get_link_inline(link, title, data+i+1, span_end-(i+1))<0
1319	){
1320	goto char_link_cleanup;
1321	}
1322
1323	i = span_end+1;
1324	}
1325
1326	/* reference style link or span-bounded footnote reference */
1327	}else if( i<size && data[i]=='[' ){
1328	char *id_data;
1329	size_t id_size, id_end = i;
1330	int bFootnote;
1331
1332	while( id_end<size && data[id_end]!=']' ){ id_end++; }
1333
1334	if( id_end>=size ) goto char_link_cleanup;
1335	bFootnote = data[i+1]=='^';
1336
1337	if( i+1==id_end \|\| (bFootnote && i+2==id_end) ){
1338	/* implicit id - use the contents */
1339	id_data = data+1;
1340	id_size = txt_e-1;
1341	}else{
	@@ -1345,23 +1376,20 @@
1345	if( bFootnote ){
1346	id_data++;
1347	id_size--;
1348	}
1349	}
1350
1351	if( bFootnote ){
1352	fn = get_footnote(rndr, id_data, id_size);
1353	if( !fn ) {
1354	rndr->notes.misref.nUsed++;
1355	fn = &rndr->notes.misref;
1356	}
1357	}else if( get_link_ref(rndr, link, title, id_data, id_size)<0 ){
1358	goto char_link_cleanup;
1359	}
1360
1361	i = id_end+1;
1362
1363	/* shortcut reference style link */
1364	}else{
1365	if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){
1366	goto char_link_cleanup;
1367	}
	@@ -1375,16 +1403,18 @@
1375	else parse_inline(content, rndr, data+1, txt_e-1);
1376	}
1377
1378	/* calling the relevant rendering function */
1379	if( is_img ){
1380	if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ) ob->nUsed--;


1381	ret = rndr->make.image(ob, link, title, content, rndr->make.opaque);
1382	}else if(fn){
1383	if( rndr->make.footnote_ref ){
1384	ret = rndr->make.footnote_ref(ob, content, &fn->upc, fn->iMark, fn->nUsed,
1385	rndr->make.opaque);
1386	}
1387	}else{
1388	ret = rndr->make.link(ob, link, title, content, rndr->make.opaque);
1389	}
1390
	@@ -1393,11 +1423,10 @@
1393	release_work_buffer(rndr, title);
1394	release_work_buffer(rndr, link);
1395	release_work_buffer(rndr, content);
1396	return ret ? i : 0;
1397	}
1398
1399
1400
1401	/*********************************
1402	* BLOCK-LEVEL PARSING FUNCTIONS *
1403	*********************************/
	@@ -2532,18 +2561,19 @@
2532	while( indent<end && data[indent]==' ' ){ indent++; }
2533	if( indent>=end ) goto footnote_finish;
2534	indent -= i;
2535	if( indent<2 ) goto footnote_finish;
2536
2537	/* process the 2nd and the following lines */
2538	while( i+indent<end && memcmp(data+i,spaces,indent)==0 ){
2539	size_t j;
2540	i += indent;
2541	if( !upc_offset ){
2542	/* a classlist must be provided no later than at the 2nd line */
2543	upc_offset = i + sizeof_blank_prefix(data+i, end-i, 1);
2544	upc_size = is_footnote_classlist(data+upc_offset, end-upc_offset, 1);

2545	if( upc_size ){
2546	i = upc_offset + upc_size;
2547	}
2548	}
2549	j = i;
	@@ -2599,11 +2629,11 @@
2599	struct link_ref *lr;
2600	struct footnote *fn;
2601	size_t i, beg, end = 0;
2602	struct render rndr;
2603	Blob text = BLOB_INITIALIZER; /* input after the first pass */
2604	Blob *allNotes = &rndr.notes.all;
2605
2606	/* filling the render structure */
2607	if( !rndrer ) return;
2608	rndr.make = *rndrer;
2609	rndr.nBlobCache = 0;
2610

	--- src/markdown.c
	+++ src/markdown.c
	@@ -118,11 +118,13 @@
118
119	/**********************
120	* EXPORTED FUNCTIONS *
121	**********************/
122
123	/*
124	** markdown -- parses the input buffer and renders it into the output buffer.
125	*/
126	void markdown(
127	struct Blob *ob,
128	const struct Blob *ib,
129	const struct mkd_renderer *rndr);
130
	@@ -135,18 +137,21 @@
137
138	/***************
139	* LOCAL TYPES *
140	***************/
141
142	/*
143	** link_ref -- reference to a link.
144	*/
145	struct link_ref {
146	struct Blob id; /* must be the first field as in footnote struct */
147	struct Blob link;
148	struct Blob title;
149	};
150
151	/*
152	** A footnote's data.
153	** id, text, and upc fields must be in that particular order.
154	*/
155	struct footnote {
156	struct Blob id; /* must be the first field as in link_ref struct */
157	struct Blob text; /* footnote's content that is rendered at the end */
	@@ -216,12 +221,14 @@
221
222	/***************************
223	* STATIC HELPER FUNCTIONS *
224	***************************/
225
226	/*
227	** build_ref_id -- collapse whitespace from input text to make it a ref id.
228	** Potential TODO: maybe also handle CR+LF line endings?
229	*/
230	static int build_ref_id(struct Blob id, const char data, size_t size){
231	size_t beg, i;
232	char *id_data;
233
234	/* skip leading whitespace */
	@@ -276,13 +283,15 @@
283	struct link_ref lra = (void )a;
284	struct link_ref lrb = (void )b;
285	return blob_compare(&lra->id, &lrb->id);
286	}
287
288	/*
289	** cmp_footnote_id -- comparison function for footnotes qsort.
290	** Empty IDs sort last (in undetermined order).
291	** Equal IDs are sorted in the order of definition in the source.
292	*/
293	static int cmp_footnote_id(const void fna, const void fnb){
294	const struct footnote a = fna, b = fnb;
295	const int szA = blob_size(&a->id), szB = blob_size(&b->id);
296	if( szA ){
297	if( szB ){
	@@ -295,13 +304,15 @@
304	if( a->defno > b->defno ) return 1;
305	assert(!"reachable");
306	return 0; /* should never reach here */
307	}
308
309	/*
310	** cmp_footnote_sort -- comparison function for footnotes qsort.
311	** Unreferenced footnotes (when nUsed == 0) sort last and
312	** are sorted in the order of definition in the source.
313	*/
314	static int cmp_footnote_sort(const void fna, const void fnb){
315	const struct footnote a = fna, b = fnb;
316	int i, j;
317	assert( a->nUsed >= 0 );
318	assert( b->nUsed >= 0 );
	@@ -652,12 +663,14 @@
663	if( fossil_isalnum(after) ) return 0;
664	return 1;
665	}
666
667
668	/*
669	** parse_emph1 -- parsing single emphasis.
670	** closed by a symbol not preceded by whitespace and not followed by symbol.
671	*/
672	static size_t parse_emph1(
673	struct Blob *ob,
674	struct render *rndr,
675	char *data,
676	size_t size,
	@@ -697,12 +710,13 @@
710	}
711	}
712	return 0;
713	}
714
715	/*
716	** parse_emph2 -- parsing single emphasis.
717	*/
718	static size_t parse_emph2(
719	struct Blob *ob,
720	struct render *rndr,
721	char *data,
722	size_t size,
	@@ -736,13 +750,14 @@
750	i++;
751	}
752	return 0;
753	}
754
755	/*
756	** parse_emph3 -- parsing single emphasis.
757	** finds the first closing tag, and delegates to the other emph.
758	*/
759	static size_t parse_emph3(
760	struct Blob *ob,
761	struct render *rndr,
762	char *data,
763	size_t size,
	@@ -784,12 +799,13 @@
799	}
800	}
801	return 0;
802	}
803
804	/*
805	** char_emphasis -- single and double emphasis parsing.
806	*/
807	static size_t char_emphasis(
808	struct Blob *ob,
809	struct render *rndr,
810	char *data,
811	size_t offset,
	@@ -829,12 +845,13 @@
845	return ret+3;
846	}
847	return 0;
848	}
849
850	/*
851	** char_linebreak -- '\n' preceded by two spaces (assuming linebreak != 0).
852	*/
853	static size_t char_linebreak(
854	struct Blob *ob,
855	struct render *rndr,
856	char *data,
857	size_t offset,
	@@ -844,12 +861,13 @@
861	/* removing the last space from ob and rendering */
862	if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]==' ' ) ob->nUsed--;
863	return rndr->make.linebreak(ob, rndr->make.opaque) ? 1 : 0;
864	}
865
866	/*
867	** char_codespan -- '`' parsing a code span (assuming codespan != 0).
868	*/
869	static size_t char_codespan(
870	struct Blob *ob,
871	struct render *rndr,
872	char *data,
873	size_t offset,
	@@ -886,11 +904,13 @@
904	}
905	return end;
906	}
907
908
909	/*
910	** char_escape -- '\\' backslash escape.
911	*/
912	static size_t char_escape(
913	struct Blob *ob,
914	struct render *rndr,
915	char *data,
916	size_t offset,
	@@ -906,13 +926,14 @@
926	}
927	}
928	return 2;
929	}
930
931	/*
932	** char_entity -- '&' escaped when it doesn't belong to an entity.
933	** valid entities are assumed to be anything matching &#?[A-Za-z0-9]+;
934	*/
935	static size_t char_entity(
936	struct Blob *ob,
937	struct render *rndr,
938	char *data,
939	size_t offset,
	@@ -942,12 +963,13 @@
963	blob_append(ob, data, end);
964	}
965	return end;
966	}
967
968	/*
969	** char_langle_tag -- '<' when tags or autolinks are allowed.
970	*/
971	static size_t char_langle_tag(
972	struct Blob *ob,
973	struct render *rndr,
974	char *data,
975	size_t offset,
	@@ -972,12 +994,12 @@
994	}else{
995	return end;
996	}
997	}
998
999	/*
1000	** get_link_inline -- extract inline-style link and title from
1001	** parenthesed data
1002	*/
1003	static int get_link_inline(
1004	struct Blob *link,
1005	struct Blob *title,
	@@ -1048,11 +1070,13 @@
1070	/* this function always succeed */
1071	return 0;
1072	}
1073
1074
1075	/*
1076	** get_link_ref -- extract referenced link and title from id.
1077	*/
1078	static int get_link_ref(
1079	struct render *rndr,
1080	struct Blob *link,
1081	struct Blob *title,
1082	char *data,
	@@ -1076,13 +1100,15 @@
1100	blob_appendb(link, &lr->link);
1101	blob_appendb(title, &lr->title);
1102	return 0;
1103	}
1104
1105	/*
1106	** get_footnote() -- find a footnote by label, invoked during the 2nd pass.
1107	** On success returns a footnote (after incrementing its nUsed field),
1108	** otherwise returns NULL.
1109	*/
1110	static const struct footnote* get_footnote(
1111	struct render *rndr,
1112	const char *data,
1113	size_t size
1114	){
	@@ -1105,14 +1131,15 @@
1131	cleanup:
1132	release_work_buffer( rndr, id );
1133	return fn;
1134	}
1135
1136	/*
1137	** Counts characters in the blank prefix within at most nHalfLines.
1138	** A sequence of spaces and tabs counts as odd halfline,
1139	** a newline counts as even halfline.
1140	** If nHalfLines < 0 then proceed without constraints.
1141	*/
1142	static inline size_t sizeof_blank_prefix(
1143	const char *data, size_t size, int nHalfLines
1144	){
1145	const char *p = data;
	@@ -1134,22 +1161,24 @@
1161	nHalfLines--;
1162	}
1163	return p-data;
1164	}
1165
1166	/*
1167	** Check if the data starts with a classlist token of the special form.
1168	** If so then return the length of that token, otherwise return 0.
1169	**
1170	** The token must start with a dot and must end with a colon;
1171	** in between of these it must be a dot-separated list of words;
1172	** each word may contain only alphanumeric characters and hyphens.
1173	**
1174	** If `bBlank` is non-zero then a blank character must follow
1175	** the token's ending colon: otherwise function returns 0
1176	** despite the well-formed token.
1177	*/
1178	static size_t is_footnote_classlist(const char * const data, size_t size,
1179	int bBlank){
1180	const char *p;
1181	const char * const end = data+size;
1182	if( data==end \|\| *data != '.' ) return 0;
1183	for(p=data+1; p!=end; p++){
1184	if( fossil_isalnum(p) \|\| p=='-' ) continue;
	@@ -1164,13 +1193,16 @@
1193	if( *p!='.' ) break;
1194	}
1195	return 0;
1196	}
1197
1198	/*
1199	** Adds unlabeled footnote to the rndr. If text is blank then returns
1200	** 0, otherwise returns the address of the added footnote, which lives
1201	** in rndr->notes, noting that the pointer may be invalidated via
1202	** reallocation the next time a footnote is added to that member.
1203	*/
1204	static inline const struct footnote* add_inline_footnote(
1205	struct render *rndr,
1206	const char *text,
1207	size_t size
1208	){
	@@ -1202,12 +1234,13 @@
1234	blob_append(&rndr->notes.all, (char *)&fn, sizeof fn);
1235	return (struct footnote*)( blob_buffer(&rndr->notes.all)
1236	+( blob_size(&rndr->notes.all)-sizeof fn ));
1237	}
1238
1239	/*
1240	** Return the byte offset of the matching closing bracket or 0 if not
1241	** found. begin[0] must be either '[' or '('.
1242	**
1243	** TODO: It seems that things like "\\(" are not handled correctly.
1244	** That is historical behavior for a corner-case,
1245	** so it's left as it is until somebody complains.
1246	*/
	@@ -1229,11 +1262,13 @@
1262	}
1263	}
1264	return 0;
1265	}
1266
1267	/*
1268	** char_footnote -- '(': parsing a standalone inline footnote.
1269	*/
1270	static size_t char_footnote(
1271	struct Blob *ob,
1272	struct render *rndr,
1273	char *data,
1274	size_t offset,
	@@ -1251,11 +1286,13 @@
1286	rndr->make.footnote_ref(ob,0,&fn->upc,fn->iMark,1,rndr->make.opaque);
1287	}
1288	return end+1;
1289	}
1290
1291	/*
1292	** char_link -- '[': parsing a link or an image.
1293	*/
1294	static size_t char_link(
1295	struct Blob *ob,
1296	struct render *rndr,
1297	char *data,
1298	size_t offset,
	@@ -1288,11 +1325,11 @@
1325	fn = &rndr->notes.misref;
1326	}
1327	}else{
1328
1329	/* skip "inter-bracket-whitespace" - any amount of whitespace or newline */
1330	/* (this is much more lax than original markdown syntax) */
1331	while( i<size && (data[i]==' ' \|\| data[i]=='\t' \|\| data[i]=='\n') ){ i++; }
1332
1333	/* allocate temporary buffers to store content, link and title */
1334	title = new_work_buffer(rndr);
1335	content = new_work_buffer(rndr);
	@@ -1307,35 +1344,29 @@
1344	fn = add_inline_footnote(rndr, data+(i+2), k-2);
1345	i += k+1;
1346	}else{ /* inline style link */
1347	size_t span_end = i;
1348	while( span_end<size
1349	&& !(data[span_end]==')'
1350	&& (span_end==i \|\| data[span_end-1]!='\\')) ){
1351	span_end++;
1352	}

1353	if( span_end>=size
1354	\|\| get_link_inline(link, title, data+i+1, span_end-(i+1))<0 ){

1355	goto char_link_cleanup;
1356	}

1357	i = span_end+1;
1358	}

1359	/* reference style link or span-bounded footnote reference */
1360	}else if( i<size && data[i]=='[' ){
1361	char *id_data;
1362	size_t id_size, id_end = i;
1363	int bFootnote;
1364
1365	while( id_end<size && data[id_end]!=']' ){ id_end++; }

1366	if( id_end>=size ) goto char_link_cleanup;
1367	bFootnote = data[i+1]=='^';

1368	if( i+1==id_end \|\| (bFootnote && i+2==id_end) ){
1369	/* implicit id - use the contents */
1370	id_data = data+1;
1371	id_size = txt_e-1;
1372	}else{
	@@ -1345,23 +1376,20 @@
1376	if( bFootnote ){
1377	id_data++;
1378	id_size--;
1379	}
1380	}

1381	if( bFootnote ){
1382	fn = get_footnote(rndr, id_data, id_size);
1383	if( !fn ) {
1384	rndr->notes.misref.nUsed++;
1385	fn = &rndr->notes.misref;
1386	}
1387	}else if( get_link_ref(rndr, link, title, id_data, id_size)<0 ){
1388	goto char_link_cleanup;
1389	}

1390	i = id_end+1;

1391	/* shortcut reference style link */
1392	}else{
1393	if( get_link_ref(rndr, link, title, data+1, txt_e-1)<0 ){
1394	goto char_link_cleanup;
1395	}
	@@ -1375,16 +1403,18 @@
1403	else parse_inline(content, rndr, data+1, txt_e-1);
1404	}
1405
1406	/* calling the relevant rendering function */
1407	if( is_img ){
1408	if( blob_size(ob)>0 && blob_buffer(ob)[blob_size(ob)-1]=='!' ){
1409	ob->nUsed--;
1410	}
1411	ret = rndr->make.image(ob, link, title, content, rndr->make.opaque);
1412	}else if( fn ){
1413	if( rndr->make.footnote_ref ){
1414	ret = rndr->make.footnote_ref(ob, content, &fn->upc, fn->iMark,
1415	fn->nUsed, rndr->make.opaque);
1416	}
1417	}else{
1418	ret = rndr->make.link(ob, link, title, content, rndr->make.opaque);
1419	}
1420
	@@ -1393,11 +1423,10 @@
1423	release_work_buffer(rndr, title);
1424	release_work_buffer(rndr, link);
1425	release_work_buffer(rndr, content);
1426	return ret ? i : 0;
1427	}

1428
1429
1430	/*********************************
1431	* BLOCK-LEVEL PARSING FUNCTIONS *
1432	*********************************/
	@@ -2532,18 +2561,19 @@
2561	while( indent<end && data[indent]==' ' ){ indent++; }
2562	if( indent>=end ) goto footnote_finish;
2563	indent -= i;
2564	if( indent<2 ) goto footnote_finish;
2565
2566	/* process the 2nd and subsequent lines */
2567	while( i+indent<end && memcmp(data+i,spaces,indent)==0 ){
2568	size_t j;
2569	i += indent;
2570	if( !upc_offset ){
2571	/* a classlist must be provided no later than at the 2nd line */
2572	upc_offset = i + sizeof_blank_prefix(data+i, end-i, 1);
2573	upc_size = is_footnote_classlist(data+upc_offset,
2574	end-upc_offset, 1);
2575	if( upc_size ){
2576	i = upc_offset + upc_size;
2577	}
2578	}
2579	j = i;
	@@ -2599,11 +2629,11 @@
2629	struct link_ref *lr;
2630	struct footnote *fn;
2631	size_t i, beg, end = 0;
2632	struct render rndr;
2633	Blob text = BLOB_INITIALIZER; /* input after the first pass */
2634	Blob * const allNotes = &rndr.notes.all;
2635
2636	/* filling the render structure */
2637	if( !rndrer ) return;
2638	rndr.make = *rndrer;
2639	rndr.nBlobCache = 0;
2640

M src/markdown.md

+1 -1

		--- src/markdown.md
		+++ src/markdown.md
		@@ -180,11 +180,11 @@
180	180	> ```
181	181	> [^label]: Footnote definition must start on the first column.
182	182	> The second line (if any) must be indented by two or more spaces.
183	183	> Definition continues until indentation drops below that of the 2nd line.
184	184	>```
185		-> Charachter ^ is not part of a label, it is part of the syntax.
	185	+> Character ^ is not part of a label, it is part of the syntax.
186	186	> Both a footnote's text and a fragment to which a footnote applies
187	187	> are subject to further interpretation as Markdown sources.
188	188
189	189	## Miscellaneous ##
190	190
191	191

	--- src/markdown.md
	+++ src/markdown.md
	@@ -180,11 +180,11 @@
180	> ```
181	> [^label]: Footnote definition must start on the first column.
182	> The second line (if any) must be indented by two or more spaces.
183	> Definition continues until indentation drops below that of the 2nd line.
184	>```
185	> Charachter ^ is not part of a label, it is part of the syntax.
186	> Both a footnote's text and a fragment to which a footnote applies
187	> are subject to further interpretation as Markdown sources.
188
189	## Miscellaneous ##
190
191

	--- src/markdown.md
	+++ src/markdown.md
	@@ -180,11 +180,11 @@
180	> ```
181	> [^label]: Footnote definition must start on the first column.
182	> The second line (if any) must be indented by two or more spaces.
183	> Definition continues until indentation drops below that of the 2nd line.
184	>```
185	> Character ^ is not part of a label, it is part of the syntax.
186	> Both a footnote's text and a fragment to which a footnote applies
187	> are subject to further interpretation as Markdown sources.
188
189	## Miscellaneous ##
190
191

M src/markdown_html.c

+84 -88

		--- src/markdown_html.c
		+++ src/markdown_html.c
		@@ -29,11 +29,19 @@
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;
	34	+/*
	35	+** Markdown-internal helper for generating unique link reference IDs.
	36	+*/
	37	+typedef union bitfield64_t bitfield64_t;
	38	+union bitfield64_t{
	39	+ uint64_t u;
	40	+ char c[8];
	41	+ unsigned char b[8];
	42	+};
35	43
36	44	/*
37	45	** An instance of the following structure is passed through the
38	46	** "opaque" pointer.
39	47	*/
		@@ -50,20 +58,10 @@
50	58
51	59	/* INTER_BLOCK -- skip a line between block level elements */
52	60	#define INTER_BLOCK(ob) \
53	61	do { if( blob_size(ob)>0 ) blob_append_char(ob, '\n'); } while (0)
54	62
55		-/* BLOB_APPEND_LITERAL -- append a string literal to a blob
56		-** TODO: Refactor all invocations to use global macro blob_append_literal()
57		-*/
58		-#define BLOB_APPEND_LITERAL blob_append_literal
59		-
60		-/* BLOB_APPEND_BLOB -- append blob contents to another
61		-** TODO: Refactor all invocations to use global macro blob_appendb()
62		-*/
63		-#define BLOB_APPEND_BLOB(dest, src) blob_appendb((dest), (src))
64		-
65	63	#ifndef FOOTNOTES_WITHOUT_URI
66	64	#define BLOB_APPEND_URI(dest,ctx) blob_appendb(dest,&((ctx)->reqURI))
67	65	#else
68	66	#define BLOB_APPEND_URI(dest,ctx)
69	67	#endif
		@@ -106,19 +104,19 @@
106	104	i++;
107	105	}
108	106	blob_append(ob, data+beg, i-beg);
109	107	while( i<size ){
110	108	if( data[i]=='<' ){
111		- BLOB_APPEND_LITERAL(ob, "<");
	109	+ blob_append_literal(ob, "<");
112	110	}else if( data[i]=='>' ){
113		- BLOB_APPEND_LITERAL(ob, ">");
	111	+ blob_append_literal(ob, ">");
114	112	}else if( data[i]=='&' ){
115		- BLOB_APPEND_LITERAL(ob, "&");
	113	+ blob_append_literal(ob, "&");
116	114	}else if( data[i]=='"' ){
117		- BLOB_APPEND_LITERAL(ob, """);
	115	+ blob_append_literal(ob, """);
118	116	}else if( data[i]=='\'' ){
119		- BLOB_APPEND_LITERAL(ob, "'");
	117	+ blob_append_literal(ob, "'");
120	118	}else{
121	119	break;
122	120	}
123	121	i++;
124	122	}
		@@ -136,15 +134,15 @@
136	134	i++;
137	135	}
138	136	blob_append(ob, data+beg, i-beg);
139	137	while( i<size ){
140	138	if( data[i]=='<' ){
141		- BLOB_APPEND_LITERAL(ob, "<");
	139	+ blob_append_literal(ob, "<");
142	140	}else if( data[i]=='>' ){
143		- BLOB_APPEND_LITERAL(ob, ">");
	141	+ blob_append_literal(ob, ">");
144	142	}else if( data[i]=='&' ){
145		- BLOB_APPEND_LITERAL(ob, "&");
	143	+ blob_append_literal(ob, "&");
146	144	}else{
147	145	break;
148	146	}
149	147	i++;
150	148	}
		@@ -157,17 +155,17 @@
157	155	/* Size of the prolog: "<div class='markdown'>\n" */
158	156	#define PROLOG_SIZE 23
159	157
160	158	static void html_prolog(struct Blob ob, void opaque){
161	159	INTER_BLOCK(ob);
162		- BLOB_APPEND_LITERAL(ob, "<div class=\"markdown\">\n");
	160	+ blob_append_literal(ob, "<div class=\"markdown\">\n");
163	161	assert( blob_size(ob)==PROLOG_SIZE );
164	162	}
165	163
166	164	static void html_epilog(struct Blob ob, void opaque){
167	165	INTER_BLOCK(ob);
168		- BLOB_APPEND_LITERAL(ob, "</div>\n");
	166	+ blob_append_literal(ob, "</div>\n");
169	167	}
170	168
171	169	static void html_blockhtml(struct Blob ob, struct Blob text, void *opaque){
172	170	char *data = blob_buffer(text);
173	171	size_t size = blob_size(text);
		@@ -185,25 +183,25 @@
185	183	blob_append(title, data+nTag, size - nTag - 5);
186	184	return;
187	185	}
188	186	INTER_BLOCK(ob);
189	187	blob_append(ob, data, size);
190		- BLOB_APPEND_LITERAL(ob, "\n");
	188	+ blob_append_literal(ob, "\n");
191	189	}
192	190
193	191	static void html_blockcode(struct Blob ob, struct Blob text, void *opaque){
194	192	INTER_BLOCK(ob);
195		- BLOB_APPEND_LITERAL(ob, "<pre><code>");
	193	+ blob_append_literal(ob, "<pre><code>");
196	194	html_escape(ob, blob_buffer(text), blob_size(text));
197		- BLOB_APPEND_LITERAL(ob, "</code></pre>\n");
	195	+ blob_append_literal(ob, "</code></pre>\n");
198	196	}
199	197
200	198	static void html_blockquote(struct Blob ob, struct Blob text, void *opaque){
201	199	INTER_BLOCK(ob);
202		- BLOB_APPEND_LITERAL(ob, "<blockquote>\n");
203		- BLOB_APPEND_BLOB(ob, text);
204		- BLOB_APPEND_LITERAL(ob, "</blockquote>\n");
	200	+ blob_append_literal(ob, "<blockquote>\n");
	201	+ blob_appendb(ob, text);
	202	+ blob_append_literal(ob, "</blockquote>\n");
205	203	}
206	204
207	205	static void html_header(
208	206	struct Blob *ob,
209	207	struct Blob *text,
		@@ -212,22 +210,22 @@
212	210	){
213	211	struct Blob title = ((MarkdownToHtml)opaque)->output_title;
214	212	/* The first header at the beginning of a text is considered as
215	213	* a title and not output. */
216	214	if( blob_size(ob)<=PROLOG_SIZE && title!=0 && blob_size(title)==0 ){
217		- BLOB_APPEND_BLOB(title, text);
	215	+ blob_appendb(title, text);
218	216	return;
219	217	}
220	218	INTER_BLOCK(ob);
221	219	blob_appendf(ob, "<h%d>", level);
222		- BLOB_APPEND_BLOB(ob, text);
	220	+ blob_appendb(ob, text);
223	221	blob_appendf(ob, "</h%d>", level);
224	222	}
225	223
226	224	static void html_hrule(struct Blob ob, void opaque){
227	225	INTER_BLOCK(ob);
228		- BLOB_APPEND_LITERAL(ob, "<hr />\n");
	226	+ blob_append_literal(ob, "<hr />\n");
229	227	}
230	228
231	229
232	230	static void html_list(
233	231	struct Blob *ob,
		@@ -238,11 +236,11 @@
238	236	char ol[] = "ol";
239	237	char ul[] = "ul";
240	238	char *tag = (flags & MKD_LIST_ORDERED) ? ol : ul;
241	239	INTER_BLOCK(ob);
242	240	blob_appendf(ob, "<%s>\n", tag);
243		- BLOB_APPEND_BLOB(ob, text);
	241	+ blob_appendb(ob, text);
244	242	blob_appendf(ob, "</%s>\n", tag);
245	243	}
246	244
247	245	static void html_list_item(
248	246	struct Blob *ob,
		@@ -251,20 +249,20 @@
251	249	void *opaque
252	250	){
253	251	char *text_data = blob_buffer(text);
254	252	size_t text_size = blob_size(text);
255	253	while( text_size>0 && text_data[text_size-1]=='\n' ) text_size--;
256		- BLOB_APPEND_LITERAL(ob, "<li>");
	254	+ blob_append_literal(ob, "<li>");
257	255	blob_append(ob, text_data, text_size);
258		- BLOB_APPEND_LITERAL(ob, "</li>\n");
	256	+ blob_append_literal(ob, "</li>\n");
259	257	}
260	258
261	259	static void html_paragraph(struct Blob ob, struct Blob text, void *opaque){
262	260	INTER_BLOCK(ob);
263		- BLOB_APPEND_LITERAL(ob, "<p>");
264		- BLOB_APPEND_BLOB(ob, text);
265		- BLOB_APPEND_LITERAL(ob, "</p>\n");
	261	+ blob_append_literal(ob, "<p>");
	262	+ blob_appendb(ob, text);
	263	+ blob_append_literal(ob, "</p>\n");
266	264	}
267	265
268	266
269	267	static void html_table(
270	268	struct Blob *ob,
		@@ -271,84 +269,85 @@
271	269	struct Blob *head_row,
272	270	struct Blob *rows,
273	271	void *opaque
274	272	){
275	273	INTER_BLOCK(ob);
276		- BLOB_APPEND_LITERAL(ob, "<table>\n");
	274	+ blob_append_literal(ob, "<table>\n");
277	275	if( head_row && blob_size(head_row)>0 ){
278		- BLOB_APPEND_LITERAL(ob, "<thead>\n");
279		- BLOB_APPEND_BLOB(ob, head_row);
280		- BLOB_APPEND_LITERAL(ob, "</thead>\n<tbody>\n");
	276	+ blob_append_literal(ob, "<thead>\n");
	277	+ blob_appendb(ob, head_row);
	278	+ blob_append_literal(ob, "</thead>\n<tbody>\n");
281	279	}
282	280	if( rows ){
283		- BLOB_APPEND_BLOB(ob, rows);
	281	+ blob_appendb(ob, rows);
284	282	}
285	283	if( head_row && blob_size(head_row)>0 ){
286		- BLOB_APPEND_LITERAL(ob, "</tbody>\n");
	284	+ blob_append_literal(ob, "</tbody>\n");
287	285	}
288		- BLOB_APPEND_LITERAL(ob, "</table>\n");
	286	+ blob_append_literal(ob, "</table>\n");
289	287	}
290	288
291	289	static void html_table_cell(
292	290	struct Blob *ob,
293	291	struct Blob *text,
294	292	int flags,
295	293	void *opaque
296	294	){
297	295	if( flags & MKD_CELL_HEAD ){
298		- BLOB_APPEND_LITERAL(ob, " <th");
	296	+ blob_append_literal(ob, " <th");
299	297	}else{
300		- BLOB_APPEND_LITERAL(ob, " <td");
	298	+ blob_append_literal(ob, " <td");
301	299	}
302	300	switch( flags & MKD_CELL_ALIGN_MASK ){
303	301	case MKD_CELL_ALIGN_LEFT: {
304		- BLOB_APPEND_LITERAL(ob, " align=\"left\"");
	302	+ blob_append_literal(ob, " align=\"left\"");
305	303	break;
306	304	}
307	305	case MKD_CELL_ALIGN_RIGHT: {
308		- BLOB_APPEND_LITERAL(ob, " align=\"right\"");
	306	+ blob_append_literal(ob, " align=\"right\"");
309	307	break;
310	308	}
311	309	case MKD_CELL_ALIGN_CENTER: {
312		- BLOB_APPEND_LITERAL(ob, " align=\"center\"");
	310	+ blob_append_literal(ob, " align=\"center\"");
313	311	break;
314	312	}
315	313	}
316		- BLOB_APPEND_LITERAL(ob, ">");
317		- BLOB_APPEND_BLOB(ob, text);
	314	+ blob_append_literal(ob, ">");
	315	+ blob_appendb(ob, text);
318	316	if( flags & MKD_CELL_HEAD ){
319		- BLOB_APPEND_LITERAL(ob, "</th>\n");
	317	+ blob_append_literal(ob, "</th>\n");
320	318	}else{
321		- BLOB_APPEND_LITERAL(ob, "</td>\n");
	319	+ blob_append_literal(ob, "</td>\n");
322	320	}
323	321	}
324	322
325	323	static void html_table_row(
326	324	struct Blob *ob,
327	325	struct Blob *cells,
328	326	int flags,
329	327	void *opaque
330	328	){
331		- BLOB_APPEND_LITERAL(ob, " <tr>\n");
332		- BLOB_APPEND_BLOB(ob, cells);
333		- BLOB_APPEND_LITERAL(ob, " </tr>\n");
	329	+ blob_append_literal(ob, " <tr>\n");
	330	+ blob_appendb(ob, cells);
	331	+ blob_append_literal(ob, " </tr>\n");
334	332	}
335	333
336		-/* Render a token of user provided classes.
	334	+/*
	335	+** Render a token of user provided classes.
337	336	** If bHTML is true then render HTML for (presumably) visible text,
338		-** otherwise just a space-separated list of the derived classes
	337	+** otherwise just a space-separated list of the derived classes.
339	338	*/
340	339	static void append_footnote_upc(
341	340	struct Blob *ob,
342	341	const struct Blob upc, / token of user-provided classes */
343	342	int bHTML
344	343	){
345	344	const char *z = blob_buffer(upc);
346	345	int i, n = blob_size(upc);
	346	+
347	347	if( n<3 ) return;
348	348	assert( z[0]=='.' && z[n-1] == ':' );
349		-
350	349	if( bHTML ){
351	350	blob_append_literal(ob, "<span class='fn-upc'>"
352	351	"<span class='fn-upcDot'>.</span>");
353	352	}
354	353	n = 0;
		@@ -394,29 +393,28 @@
394	393	char pos[32];
395	394	memset(pos,0,32);
396	395	assert( locus > 0 );
397	396	/* expect BUGs if the following yields compiler warnings */
398	397	if( iMark > 0 ){ /* a regular reference to a footnote */
399		-
400		- sprintf(pos, "%s-%i-%s", ctx->unique.c, iMark, l.c);
	398	+ sprintf(pos, "%s-%d-%s", ctx->unique.c, iMark, l.c);
401	399	if(span && blob_size(span)) {
402	400	blob_append_literal(ob,"<span class='");
403	401	append_footnote_upc(ob, upc, 0);
404	402	blob_append_literal(ob,"notescope' id='noteref");
405	403	blob_appendf(ob,"%s'>",pos);
406	404	blob_appendb(ob, span);
407	405	blob_trim(ob);
408	406	blob_append_literal(ob,"<sup class='noteref'><a href='");
409	407	BLOB_APPEND_URI(ob, ctx);
410		- blob_appendf(ob,"#footnote%s'>%i</a></sup></span>", pos, iMark);
	408	+ blob_appendf(ob,"#footnote%s'>%d</a></sup></span>", pos, iMark);
411	409	}else{
412	410	blob_trim(ob);
413	411	blob_append_literal(ob,"<sup class='");
414	412	append_footnote_upc(ob, upc, 0);
415	413	blob_append_literal(ob,"noteref'><a href='");
416	414	BLOB_APPEND_URI(ob, ctx);
417		- blob_appendf(ob,"#footnote%s' id='noteref%s'>%i</a></sup>",
	415	+ blob_appendf(ob,"#footnote%s' id='noteref%s'>%d</a></sup>",
418	416	pos, pos, iMark);
419	417	}
420	418	}else{ /* misreference */
421	419	assert( iMark == -1 );
422	420
		@@ -470,21 +468,19 @@
470	468	blob_appendf(ob,"#misref%s-%c'>%c</a>", unique,c, c);
471	469	}
472	470	if( i < nUsed ) blob_append_literal(ob," …");
473	471	}
474	472	blob_append_literal(ob,"</sup>\n<span>Misreference</span>");
475		-
476	473	}else if( iMark > 0 ){ /* regular, joined and overnested footnotes */
477	474	char pos[24];
478	475	int bJoin = 0;
479	476	#define _joined_footnote_indicator "<ul class='fn-joined'>"
480	477	#define _jfi_sz (sizeof(_joined_footnote_indicator)-1)
481	478	assert( text );
482	479	assert( blob_size(text) );
483	480	memset(pos,0,24);
484		- sprintf(pos, "%s-%i", unique, iMark);
485		-
	481	+ sprintf(pos, "%s-%d", unique, iMark);
486	482	blob_appendf(ob, "<li id='footnote%s' class='", pos);
487	483	if( nUsed ){
488	484	if( blob_size(text)>=_jfi_sz &&
489	485	!memcmp(blob_buffer(text),_joined_footnote_indicator,_jfi_sz)){
490	486	bJoin = 1;
		@@ -492,11 +488,10 @@
492	488	}
493	489	append_footnote_upc(ob, upc, 0);
494	490	}else{
495	491	blob_append_literal(ob, "fn-toodeep ");
496	492	}
497		-
498	493	if( nUsed <= 1 ){
499	494	blob_append_literal(ob, "fn-monoref'><sup class='fn-backrefs'>");
500	495	blob_appendf(ob,"<a id='footnote%s-a' href='", pos);
501	496	BLOB_APPEND_URI(ob, ctx);
502	497	blob_appendf(ob,"#noteref%s-a'>^</a>", pos);
		@@ -554,10 +549,11 @@
554	549	html_escape(ob, blob_buffer(text), blob_size(text));
555	550	blob_append_literal(ob,"</code></pre>");
556	551	}
557	552	blob_append_literal(ob, "\n</li>\n");
558	553	}
	554	+
559	555	static void html_footnotes(
560	556	struct Blob ob, const struct Blob items, void *opaque
561	557	){
562	558	if( items && blob_size(items) ){
563	559	blob_append_literal(ob,
		@@ -579,21 +575,21 @@
579	575	struct Blob *link,
580	576	enum mkd_autolink type,
581	577	void *opaque
582	578	){
583	579	if( !link \|\| blob_size(link)<=0 ) return 0;
584		- BLOB_APPEND_LITERAL(ob, "<a href=\"");
585		- if( type==MKDA_IMPLICIT_EMAIL ) BLOB_APPEND_LITERAL(ob, "mailto:");
	580	+ blob_append_literal(ob, "<a href=\"");
	581	+ if( type==MKDA_IMPLICIT_EMAIL ) blob_append_literal(ob, "mailto:");
586	582	html_quote(ob, blob_buffer(link), blob_size(link));
587		- BLOB_APPEND_LITERAL(ob, "\">");
	583	+ blob_append_literal(ob, "\">");
588	584	if( type==MKDA_EXPLICIT_EMAIL && blob_size(link)>7 ){
589	585	/* remove "mailto:" from displayed text */
590	586	html_escape(ob, blob_buffer(link)+7, blob_size(link)-7);
591	587	}else{
592	588	html_escape(ob, blob_buffer(link), blob_size(link));
593	589	}
594		- BLOB_APPEND_LITERAL(ob, "</a>");
	590	+ blob_append_literal(ob, "</a>");
595	591	return 1;
596	592	}
597	593
598	594	/*
599	595	** The nSrc bytes at zSrc[] are Pikchr input text (allegedly). Process that
		@@ -682,13 +678,13 @@
682	678	){
683	679	if( text==0 ){
684	680	/* no-op */
685	681	}else if( nSep<=2 ){
686	682	/* One or two graves: an in-line code span */
687		- BLOB_APPEND_LITERAL(ob, "<code>");
	683	+ blob_append_literal(ob, "<code>");
688	684	html_escape(ob, blob_buffer(text), blob_size(text));
689		- BLOB_APPEND_LITERAL(ob, "</code>");
	685	+ blob_append_literal(ob, "</code>");
690	686	}else{
691	687	/* Three or more graves: a fenced code block */
692	688	int n = blob_size(text);
693	689	const char *z = blob_buffer(text);
694	690	int i;
		@@ -720,25 +716,25 @@
720	716	struct Blob *ob,
721	717	struct Blob *text,
722	718	char c,
723	719	void *opaque
724	720	){
725		- BLOB_APPEND_LITERAL(ob, "<strong>");
726		- BLOB_APPEND_BLOB(ob, text);
727		- BLOB_APPEND_LITERAL(ob, "</strong>");
	721	+ blob_append_literal(ob, "<strong>");
	722	+ blob_appendb(ob, text);
	723	+ blob_append_literal(ob, "</strong>");
728	724	return 1;
729	725	}
730	726
731	727	static int html_emphasis(
732	728	struct Blob *ob,
733	729	struct Blob *text,
734	730	char c,
735	731	void *opaque
736	732	){
737		- BLOB_APPEND_LITERAL(ob, "<em>");
738		- BLOB_APPEND_BLOB(ob, text);
739		- BLOB_APPEND_LITERAL(ob, "</em>");
	733	+ blob_append_literal(ob, "<em>");
	734	+ blob_appendb(ob, text);
	735	+ blob_append_literal(ob, "</em>");
740	736	return 1;
741	737	}
742	738
743	739	static int html_image(
744	740	struct Blob *ob,
		@@ -745,24 +741,24 @@
745	741	struct Blob *link,
746	742	struct Blob *title,
747	743	struct Blob *alt,
748	744	void *opaque
749	745	){
750		- BLOB_APPEND_LITERAL(ob, "<img src=\"");
	746	+ blob_append_literal(ob, "<img src=\"");
751	747	html_quote(ob, blob_buffer(link), blob_size(link));
752		- BLOB_APPEND_LITERAL(ob, "\" alt=\"");
	748	+ blob_append_literal(ob, "\" alt=\"");
753	749	html_quote(ob, blob_buffer(alt), blob_size(alt));
754	750	if( title && blob_size(title)>0 ){
755		- BLOB_APPEND_LITERAL(ob, "\" title=\"");
	751	+ blob_append_literal(ob, "\" title=\"");
756	752	html_quote(ob, blob_buffer(title), blob_size(title));
757	753	}
758		- BLOB_APPEND_LITERAL(ob, "\" />");
	754	+ blob_append_literal(ob, "\" />");
759	755	return 1;
760	756	}
761	757
762	758	static int html_linebreak(struct Blob ob, void opaque){
763		- BLOB_APPEND_LITERAL(ob, "<br />\n");
	759	+ blob_append_literal(ob, "<br />\n");
764	760	return 1;
765	761	}
766	762
767	763	static int html_link(
768	764	struct Blob *ob,
		@@ -783,13 +779,13 @@
783	779	WIKI_MARKDOWNLINKS
784	780	;
785	781	wiki_resolve_hyperlink(ob, flags, zLink, zClose, sizeof(zClose), 0, zTitle);
786	782	}
787	783	if( blob_size(content)==0 ){
788		- if( link ) BLOB_APPEND_BLOB(ob, link);
	784	+ if( link ) blob_appendb(ob, link);
789	785	}else{
790		- BLOB_APPEND_BLOB(ob, content);
	786	+ blob_appendb(ob, content);
791	787	}
792	788	blob_append(ob, zClose, -1);
793	789	return 1;
794	790	}
795	791
		@@ -797,13 +793,13 @@
797	793	struct Blob *ob,
798	794	struct Blob *text,
799	795	char c,
800	796	void *opaque
801	797	){
802		- BLOB_APPEND_LITERAL(ob, "<strong><em>");
803		- BLOB_APPEND_BLOB(ob, text);
804		- BLOB_APPEND_LITERAL(ob, "</em></strong>");
	798	+ blob_append_literal(ob, "<strong><em>");
	799	+ blob_appendb(ob, text);
	800	+ blob_append_literal(ob, "</em></strong>");
805	801	return 1;
806	802	}
807	803
808	804
809	805	static void html_normal_text(struct Blob ob, struct Blob text, void *opaque){
810	806

	--- src/markdown_html.c
	+++ src/markdown_html.c
	@@ -29,11 +29,19 @@
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	*/
	@@ -50,20 +58,10 @@
50
51	/* INTER_BLOCK -- skip a line between block level elements */
52	#define INTER_BLOCK(ob) \
53	do { if( blob_size(ob)>0 ) blob_append_char(ob, '\n'); } while (0)
54
55	/* BLOB_APPEND_LITERAL -- append a string literal to a blob
56	** TODO: Refactor all invocations to use global macro blob_append_literal()
57	*/
58	#define BLOB_APPEND_LITERAL blob_append_literal
59
60	/* BLOB_APPEND_BLOB -- append blob contents to another
61	** TODO: Refactor all invocations to use global macro blob_appendb()
62	*/
63	#define BLOB_APPEND_BLOB(dest, src) blob_appendb((dest), (src))
64
65	#ifndef FOOTNOTES_WITHOUT_URI
66	#define BLOB_APPEND_URI(dest,ctx) blob_appendb(dest,&((ctx)->reqURI))
67	#else
68	#define BLOB_APPEND_URI(dest,ctx)
69	#endif
	@@ -106,19 +104,19 @@
106	i++;
107	}
108	blob_append(ob, data+beg, i-beg);
109	while( i<size ){
110	if( data[i]=='<' ){
111	BLOB_APPEND_LITERAL(ob, "<");
112	}else if( data[i]=='>' ){
113	BLOB_APPEND_LITERAL(ob, ">");
114	}else if( data[i]=='&' ){
115	BLOB_APPEND_LITERAL(ob, "&");
116	}else if( data[i]=='"' ){
117	BLOB_APPEND_LITERAL(ob, """);
118	}else if( data[i]=='\'' ){
119	BLOB_APPEND_LITERAL(ob, "'");
120	}else{
121	break;
122	}
123	i++;
124	}
	@@ -136,15 +134,15 @@
136	i++;
137	}
138	blob_append(ob, data+beg, i-beg);
139	while( i<size ){
140	if( data[i]=='<' ){
141	BLOB_APPEND_LITERAL(ob, "<");
142	}else if( data[i]=='>' ){
143	BLOB_APPEND_LITERAL(ob, ">");
144	}else if( data[i]=='&' ){
145	BLOB_APPEND_LITERAL(ob, "&");
146	}else{
147	break;
148	}
149	i++;
150	}
	@@ -157,17 +155,17 @@
157	/* Size of the prolog: "<div class='markdown'>\n" */
158	#define PROLOG_SIZE 23
159
160	static void html_prolog(struct Blob ob, void opaque){
161	INTER_BLOCK(ob);
162	BLOB_APPEND_LITERAL(ob, "<div class=\"markdown\">\n");
163	assert( blob_size(ob)==PROLOG_SIZE );
164	}
165
166	static void html_epilog(struct Blob ob, void opaque){
167	INTER_BLOCK(ob);
168	BLOB_APPEND_LITERAL(ob, "</div>\n");
169	}
170
171	static void html_blockhtml(struct Blob ob, struct Blob text, void *opaque){
172	char *data = blob_buffer(text);
173	size_t size = blob_size(text);
	@@ -185,25 +183,25 @@
185	blob_append(title, data+nTag, size - nTag - 5);
186	return;
187	}
188	INTER_BLOCK(ob);
189	blob_append(ob, data, size);
190	BLOB_APPEND_LITERAL(ob, "\n");
191	}
192
193	static void html_blockcode(struct Blob ob, struct Blob text, void *opaque){
194	INTER_BLOCK(ob);
195	BLOB_APPEND_LITERAL(ob, "<pre><code>");
196	html_escape(ob, blob_buffer(text), blob_size(text));
197	BLOB_APPEND_LITERAL(ob, "</code></pre>\n");
198	}
199
200	static void html_blockquote(struct Blob ob, struct Blob text, void *opaque){
201	INTER_BLOCK(ob);
202	BLOB_APPEND_LITERAL(ob, "<blockquote>\n");
203	BLOB_APPEND_BLOB(ob, text);
204	BLOB_APPEND_LITERAL(ob, "</blockquote>\n");
205	}
206
207	static void html_header(
208	struct Blob *ob,
209	struct Blob *text,
	@@ -212,22 +210,22 @@
212	){
213	struct Blob title = ((MarkdownToHtml)opaque)->output_title;
214	/* The first header at the beginning of a text is considered as
215	* a title and not output. */
216	if( blob_size(ob)<=PROLOG_SIZE && title!=0 && blob_size(title)==0 ){
217	BLOB_APPEND_BLOB(title, text);
218	return;
219	}
220	INTER_BLOCK(ob);
221	blob_appendf(ob, "<h%d>", level);
222	BLOB_APPEND_BLOB(ob, text);
223	blob_appendf(ob, "</h%d>", level);
224	}
225
226	static void html_hrule(struct Blob ob, void opaque){
227	INTER_BLOCK(ob);
228	BLOB_APPEND_LITERAL(ob, "<hr />\n");
229	}
230
231
232	static void html_list(
233	struct Blob *ob,
	@@ -238,11 +236,11 @@
238	char ol[] = "ol";
239	char ul[] = "ul";
240	char *tag = (flags & MKD_LIST_ORDERED) ? ol : ul;
241	INTER_BLOCK(ob);
242	blob_appendf(ob, "<%s>\n", tag);
243	BLOB_APPEND_BLOB(ob, text);
244	blob_appendf(ob, "</%s>\n", tag);
245	}
246
247	static void html_list_item(
248	struct Blob *ob,
	@@ -251,20 +249,20 @@
251	void *opaque
252	){
253	char *text_data = blob_buffer(text);
254	size_t text_size = blob_size(text);
255	while( text_size>0 && text_data[text_size-1]=='\n' ) text_size--;
256	BLOB_APPEND_LITERAL(ob, "<li>");
257	blob_append(ob, text_data, text_size);
258	BLOB_APPEND_LITERAL(ob, "</li>\n");
259	}
260
261	static void html_paragraph(struct Blob ob, struct Blob text, void *opaque){
262	INTER_BLOCK(ob);
263	BLOB_APPEND_LITERAL(ob, "<p>");
264	BLOB_APPEND_BLOB(ob, text);
265	BLOB_APPEND_LITERAL(ob, "</p>\n");
266	}
267
268
269	static void html_table(
270	struct Blob *ob,
	@@ -271,84 +269,85 @@
271	struct Blob *head_row,
272	struct Blob *rows,
273	void *opaque
274	){
275	INTER_BLOCK(ob);
276	BLOB_APPEND_LITERAL(ob, "<table>\n");
277	if( head_row && blob_size(head_row)>0 ){
278	BLOB_APPEND_LITERAL(ob, "<thead>\n");
279	BLOB_APPEND_BLOB(ob, head_row);
280	BLOB_APPEND_LITERAL(ob, "</thead>\n<tbody>\n");
281	}
282	if( rows ){
283	BLOB_APPEND_BLOB(ob, rows);
284	}
285	if( head_row && blob_size(head_row)>0 ){
286	BLOB_APPEND_LITERAL(ob, "</tbody>\n");
287	}
288	BLOB_APPEND_LITERAL(ob, "</table>\n");
289	}
290
291	static void html_table_cell(
292	struct Blob *ob,
293	struct Blob *text,
294	int flags,
295	void *opaque
296	){
297	if( flags & MKD_CELL_HEAD ){
298	BLOB_APPEND_LITERAL(ob, " <th");
299	}else{
300	BLOB_APPEND_LITERAL(ob, " <td");
301	}
302	switch( flags & MKD_CELL_ALIGN_MASK ){
303	case MKD_CELL_ALIGN_LEFT: {
304	BLOB_APPEND_LITERAL(ob, " align=\"left\"");
305	break;
306	}
307	case MKD_CELL_ALIGN_RIGHT: {
308	BLOB_APPEND_LITERAL(ob, " align=\"right\"");
309	break;
310	}
311	case MKD_CELL_ALIGN_CENTER: {
312	BLOB_APPEND_LITERAL(ob, " align=\"center\"");
313	break;
314	}
315	}
316	BLOB_APPEND_LITERAL(ob, ">");
317	BLOB_APPEND_BLOB(ob, text);
318	if( flags & MKD_CELL_HEAD ){
319	BLOB_APPEND_LITERAL(ob, "</th>\n");
320	}else{
321	BLOB_APPEND_LITERAL(ob, "</td>\n");
322	}
323	}
324
325	static void html_table_row(
326	struct Blob *ob,
327	struct Blob *cells,
328	int flags,
329	void *opaque
330	){
331	BLOB_APPEND_LITERAL(ob, " <tr>\n");
332	BLOB_APPEND_BLOB(ob, cells);
333	BLOB_APPEND_LITERAL(ob, " </tr>\n");
334	}
335
336	/* Render a token of user provided classes.

337	** If bHTML is true then render HTML for (presumably) visible text,
338	** otherwise just a space-separated list of the derived classes
339	*/
340	static void append_footnote_upc(
341	struct Blob *ob,
342	const struct Blob upc, / token of user-provided classes */
343	int bHTML
344	){
345	const char *z = blob_buffer(upc);
346	int i, n = blob_size(upc);

347	if( n<3 ) return;
348	assert( z[0]=='.' && z[n-1] == ':' );
349
350	if( bHTML ){
351	blob_append_literal(ob, "<span class='fn-upc'>"
352	"<span class='fn-upcDot'>.</span>");
353	}
354	n = 0;
	@@ -394,29 +393,28 @@
394	char pos[32];
395	memset(pos,0,32);
396	assert( locus > 0 );
397	/* expect BUGs if the following yields compiler warnings */
398	if( iMark > 0 ){ /* a regular reference to a footnote */
399
400	sprintf(pos, "%s-%i-%s", ctx->unique.c, iMark, l.c);
401	if(span && blob_size(span)) {
402	blob_append_literal(ob,"<span class='");
403	append_footnote_upc(ob, upc, 0);
404	blob_append_literal(ob,"notescope' id='noteref");
405	blob_appendf(ob,"%s'>",pos);
406	blob_appendb(ob, span);
407	blob_trim(ob);
408	blob_append_literal(ob,"<sup class='noteref'><a href='");
409	BLOB_APPEND_URI(ob, ctx);
410	blob_appendf(ob,"#footnote%s'>%i</a></sup></span>", pos, iMark);
411	}else{
412	blob_trim(ob);
413	blob_append_literal(ob,"<sup class='");
414	append_footnote_upc(ob, upc, 0);
415	blob_append_literal(ob,"noteref'><a href='");
416	BLOB_APPEND_URI(ob, ctx);
417	blob_appendf(ob,"#footnote%s' id='noteref%s'>%i</a></sup>",
418	pos, pos, iMark);
419	}
420	}else{ /* misreference */
421	assert( iMark == -1 );
422
	@@ -470,21 +468,19 @@
470	blob_appendf(ob,"#misref%s-%c'>%c</a>", unique,c, c);
471	}
472	if( i < nUsed ) blob_append_literal(ob," …");
473	}
474	blob_append_literal(ob,"</sup>\n<span>Misreference</span>");
475
476	}else if( iMark > 0 ){ /* regular, joined and overnested footnotes */
477	char pos[24];
478	int bJoin = 0;
479	#define _joined_footnote_indicator "<ul class='fn-joined'>"
480	#define _jfi_sz (sizeof(_joined_footnote_indicator)-1)
481	assert( text );
482	assert( blob_size(text) );
483	memset(pos,0,24);
484	sprintf(pos, "%s-%i", unique, iMark);
485
486	blob_appendf(ob, "<li id='footnote%s' class='", pos);
487	if( nUsed ){
488	if( blob_size(text)>=_jfi_sz &&
489	!memcmp(blob_buffer(text),_joined_footnote_indicator,_jfi_sz)){
490	bJoin = 1;
	@@ -492,11 +488,10 @@
492	}
493	append_footnote_upc(ob, upc, 0);
494	}else{
495	blob_append_literal(ob, "fn-toodeep ");
496	}
497
498	if( nUsed <= 1 ){
499	blob_append_literal(ob, "fn-monoref'><sup class='fn-backrefs'>");
500	blob_appendf(ob,"<a id='footnote%s-a' href='", pos);
501	BLOB_APPEND_URI(ob, ctx);
502	blob_appendf(ob,"#noteref%s-a'>^</a>", pos);
	@@ -554,10 +549,11 @@
554	html_escape(ob, blob_buffer(text), blob_size(text));
555	blob_append_literal(ob,"</code></pre>");
556	}
557	blob_append_literal(ob, "\n</li>\n");
558	}

559	static void html_footnotes(
560	struct Blob ob, const struct Blob items, void *opaque
561	){
562	if( items && blob_size(items) ){
563	blob_append_literal(ob,
	@@ -579,21 +575,21 @@
579	struct Blob *link,
580	enum mkd_autolink type,
581	void *opaque
582	){
583	if( !link \|\| blob_size(link)<=0 ) return 0;
584	BLOB_APPEND_LITERAL(ob, "<a href=\"");
585	if( type==MKDA_IMPLICIT_EMAIL ) BLOB_APPEND_LITERAL(ob, "mailto:");
586	html_quote(ob, blob_buffer(link), blob_size(link));
587	BLOB_APPEND_LITERAL(ob, "\">");
588	if( type==MKDA_EXPLICIT_EMAIL && blob_size(link)>7 ){
589	/* remove "mailto:" from displayed text */
590	html_escape(ob, blob_buffer(link)+7, blob_size(link)-7);
591	}else{
592	html_escape(ob, blob_buffer(link), blob_size(link));
593	}
594	BLOB_APPEND_LITERAL(ob, "</a>");
595	return 1;
596	}
597
598	/*
599	** The nSrc bytes at zSrc[] are Pikchr input text (allegedly). Process that
	@@ -682,13 +678,13 @@
682	){
683	if( text==0 ){
684	/* no-op */
685	}else if( nSep<=2 ){
686	/* One or two graves: an in-line code span */
687	BLOB_APPEND_LITERAL(ob, "<code>");
688	html_escape(ob, blob_buffer(text), blob_size(text));
689	BLOB_APPEND_LITERAL(ob, "</code>");
690	}else{
691	/* Three or more graves: a fenced code block */
692	int n = blob_size(text);
693	const char *z = blob_buffer(text);
694	int i;
	@@ -720,25 +716,25 @@
720	struct Blob *ob,
721	struct Blob *text,
722	char c,
723	void *opaque
724	){
725	BLOB_APPEND_LITERAL(ob, "<strong>");
726	BLOB_APPEND_BLOB(ob, text);
727	BLOB_APPEND_LITERAL(ob, "</strong>");
728	return 1;
729	}
730
731	static int html_emphasis(
732	struct Blob *ob,
733	struct Blob *text,
734	char c,
735	void *opaque
736	){
737	BLOB_APPEND_LITERAL(ob, "<em>");
738	BLOB_APPEND_BLOB(ob, text);
739	BLOB_APPEND_LITERAL(ob, "</em>");
740	return 1;
741	}
742
743	static int html_image(
744	struct Blob *ob,
	@@ -745,24 +741,24 @@
745	struct Blob *link,
746	struct Blob *title,
747	struct Blob *alt,
748	void *opaque
749	){
750	BLOB_APPEND_LITERAL(ob, "<img src=\"");
751	html_quote(ob, blob_buffer(link), blob_size(link));
752	BLOB_APPEND_LITERAL(ob, "\" alt=\"");
753	html_quote(ob, blob_buffer(alt), blob_size(alt));
754	if( title && blob_size(title)>0 ){
755	BLOB_APPEND_LITERAL(ob, "\" title=\"");
756	html_quote(ob, blob_buffer(title), blob_size(title));
757	}
758	BLOB_APPEND_LITERAL(ob, "\" />");
759	return 1;
760	}
761
762	static int html_linebreak(struct Blob ob, void opaque){
763	BLOB_APPEND_LITERAL(ob, "<br />\n");
764	return 1;
765	}
766
767	static int html_link(
768	struct Blob *ob,
	@@ -783,13 +779,13 @@
783	WIKI_MARKDOWNLINKS
784	;
785	wiki_resolve_hyperlink(ob, flags, zLink, zClose, sizeof(zClose), 0, zTitle);
786	}
787	if( blob_size(content)==0 ){
788	if( link ) BLOB_APPEND_BLOB(ob, link);
789	}else{
790	BLOB_APPEND_BLOB(ob, content);
791	}
792	blob_append(ob, zClose, -1);
793	return 1;
794	}
795
	@@ -797,13 +793,13 @@
797	struct Blob *ob,
798	struct Blob *text,
799	char c,
800	void *opaque
801	){
802	BLOB_APPEND_LITERAL(ob, "<strong><em>");
803	BLOB_APPEND_BLOB(ob, text);
804	BLOB_APPEND_LITERAL(ob, "</em></strong>");
805	return 1;
806	}
807
808
809	static void html_normal_text(struct Blob ob, struct Blob text, void *opaque){
810

	--- src/markdown_html.c
	+++ src/markdown_html.c
	@@ -29,11 +29,19 @@
29	struct Blob *output_title,
30	struct Blob *output_body);
31
32	#endif /* INTERFACE */
33
34	/*
35	** Markdown-internal helper for generating unique link reference IDs.
36	*/
37	typedef union bitfield64_t bitfield64_t;
38	union bitfield64_t{
39	uint64_t u;
40	char c[8];
41	unsigned char b[8];
42	};
43
44	/*
45	** An instance of the following structure is passed through the
46	** "opaque" pointer.
47	*/
	@@ -50,20 +58,10 @@
58
59	/* INTER_BLOCK -- skip a line between block level elements */
60	#define INTER_BLOCK(ob) \
61	do { if( blob_size(ob)>0 ) blob_append_char(ob, '\n'); } while (0)
62










63	#ifndef FOOTNOTES_WITHOUT_URI
64	#define BLOB_APPEND_URI(dest,ctx) blob_appendb(dest,&((ctx)->reqURI))
65	#else
66	#define BLOB_APPEND_URI(dest,ctx)
67	#endif
	@@ -106,19 +104,19 @@
104	i++;
105	}
106	blob_append(ob, data+beg, i-beg);
107	while( i<size ){
108	if( data[i]=='<' ){
109	blob_append_literal(ob, "<");
110	}else if( data[i]=='>' ){
111	blob_append_literal(ob, ">");
112	}else if( data[i]=='&' ){
113	blob_append_literal(ob, "&");
114	}else if( data[i]=='"' ){
115	blob_append_literal(ob, """);
116	}else if( data[i]=='\'' ){
117	blob_append_literal(ob, "'");
118	}else{
119	break;
120	}
121	i++;
122	}
	@@ -136,15 +134,15 @@
134	i++;
135	}
136	blob_append(ob, data+beg, i-beg);
137	while( i<size ){
138	if( data[i]=='<' ){
139	blob_append_literal(ob, "<");
140	}else if( data[i]=='>' ){
141	blob_append_literal(ob, ">");
142	}else if( data[i]=='&' ){
143	blob_append_literal(ob, "&");
144	}else{
145	break;
146	}
147	i++;
148	}
	@@ -157,17 +155,17 @@
155	/* Size of the prolog: "<div class='markdown'>\n" */
156	#define PROLOG_SIZE 23
157
158	static void html_prolog(struct Blob ob, void opaque){
159	INTER_BLOCK(ob);
160	blob_append_literal(ob, "<div class=\"markdown\">\n");
161	assert( blob_size(ob)==PROLOG_SIZE );
162	}
163
164	static void html_epilog(struct Blob ob, void opaque){
165	INTER_BLOCK(ob);
166	blob_append_literal(ob, "</div>\n");
167	}
168
169	static void html_blockhtml(struct Blob ob, struct Blob text, void *opaque){
170	char *data = blob_buffer(text);
171	size_t size = blob_size(text);
	@@ -185,25 +183,25 @@
183	blob_append(title, data+nTag, size - nTag - 5);
184	return;
185	}
186	INTER_BLOCK(ob);
187	blob_append(ob, data, size);
188	blob_append_literal(ob, "\n");
189	}
190
191	static void html_blockcode(struct Blob ob, struct Blob text, void *opaque){
192	INTER_BLOCK(ob);
193	blob_append_literal(ob, "<pre><code>");
194	html_escape(ob, blob_buffer(text), blob_size(text));
195	blob_append_literal(ob, "</code></pre>\n");
196	}
197
198	static void html_blockquote(struct Blob ob, struct Blob text, void *opaque){
199	INTER_BLOCK(ob);
200	blob_append_literal(ob, "<blockquote>\n");
201	blob_appendb(ob, text);
202	blob_append_literal(ob, "</blockquote>\n");
203	}
204
205	static void html_header(
206	struct Blob *ob,
207	struct Blob *text,
	@@ -212,22 +210,22 @@
210	){
211	struct Blob title = ((MarkdownToHtml)opaque)->output_title;
212	/* The first header at the beginning of a text is considered as
213	* a title and not output. */
214	if( blob_size(ob)<=PROLOG_SIZE && title!=0 && blob_size(title)==0 ){
215	blob_appendb(title, text);
216	return;
217	}
218	INTER_BLOCK(ob);
219	blob_appendf(ob, "<h%d>", level);
220	blob_appendb(ob, text);
221	blob_appendf(ob, "</h%d>", level);
222	}
223
224	static void html_hrule(struct Blob ob, void opaque){
225	INTER_BLOCK(ob);
226	blob_append_literal(ob, "<hr />\n");
227	}
228
229
230	static void html_list(
231	struct Blob *ob,
	@@ -238,11 +236,11 @@
236	char ol[] = "ol";
237	char ul[] = "ul";
238	char *tag = (flags & MKD_LIST_ORDERED) ? ol : ul;
239	INTER_BLOCK(ob);
240	blob_appendf(ob, "<%s>\n", tag);
241	blob_appendb(ob, text);
242	blob_appendf(ob, "</%s>\n", tag);
243	}
244
245	static void html_list_item(
246	struct Blob *ob,
	@@ -251,20 +249,20 @@
249	void *opaque
250	){
251	char *text_data = blob_buffer(text);
252	size_t text_size = blob_size(text);
253	while( text_size>0 && text_data[text_size-1]=='\n' ) text_size--;
254	blob_append_literal(ob, "<li>");
255	blob_append(ob, text_data, text_size);
256	blob_append_literal(ob, "</li>\n");
257	}
258
259	static void html_paragraph(struct Blob ob, struct Blob text, void *opaque){
260	INTER_BLOCK(ob);
261	blob_append_literal(ob, "<p>");
262	blob_appendb(ob, text);
263	blob_append_literal(ob, "</p>\n");
264	}
265
266
267	static void html_table(
268	struct Blob *ob,
	@@ -271,84 +269,85 @@
269	struct Blob *head_row,
270	struct Blob *rows,
271	void *opaque
272	){
273	INTER_BLOCK(ob);
274	blob_append_literal(ob, "<table>\n");
275	if( head_row && blob_size(head_row)>0 ){
276	blob_append_literal(ob, "<thead>\n");
277	blob_appendb(ob, head_row);
278	blob_append_literal(ob, "</thead>\n<tbody>\n");
279	}
280	if( rows ){
281	blob_appendb(ob, rows);
282	}
283	if( head_row && blob_size(head_row)>0 ){
284	blob_append_literal(ob, "</tbody>\n");
285	}
286	blob_append_literal(ob, "</table>\n");
287	}
288
289	static void html_table_cell(
290	struct Blob *ob,
291	struct Blob *text,
292	int flags,
293	void *opaque
294	){
295	if( flags & MKD_CELL_HEAD ){
296	blob_append_literal(ob, " <th");
297	}else{
298	blob_append_literal(ob, " <td");
299	}
300	switch( flags & MKD_CELL_ALIGN_MASK ){
301	case MKD_CELL_ALIGN_LEFT: {
302	blob_append_literal(ob, " align=\"left\"");
303	break;
304	}
305	case MKD_CELL_ALIGN_RIGHT: {
306	blob_append_literal(ob, " align=\"right\"");
307	break;
308	}
309	case MKD_CELL_ALIGN_CENTER: {
310	blob_append_literal(ob, " align=\"center\"");
311	break;
312	}
313	}
314	blob_append_literal(ob, ">");
315	blob_appendb(ob, text);
316	if( flags & MKD_CELL_HEAD ){
317	blob_append_literal(ob, "</th>\n");
318	}else{
319	blob_append_literal(ob, "</td>\n");
320	}
321	}
322
323	static void html_table_row(
324	struct Blob *ob,
325	struct Blob *cells,
326	int flags,
327	void *opaque
328	){
329	blob_append_literal(ob, " <tr>\n");
330	blob_appendb(ob, cells);
331	blob_append_literal(ob, " </tr>\n");
332	}
333
334	/*
335	** Render a token of user provided classes.
336	** If bHTML is true then render HTML for (presumably) visible text,
337	** otherwise just a space-separated list of the derived classes.
338	*/
339	static void append_footnote_upc(
340	struct Blob *ob,
341	const struct Blob upc, / token of user-provided classes */
342	int bHTML
343	){
344	const char *z = blob_buffer(upc);
345	int i, n = blob_size(upc);
346
347	if( n<3 ) return;
348	assert( z[0]=='.' && z[n-1] == ':' );

349	if( bHTML ){
350	blob_append_literal(ob, "<span class='fn-upc'>"
351	"<span class='fn-upcDot'>.</span>");
352	}
353	n = 0;
	@@ -394,29 +393,28 @@
393	char pos[32];
394	memset(pos,0,32);
395	assert( locus > 0 );
396	/* expect BUGs if the following yields compiler warnings */
397	if( iMark > 0 ){ /* a regular reference to a footnote */
398	sprintf(pos, "%s-%d-%s", ctx->unique.c, iMark, l.c);

399	if(span && blob_size(span)) {
400	blob_append_literal(ob,"<span class='");
401	append_footnote_upc(ob, upc, 0);
402	blob_append_literal(ob,"notescope' id='noteref");
403	blob_appendf(ob,"%s'>",pos);
404	blob_appendb(ob, span);
405	blob_trim(ob);
406	blob_append_literal(ob,"<sup class='noteref'><a href='");
407	BLOB_APPEND_URI(ob, ctx);
408	blob_appendf(ob,"#footnote%s'>%d</a></sup></span>", pos, iMark);
409	}else{
410	blob_trim(ob);
411	blob_append_literal(ob,"<sup class='");
412	append_footnote_upc(ob, upc, 0);
413	blob_append_literal(ob,"noteref'><a href='");
414	BLOB_APPEND_URI(ob, ctx);
415	blob_appendf(ob,"#footnote%s' id='noteref%s'>%d</a></sup>",
416	pos, pos, iMark);
417	}
418	}else{ /* misreference */
419	assert( iMark == -1 );
420
	@@ -470,21 +468,19 @@
468	blob_appendf(ob,"#misref%s-%c'>%c</a>", unique,c, c);
469	}
470	if( i < nUsed ) blob_append_literal(ob," …");
471	}
472	blob_append_literal(ob,"</sup>\n<span>Misreference</span>");

473	}else if( iMark > 0 ){ /* regular, joined and overnested footnotes */
474	char pos[24];
475	int bJoin = 0;
476	#define _joined_footnote_indicator "<ul class='fn-joined'>"
477	#define _jfi_sz (sizeof(_joined_footnote_indicator)-1)
478	assert( text );
479	assert( blob_size(text) );
480	memset(pos,0,24);
481	sprintf(pos, "%s-%d", unique, iMark);

482	blob_appendf(ob, "<li id='footnote%s' class='", pos);
483	if( nUsed ){
484	if( blob_size(text)>=_jfi_sz &&
485	!memcmp(blob_buffer(text),_joined_footnote_indicator,_jfi_sz)){
486	bJoin = 1;
	@@ -492,11 +488,10 @@
488	}
489	append_footnote_upc(ob, upc, 0);
490	}else{
491	blob_append_literal(ob, "fn-toodeep ");
492	}

493	if( nUsed <= 1 ){
494	blob_append_literal(ob, "fn-monoref'><sup class='fn-backrefs'>");
495	blob_appendf(ob,"<a id='footnote%s-a' href='", pos);
496	BLOB_APPEND_URI(ob, ctx);
497	blob_appendf(ob,"#noteref%s-a'>^</a>", pos);
	@@ -554,10 +549,11 @@
549	html_escape(ob, blob_buffer(text), blob_size(text));
550	blob_append_literal(ob,"</code></pre>");
551	}
552	blob_append_literal(ob, "\n</li>\n");
553	}
554
555	static void html_footnotes(
556	struct Blob ob, const struct Blob items, void *opaque
557	){
558	if( items && blob_size(items) ){
559	blob_append_literal(ob,
	@@ -579,21 +575,21 @@
575	struct Blob *link,
576	enum mkd_autolink type,
577	void *opaque
578	){
579	if( !link \|\| blob_size(link)<=0 ) return 0;
580	blob_append_literal(ob, "<a href=\"");
581	if( type==MKDA_IMPLICIT_EMAIL ) blob_append_literal(ob, "mailto:");
582	html_quote(ob, blob_buffer(link), blob_size(link));
583	blob_append_literal(ob, "\">");
584	if( type==MKDA_EXPLICIT_EMAIL && blob_size(link)>7 ){
585	/* remove "mailto:" from displayed text */
586	html_escape(ob, blob_buffer(link)+7, blob_size(link)-7);
587	}else{
588	html_escape(ob, blob_buffer(link), blob_size(link));
589	}
590	blob_append_literal(ob, "</a>");
591	return 1;
592	}
593
594	/*
595	** The nSrc bytes at zSrc[] are Pikchr input text (allegedly). Process that
	@@ -682,13 +678,13 @@
678	){
679	if( text==0 ){
680	/* no-op */
681	}else if( nSep<=2 ){
682	/* One or two graves: an in-line code span */
683	blob_append_literal(ob, "<code>");
684	html_escape(ob, blob_buffer(text), blob_size(text));
685	blob_append_literal(ob, "</code>");
686	}else{
687	/* Three or more graves: a fenced code block */
688	int n = blob_size(text);
689	const char *z = blob_buffer(text);
690	int i;
	@@ -720,25 +716,25 @@
716	struct Blob *ob,
717	struct Blob *text,
718	char c,
719	void *opaque
720	){
721	blob_append_literal(ob, "<strong>");
722	blob_appendb(ob, text);
723	blob_append_literal(ob, "</strong>");
724	return 1;
725	}
726
727	static int html_emphasis(
728	struct Blob *ob,
729	struct Blob *text,
730	char c,
731	void *opaque
732	){
733	blob_append_literal(ob, "<em>");
734	blob_appendb(ob, text);
735	blob_append_literal(ob, "</em>");
736	return 1;
737	}
738
739	static int html_image(
740	struct Blob *ob,
	@@ -745,24 +741,24 @@
741	struct Blob *link,
742	struct Blob *title,
743	struct Blob *alt,
744	void *opaque
745	){
746	blob_append_literal(ob, "<img src=\"");
747	html_quote(ob, blob_buffer(link), blob_size(link));
748	blob_append_literal(ob, "\" alt=\"");
749	html_quote(ob, blob_buffer(alt), blob_size(alt));
750	if( title && blob_size(title)>0 ){
751	blob_append_literal(ob, "\" title=\"");
752	html_quote(ob, blob_buffer(title), blob_size(title));
753	}
754	blob_append_literal(ob, "\" />");
755	return 1;
756	}
757
758	static int html_linebreak(struct Blob ob, void opaque){
759	blob_append_literal(ob, "<br />\n");
760	return 1;
761	}
762
763	static int html_link(
764	struct Blob *ob,
	@@ -783,13 +779,13 @@
779	WIKI_MARKDOWNLINKS
780	;
781	wiki_resolve_hyperlink(ob, flags, zLink, zClose, sizeof(zClose), 0, zTitle);
782	}
783	if( blob_size(content)==0 ){
784	if( link ) blob_appendb(ob, link);
785	}else{
786	blob_appendb(ob, content);
787	}
788	blob_append(ob, zClose, -1);
789	return 1;
790	}
791
	@@ -797,13 +793,13 @@
793	struct Blob *ob,
794	struct Blob *text,
795	char c,
796	void *opaque
797	){
798	blob_append_literal(ob, "<strong><em>");
799	blob_appendb(ob, text);
800	blob_append_literal(ob, "</em></strong>");
801	return 1;
802	}
803
804
805	static void html_normal_text(struct Blob ob, struct Blob text, void *opaque){
806

M src/wikiformat.c

+4 -4

		--- src/wikiformat.c
		+++ src/wikiformat.c
		@@ -1920,14 +1920,14 @@
1920	1920	blob_reset(&out);
1921	1921	}
1922	1922	if( bFnLint && (g.ftntsIssues[0] \|\| g.ftntsIssues[1]
1923	1923	\|\| g.ftntsIssues[2] \|\| g.ftntsIssues[3] )){
1924	1924	fossil_fatal("There were issues with footnotes:\n"
1925		- " %8i misreference%s\n"
1926		- " %8i unreferenced\n"
1927		- " %8i splitted\n"
1928		- " %8i overnested",
	1925	+ " %8d misreference%s\n"
	1926	+ " %8d unreferenced\n"
	1927	+ " %8d splitted\n"
	1928	+ " %8d overnested",
1929	1929	g.ftntsIssues[0], g.ftntsIssues[0]==1?"":"s",
1930	1930	g.ftntsIssues[1], g.ftntsIssues[2], g.ftntsIssues[3]);
1931	1931	}
1932	1932	}
1933	1933
1934	1934

	--- src/wikiformat.c
	+++ src/wikiformat.c
	@@ -1920,14 +1920,14 @@
1920	blob_reset(&out);
1921	}
1922	if( bFnLint && (g.ftntsIssues[0] \|\| g.ftntsIssues[1]
1923	\|\| g.ftntsIssues[2] \|\| g.ftntsIssues[3] )){
1924	fossil_fatal("There were issues with footnotes:\n"
1925	" %8i misreference%s\n"
1926	" %8i unreferenced\n"
1927	" %8i splitted\n"
1928	" %8i overnested",
1929	g.ftntsIssues[0], g.ftntsIssues[0]==1?"":"s",
1930	g.ftntsIssues[1], g.ftntsIssues[2], g.ftntsIssues[3]);
1931	}
1932	}
1933
1934

	--- src/wikiformat.c
	+++ src/wikiformat.c
	@@ -1920,14 +1920,14 @@
1920	blob_reset(&out);
1921	}
1922	if( bFnLint && (g.ftntsIssues[0] \|\| g.ftntsIssues[1]
1923	\|\| g.ftntsIssues[2] \|\| g.ftntsIssues[3] )){
1924	fossil_fatal("There were issues with footnotes:\n"
1925	" %8d misreference%s\n"
1926	" %8d unreferenced\n"
1927	" %8d splitted\n"
1928	" %8d overnested",
1929	g.ftntsIssues[0], g.ftntsIssues[0]==1?"":"s",
1930	g.ftntsIssues[1], g.ftntsIssues[2], g.ftntsIssues[3]);
1931	}
1932	}
1933
1934

Fossil SCM

Keyboard Shortcuts