rmultimarkdown 4.7.1.1 → 6.2.2.1

data/ext/mmd/token_pairs.c

@@ -0,0 +1,263 @@
+/**
+
+	MultiMarkdown 6 -- Lightweight markup processor to produce HTML, LaTeX, and more.
+
+	@file token_pairs.c
+
+	@brief	Allow for pairing certain tokens together (e.g. '[' and ']') to create
+	more meaningful token trees.
+
+
+	@author	Fletcher T. Penney
+	@bug
+
+**/
+
+/*
+
+	Copyright © 2016 - 2017 Fletcher T. Penney.
+
+
+	The `MultiMarkdown 6` project is released under the MIT License..
+
+	GLibFacade.c and GLibFacade.h are from the MultiMarkdown v4 project:
+
+		https://github.com/fletcher/MultiMarkdown-4/
+
+	MMD 4 is released under both the MIT License and GPL.
+
+
+	CuTest is released under the zlib/libpng license. See CuTest.c for the text
+	of the license.
+
+
+	## The MIT License ##
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+
+*/
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "stack.h"
+#include "token.h"
+#include "token_pairs.h"
+
+
+/// Create a new token pair engine
+token_pair_engine * token_pair_engine_new(void) {
+	token_pair_engine * e = malloc(sizeof(token_pair_engine));
+
+	if (e) {
+		unsigned short empty[kMaxTokenTypes] = {0};
+		unsigned short empty2[kMaxTokenTypes][kMaxTokenTypes] = {{0}};
+
+		memcpy(e->can_open_pair, empty, sizeof(unsigned short) * kMaxTokenTypes);
+		memcpy(e->can_close_pair, empty, sizeof(unsigned short) * kMaxTokenTypes);
+
+		memcpy(e->pair_type, empty2, sizeof(unsigned short) * kMaxTokenTypes * kMaxTokenTypes);
+
+		memcpy(e->empty_allowed, empty, sizeof(unsigned short) * kMaxTokenTypes);
+		memcpy(e->match_len, empty, sizeof(unsigned short) * kMaxTokenTypes);
+		memcpy(e->should_prune, empty, sizeof(unsigned short) * kMaxTokenTypes);
+	}
+
+	return e;
+}
+
+
+/// Free existing token pair engine
+void token_pair_engine_free(token_pair_engine * e) {
+	if (e == NULL) {
+		return;
+	}
+
+	free(e);
+}
+
+
+/// Add a new pairing configuration to a token pair engine
+void token_pair_engine_add_pairing(token_pair_engine * e, unsigned short open_type, unsigned short close_type,
+                                   unsigned short pair_type, int options) {
+	// \todo: This needs to be more sophisticated
+	e->can_open_pair[open_type] = 1;
+	e->can_close_pair[close_type] = 1;
+	(e->pair_type)[open_type][close_type] = pair_type;
+
+	if (options & PAIRING_ALLOW_EMPTY) {
+		e->empty_allowed[pair_type] = true;
+	}
+
+	if (options & PAIRING_MATCH_LENGTH) {
+		e->match_len[pair_type] = true;
+	}
+
+	if (options & PAIRING_PRUNE_MATCH) {
+		e->should_prune[pair_type] = true;
+	}
+
+}
+
+
+/// Mate opener and closer together
+void token_pair_mate(token * a, token * b) {
+	if (a == NULL | b  == NULL) {
+		return;
+	}
+
+	a->mate = b;
+	a->unmatched = false;
+
+	b->mate = a;
+	b->unmatched = false;
+}
+
+
+/// Search a token's childen for matching pairs
+void token_pairs_match_pairs_inside_token(token * parent, token_pair_engine * e, stack * s, unsigned short depth) {
+
+	// Avoid stack overflow in "pathologic" input
+	if (depth == kMaxPairRecursiveDepth) {
+		return;
+	}
+
+	// Walk the child chain
+	token * walker = parent->child;
+
+	// Counter
+	size_t start_counter = s->size;
+	size_t i;				// We're sharing one stack, so any opener earlier than this belongs to a parent
+
+	token * peek;
+	unsigned short pair_type;
+
+	unsigned int opener_count[kMaxTokenTypes] = {0};	// Keep track of which token types are on the stack
+
+	while (walker != NULL) {
+
+		if (walker->child) {
+			token_pairs_match_pairs_inside_token(walker, e, s, depth + 1);
+		}
+
+		// Is this a closer?
+		if (walker->can_close && e->can_close_pair[walker->type] && walker->unmatched ) {
+			i = s->size;
+
+			// Do we even have a valid opener in the stack?
+			// It's only worth checking if the stack is beyond a certain size
+			if (i > start_counter + kLargeStackThreshold) {
+				for (int j = 0; j < kMaxTokenTypes; ++j) {
+					if (opener_count[j]) {
+						if (e->pair_type[j][walker->type]) {
+							goto close;
+						}
+					}
+				}
+
+				// No opener available for this as closer
+				goto open;
+			}
+
+close:
+
+			// Find matching opener for this closer
+			while (i > start_counter) {
+				peek = stack_peek_index(s, i - 1);
+
+				pair_type = e->pair_type[peek->type][walker->type];
+
+				if (pair_type) {
+					if (!e->empty_allowed[pair_type]) {
+						// Make sure they aren't consecutive tokens
+						if ((peek->next == walker) &&
+						        (peek->start + peek->len == walker->start)) {
+							// i--;
+							i = start_counter;	// In this situation, we can't use this token as a closer
+							continue;
+						}
+					}
+
+					if (e->match_len[pair_type]) {
+						// Lengths must match
+						if (peek->len != walker->len) {
+							i--;
+							continue;
+						}
+					}
+
+					token_pair_mate(peek, walker);
+
+
+					// Clear portion of stack between opener and closer as they are now unavailable for mating
+					while (s->size > (i - 1)) {
+						peek = stack_pop(s);
+						opener_count[peek->type]--;
+					}
+
+					#ifndef NDEBUG
+					fprintf(stderr, "stack now sized %lu\n", s->size);
+					#endif
+					// Prune matched section
+
+					if (e->should_prune[pair_type]) {
+						if (peek->prev == NULL) {
+							walker = token_prune_graft(peek, walker, e->pair_type[peek->type][walker->type]);
+							parent->child = walker;
+						} else {
+							walker = token_prune_graft(peek, walker, e->pair_type[peek->type][walker->type]);
+						}
+					}
+
+					break;
+				}
+
+				#ifndef NDEBUG
+				else {
+					fprintf(stderr, "token type %d failed to match stack element\n", walker->type);
+				}
+
+				#endif
+				i--;
+			}
+		}
+
+open:
+
+		// Is this an opener?
+		if (walker->can_open && e->can_open_pair[walker->type] && walker->unmatched) {
+			stack_push(s, walker);
+			opener_count[walker->type]++;
+			#ifndef NDEBUG
+			fprintf(stderr, "push token type %d to stack (%lu elements)\n", walker->type, s->size);
+			#endif
+		}
+
+		walker = walker->next;
+	}
+
+	#ifndef NDEBUG
+	fprintf(stderr, "token stack has %lu elements (of %lu)\n", s->size, s->capacity);
+	#endif
+
+	// Remove unused tokens from stack and return to parent
+	s->size = start_counter;
+}

data/ext/mmd/token_pairs.h

@@ -0,0 +1,123 @@
+/**
+
+	MultiMarkdown 6 -- Lightweight markup processor to produce HTML, LaTeX, and more.
+
+	@file token_pairs.h
+
+	@brief  Allow for pairing certain tokens together (e.g. '[' and ']') to create
+	more meaningful token trees.
+
+
+	@author	Fletcher T. Penney
+	@bug
+
+**/
+
+/*
+
+	Copyright © 2016 - 2017 Fletcher T. Penney.
+
+
+	The `MultiMarkdown 6` project is released under the MIT License..
+
+	GLibFacade.c and GLibFacade.h are from the MultiMarkdown v4 project:
+
+		https://github.com/fletcher/MultiMarkdown-4/
+
+	MMD 4 is released under both the MIT License and GPL.
+
+
+	CuTest is released under the zlib/libpng license. See CuTest.c for the text
+	of the license.
+
+
+	## The MIT License ##
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+
+*/
+
+
+#ifndef TOKEN_PAIRS_MULTIMARKDOWN_H
+#define TOKEN_PAIRS_MULTIMARKDOWN_H
+
+#include "stack.h"
+#include "token.h"
+
+
+#ifdef TEST
+	#include "CuTest.h"
+#endif
+
+#define kMaxTokenTypes	230				//!< This needs to be larger than the largest token type being used
+#define kLargeStackThreshold 1000		//!< Avoid unnecessary searches of large stacks
+#define kMaxPairRecursiveDepth 1000		//!< Maximum recursion depth to traverse when pairing tokens -- to prevent stack overflow with "pathologic" input
+
+
+/// Store information about which tokens can be paired, and what actions to take when
+/// pairing them.
+struct token_pair_engine {
+	unsigned short		can_open_pair[kMaxTokenTypes];				//!< Can token type open a pair?
+	unsigned short		can_close_pair[kMaxTokenTypes];				//!< Can token type close a pair?
+
+	unsigned short		pair_type[kMaxTokenTypes][kMaxTokenTypes];	//!< Which pair are we forming?
+
+	unsigned short		empty_allowed[kMaxTokenTypes];				//!< Is this pair type allowed to be empty?
+	unsigned short		match_len[kMaxTokenTypes];					//!< Does this pair type require matched lengths of openers/closers?
+	unsigned short		should_prune[kMaxTokenTypes];				//!< Does this pair type need to be pruned to a child token chain?
+};
+
+typedef struct token_pair_engine token_pair_engine;
+
+
+/// Flags for token pair options
+enum pairings_options {
+	PAIRING_ALLOW_EMPTY		= 1 << 0,		//!< Allow consecutive tokens to match with each other
+	PAIRING_MATCH_LENGTH	= 1 << 1,		//!< Require that opening/closing tokens be same length
+	PAIRING_PRUNE_MATCH		= 1 << 2,		//!< Move the matched sub-chain into a child chain
+};
+
+
+/// Create a new token pair engine
+token_pair_engine * token_pair_engine_new(void);
+
+/// Free existing token pair engine
+void token_pair_engine_free(
+    token_pair_engine * e					//!< Token pair engine to be freed
+);
+
+/// Add a new pairing configuration to a token pair engine
+void token_pair_engine_add_pairing(
+    token_pair_engine * e,					//!< Token pair engine to add to
+    unsigned short open_type,				//!< Token type for opener
+    unsigned short close_type,				//!< Token type for closer
+    unsigned short pair_type,				//!< Token type for pairing
+    int options								//!< Token pair options to use
+);
+
+/// Search a token's childen for matching pairs
+void token_pairs_match_pairs_inside_token(
+    token * parent,							//!< Which tokens should we search for pairs
+    token_pair_engine * e,					//!< Token pair engine to be used for matching
+    stack * s,								//!< Pointer to a stack to use for pairing tokens
+    unsigned short depth					//!< Keep track of recursion depth
+);
+
+
+#endif

data/ext/mmd/transclude.c

@@ -0,0 +1,549 @@
+/**
+
+	MultiMarkdown 6 -- Lightweight markup processor to produce HTML, LaTeX, and more.
+
+	@file transclude.c
+
+	@brief
+
+
+	@author	Fletcher T. Penney
+	@bug
+
+**/
+
+/*
+
+	Copyright © 2016 - 2017 Fletcher T. Penney.
+
+
+	The `MultiMarkdown 6` project is released under the MIT License..
+
+	GLibFacade.c and GLibFacade.h are from the MultiMarkdown v4 project:
+
+		https://github.com/fletcher/MultiMarkdown-4/
+
+	MMD 4 is released under both the MIT License and GPL.
+
+
+	CuTest is released under the zlib/libpng license. See CuTest.c for the text
+	of the license.
+
+
+	## The MIT License ##
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+#include "d_string.h"
+#include "libMultiMarkdown.h"
+#include "transclude.h"
+
+#if defined(__WIN32)
+	#include <windows.h>
+#endif
+
+#define kBUFFERSIZE 4096	// How many bytes to read at a time
+
+
+/// strndup not available on all platforms
+static char * my_strndup(const char * source, size_t n) {
+	if (source == NULL) {
+		return NULL;
+	}
+
+	size_t len = 0;
+	char * result;
+	const char * test = source;
+
+	// strlen is too slow if strlen(source) >> n
+	for (len = 0; len < n; ++len) {
+		if (test == '\0') {
+			break;
+		}
+
+		test++;
+	}
+
+	result = malloc(len + 1);
+
+	if (result) {
+		memcpy(result, source, len);
+		result[len] = '\0';
+	}
+
+	return result;
+}
+
+
+/// strdup() not available on all platforms
+static char * my_strdup(const char * source) {
+	char * result = malloc(strlen(source) + 1);
+
+	if (result) {
+		strcpy(result, source);
+	}
+
+	return result;
+}
+
+
+/// Windows can use either `\` or `/` as a separator -- thanks to t-beckmann on github
+///	for suggesting a fix for this.
+bool is_separator(char c) {
+	#if defined(__WIN32)
+	return c == '\\' || c == '/';
+	#else
+	return c == '/';
+	#endif
+}
+
+
+#ifdef TEST
+void Test_is_separator(CuTest* tc) {
+	char * test = "a/\\";
+
+	#if defined(__WIN32)
+	CuAssertIntEquals(tc, false, is_separator(test[0]));
+	CuAssertIntEquals(tc, true, is_separator(test[1]));
+	CuAssertIntEquals(tc, true, is_separator(test[2]));
+	#else
+	CuAssertIntEquals(tc, false, is_separator(test[0]));
+	CuAssertIntEquals(tc, true, is_separator(test[1]));
+	CuAssertIntEquals(tc, false, is_separator(test[2]));
+	#endif
+}
+#endif
+
+
+void add_trailing_sep(DString * path) {
+	#if defined(__WIN32)
+	char sep = '\\';
+	#else
+	char sep = '/';
+	#endif
+
+	// Ensure that folder ends in separator
+	if (!is_separator(path->str[path->currentStringLength - 1])) {
+		d_string_append_c(path, sep);
+	}
+}
+
+/// Combine directory and base filename to create a full path */
+char * path_from_dir_base(const char * dir, const char * base) {
+	if (!dir && !base) {
+		return NULL;
+	}
+
+
+	DString * path = NULL;
+	char * result = NULL;
+
+	if ((base != NULL) && (is_separator(base[0]))) {
+		// We have an absolute path
+		path = d_string_new(base);
+	} else {
+		// We have a directory and relative path
+		path = d_string_new(dir);
+
+		// Ensure that folder ends in separator
+		add_trailing_sep(path);
+
+		// Append filename (if present)
+		if (base) {
+			d_string_append(path, base);
+		}
+	}
+
+	result = path->str;
+	d_string_free(path, false);
+
+	return result;
+}
+
+
+#ifdef TEST
+void Test_path_from_dir_base(CuTest* tc) {
+	char dir[10] = "/foo";
+	char base[10] = "bar";
+
+	char * path = path_from_dir_base(dir, base);
+
+	#if defined(__WIN32)
+	CuAssertStrEquals(tc, "/foo\\bar", path);
+	#else
+	CuAssertStrEquals(tc, "/foo/bar", path);
+	#endif
+
+	free(path);
+	strcpy(base, "/bar");
+
+	path = path_from_dir_base(dir, base);
+
+	CuAssertStrEquals(tc, "/bar", path);
+
+	free(path);
+
+	path = path_from_dir_base(NULL, NULL);
+	CuAssertStrEquals(tc, NULL, path);
+}
+#endif
+
+
+/// Separate filename and directory from a full path
+///
+/// See http://stackoverflow.com/questions/1575278/function-to-split-a-filepath-into-path-and-file
+void split_path_file(char ** dir, char ** file, const char * path) {
+	const char * slash = path, * next;
+
+	#if defined(__WIN32)
+	const char sep[] = "\\/";	// Windows allows either variant
+	#else
+	const char sep[] = "/";
+	#endif
+
+	while ((next = strpbrk(slash + 1, sep))) {
+		slash = next;
+	}
+
+	if (path != slash) {
+		slash++;
+	}
+
+	*dir = my_strndup(path, slash - path);
+	*file = my_strdup(slash);
+}
+
+#ifdef TEST
+void Test_split_path_file(CuTest* tc) {
+	char * dir, * file;
+
+	char * path = "/foo/bar.txt";
+	split_path_file(&dir, &file, path);
+
+	CuAssertStrEquals(tc, "/foo/", dir);
+	CuAssertStrEquals(tc, "bar.txt", file);
+
+	path = "\\foo\\bar.txt";
+	split_path_file(&dir, &file, path);
+
+	#if defined(__WIN32)
+	CuAssertStrEquals(tc, "\\foo\\", dir);
+	CuAssertStrEquals(tc, "bar.txt", file);
+	#else
+	CuAssertStrEquals(tc, "", dir);
+	CuAssertStrEquals(tc, "\\foo\\bar.txt", file);
+	#endif
+}
+#endif
+
+
+DString * scan_file(const char * fname) {
+	/* Read from a file and return a DString *
+		`buffer` will need to be freed elsewhere */
+
+	char chunk[kBUFFERSIZE];
+	size_t bytes;
+
+	FILE * file;
+
+	#if defined(__WIN32)
+	int wchars_num = MultiByteToWideChar(CP_UTF8, 0, fname, -1, NULL, 0);
+	wchar_t wstr[wchars_num];
+	MultiByteToWideChar(CP_UTF8, 0, fname, -1, wstr, wchars_num);
+
+	if ((file = _wfopen(wstr, L"rb")) == NULL) {
+	#else
+
+	if ((file = fopen(fname, "r")) == NULL ) {
+	#endif
+
+		return NULL;
+	}
+
+	DString * buffer = d_string_new("");
+
+	while ((bytes = fread(chunk, 1, kBUFFERSIZE, file)) > 0) {
+		d_string_append_c_array(buffer, chunk, bytes);
+	}
+
+	fclose(file);
+
+	return buffer;
+}
+
+
+/// Recursively transclude source text, given a search directory.
+/// Track files to prevent infinite recursive loops
+void mmd_transclude_source(DString * source, const char * search_path, const char * source_path, short format, stack * parsed, stack * manifest) {
+	DString * file_path;
+	DString * buffer;
+
+	// Ensure search_folder is tidied up
+	char * search_folder = path_from_dir_base(search_path, NULL);
+	char * source_folder;
+	char * source_file;
+
+	split_path_file(&source_folder, &source_file, source_path);
+
+	char * start, * stop;
+	char text[1100];
+
+	char * temp;
+
+	size_t offset = 0;
+	size_t last_match;
+
+	mmd_engine * e = mmd_engine_create_with_dstring(source, EXT_TRANSCLUDE);
+
+	if (mmd_engine_has_metadata(e, &offset)) {
+
+		temp = mmd_engine_metavalue_for_key(e, "transclude base");
+
+		if (temp) {
+			// The new file overrides the search path
+			free(search_folder);
+
+			// Calculate new search path relative to source document
+			search_folder = path_from_dir_base(source_folder, temp);
+		}
+	}
+
+	free(source_folder);
+	free(source_file);
+
+	mmd_engine_free(e, false);
+
+	if (search_folder == NULL) {
+		// We don't have anywhere to search, so nothing to do
+		goto exit;
+	}
+
+	// Make sure we use a parse tree for children
+	stack * parse_stack = parsed;
+
+	if (parsed == NULL) {
+		// Create temporary stack
+		parse_stack = stack_new(0);
+	}
+
+	// Remember where we currently are in the stack
+	size_t stack_depth = parse_stack->size;
+
+	// Iterate through source text, looking for `{{foo}}`
+
+	start = strstr(&source->str[offset], "{{");
+
+	while (start != NULL) {
+		stop = strstr(start, "}}");
+
+		if (stop == NULL) {
+			break;
+		}
+
+		// Remember insertion point
+		last_match = start - source->str;
+
+		// Ensure we have a reasonable match -- cap at 1000 characters
+		if (stop - start < 1000) {
+			// Grab text
+			strncpy(text, start + 2, stop - start - 2);
+			text[stop - start - 2] = '\0';
+
+			// Is this just {{TOC}}
+			if (strcmp("TOC", text) == 0) {
+				start = strstr(stop, "{{");
+				continue;
+			}
+
+			// Is this an absolute path or relative path?
+			if (is_separator(text[0])) {
+				// Absolute path
+				file_path = d_string_new(text);
+			} else {
+				// Relative path
+				file_path = d_string_new(search_folder);
+
+				// Ensure that search_folder ends in separator
+				add_trailing_sep(file_path);
+
+				d_string_append(file_path, text);
+			}
+
+			// Adjust file wildcard extension for output format
+			// e.g. `foo.*`
+			if ((format != FORMAT_MMD) && strncmp(&text[stop - start - 4], ".*", 2) == 0) {
+				// Trim '.*'
+				d_string_erase(file_path, file_path->currentStringLength - 2, 2);
+
+				switch (format) {
+					case FORMAT_HTML:
+						d_string_append(file_path, ".html");
+						break;
+
+					case FORMAT_LATEX:
+					case FORMAT_BEAMER:
+					case FORMAT_MEMOIR:
+						d_string_append(file_path, ".tex");
+						break;
+
+					case FORMAT_FODT:
+						d_string_append(file_path, ".fodt");
+						break;
+
+					default:
+						d_string_append(file_path, ".txt");
+						break;
+
+				}
+			}
+
+			// Prevent infinite recursive loops
+			for (int i = 0; i < stack_depth; ++i) {
+				temp = stack_peek_index(parse_stack, i);
+
+				if (strcmp(file_path->str, temp) == 0) {
+					// We have parsed this file already, don't recurse infinitely
+					last_match += 2;
+					goto finish_file;
+				}
+			}
+
+			// Add this file to stack
+			stack_push(parse_stack, file_path->str);
+
+			// Add file to the manifest?
+			if (manifest) {
+				bool add = true;
+
+				for (int i = 0; i < manifest->size; ++i) {
+					temp = stack_peek_index(manifest, i);
+
+					if (strcmp(file_path->str, temp) == 0) {
+						// Already on manifest, don't duplicate
+						add = false;
+					}
+				}
+
+				// Add path to manifest
+				if (add) {
+					stack_push(manifest, my_strdup(file_path->str));
+				}
+			}
+
+			// Read the file
+			buffer = scan_file(file_path->str);
+
+			// Substitue buffer for transclusion token
+			if (buffer) {
+				// Erase transclusion token from current source
+				d_string_erase(source, start - source->str, 2 + stop - start);
+
+				// Recursively check this file for transclusions
+				mmd_transclude_source(buffer, search_folder, file_path->str, format, parse_stack, manifest);
+
+				// Strip metadata from buffer now that we have parsed it
+				e = mmd_engine_create_with_dstring(buffer, EXT_TRANSCLUDE);
+
+				if (mmd_engine_has_metadata(e, &offset)) {
+					d_string_erase(buffer, 0, offset);
+				} else {
+					// Do we need to strip BOM?
+					if (strncmp(buffer->str, "\xef\xbb\xbf", 3) == 0) {
+						d_string_erase(buffer, 0, 3);
+					}
+				}
+
+				mmd_engine_free(e, false);
+
+				// Insert file text -- this may cause d_string to reallocate the
+				// character buffer, meaning start/stop are no longer valid
+				d_string_insert(source, start - source->str, buffer->str);
+
+				// Shift search point
+				last_match += buffer->currentStringLength;
+
+				d_string_free(buffer, true);
+			} else {
+				// Skip over marker
+				last_match += 2;
+			}
+
+			// Remove this file from stack
+			stack_pop(parse_stack);
+
+finish_file:
+			d_string_free(file_path, true);
+
+		} else {
+			// Match was too long to be reasonable file name
+			// Skip over marker
+			last_match += 2;
+		}
+
+		start = strstr(source->str + last_match, "{{");
+	}
+
+exit:
+
+	if (parsed == NULL) {
+		// Free temp stack
+		stack_free(parse_stack);
+	} else {
+		// Reset stack depth
+		parse_stack->size = stack_depth;
+	}
+
+	free(search_folder);
+}
+
+
+
+/// If MMD Header metadata used, insert it into appropriate place
+void mmd_prepend_mmd_header(DString * source) {
+	size_t end;
+
+	if (mmd_d_string_has_metadata(source, &end)) {
+		char * meta = mmd_d_string_metavalue_for_key(source, "mmdheader");
+
+		if (meta) {
+			d_string_insert(source, end, "\n\n");
+			d_string_insert(source, end + 2, meta);
+			free(meta);
+		}
+	}
+}
+
+
+/// If MMD Footer metadata used, insert it into appropriate place
+void mmd_append_mmd_footer(DString * source) {
+	char * meta = mmd_d_string_metavalue_for_key(source, "mmdfooter");
+
+	if (meta) {
+		d_string_append(source, "\n\n");
+		d_string_append(source, meta);
+
+		free(meta);
+	}
+}
+