rmultimarkdown 6.2.2.1 → 6.4.0.1

data/ext/mmd/stack.c

@@ -87,8 +87,10 @@ stack * stack_new(int startingSize) {
 
 /// Free the stack
 void stack_free(stack * s) {
-	free(s->element);
-	free(s);
+	if (s) {
+		free(s->element);
+		free(s);
+	}
 }
 
 

data/ext/mmd/stack.h

@@ -71,39 +71,39 @@ typedef struct stack stack;
 /// Create a new stack with dynamic storage with an
 /// initial capacity (0 to use default capacity)
 stack * stack_new(
-    int startingSize				//!< Default capacity for stack
+	int startingSize				//!< Default capacity for stack
 );
 
 
 /// Free the stack
 void stack_free(
-    stack * s						//!< Stack to be freed
+	stack * s						//!< Stack to be freed
 );
 
 
 /// Add a new pointer to the stack
 void stack_push(
-    stack * s,						//!< Stack to use
-    void * element					//!< Pointer to push onto stack
+	stack * s,						//!< Stack to use
+	void * element					//!< Pointer to push onto stack
 );
 
 
 /// Pop the top pointer off the stack and return it
 void * stack_pop(
-    stack * s						//!< Stack to examine
+	stack * s						//!< Stack to examine
 );
 
 
 /// Peek at the top pointer on the stack (but don't remove it from stack)
 void * stack_peek(
-    stack * s						//!< Stack to examine
+	stack * s						//!< Stack to examine
 );
 
 
 /// Peek at a specific index in the stack
 void * stack_peek_index(
-    stack * s,						//!< Stack to examine
-    size_t index					//!< Index to peek at (0 is first pointer on stack)
+	stack * s,						//!< Stack to examine
+	size_t index					//!< Index to peek at (0 is first pointer on stack)
 );
 
 

data/ext/mmd/textbundle.c

@@ -109,9 +109,9 @@
 	#include <curl/curl.h>
 #endif
 
-#include "textbundle.h"
+#include "file.h"
 #include "miniz.h"
-#include "transclude.h"
+#include "textbundle.h"
 #include "writer.h"
 #include "zip.h"
 
@@ -246,8 +246,6 @@ static void add_assets(mz_zip_archive * pZip, mmd_engine * e, const char * direc
 		char destination[100] = "assets/";
 		destination[43] = '\0';
 
-		mz_bool status;
-
 		HASH_ITER(hh, e->asset_hash, a, a_tmp) {
 
 			memcpy(&destination[7], a->asset_path, 36);

data/ext/mmd/token.c

@@ -190,7 +190,7 @@ token * token_new_parent(token * child, unsigned short type) {
 /// may or may not also be the start of a chain
 void token_chain_append(token * chain_start, token * t) {
 	if ((chain_start == NULL) ||
-	        (t == NULL)) {
+			(t == NULL)) {
 		return;
 	}
 
@@ -369,6 +369,18 @@ token * token_prune_graft(token * first, token * last, unsigned short container_
 		next->prev = first;
 	}
 
+	// Fix tail (prior tail is now a child)
+	if (first->next == NULL) {
+		token * walker = first;
+
+		while (walker->prev) {
+			walker = walker->prev;
+		}
+
+		first->tail = first;
+		walker->tail = first;
+	}
+
 	return first;
 }
 
@@ -465,15 +477,15 @@ void token_tree_describe(token * t, const char * string) {
 /// Find the child node of a given parent that contains the specified
 /// offset position.
 token * token_child_for_offset(
-    token * parent,						//!< Pointer to parent token
-    size_t offset						//!< Search position
+	token * parent,						//!< Pointer to parent token
+	size_t offset						//!< Search position
 ) {
 	if (parent == NULL) {
 		return NULL;
 	}
 
 	if ((parent->start > offset) ||
-	        (parent->start + parent->len < offset)) {
+			(parent->start + parent->len < offset)) {
 		return NULL;
 	}
 
@@ -505,16 +517,16 @@ static bool ranges_intersect(size_t start1, size_t len1, size_t start2, size_t l
 /// Find first child node of a given parent that intersects the specified
 /// offset range.
 token * token_first_child_in_range(
-    token * parent,						//!< Pointer to parent token
-    size_t start,						//!< Start search position
-    size_t len							//!< Search length
+	token * parent,						//!< Pointer to parent token
+	size_t start,						//!< Start search position
+	size_t len							//!< Search length
 ) {
 	if (parent == NULL) {
 		return NULL;
 	}
 
 	if ((parent->start > start + len) ||
-	        (parent->start + parent->len < start)) {
+			(parent->start + parent->len < start)) {
 		return NULL;
 	}
 
@@ -539,16 +551,16 @@ token * token_first_child_in_range(
 /// Find last child node of a given parent that intersects the specified
 /// offset range.
 token * token_last_child_in_range(
-    token * parent,						//!< Pointer to parent token
-    size_t start,						//!< Start search position
-    size_t len							//!< Search length
+	token * parent,						//!< Pointer to parent token
+	size_t start,						//!< Start search position
+	size_t len							//!< Search length
 ) {
 	if (parent == NULL) {
 		return NULL;
 	}
 
 	if ((parent->start > start + len) ||
-	        (parent->start + parent->len < start)) {
+			(parent->start + parent->len < start)) {
 		return NULL;
 	}
 

data/ext/mmd/token_pairs.c

@@ -97,7 +97,7 @@ void token_pair_engine_free(token_pair_engine * 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) {
+								   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;
@@ -189,7 +189,7 @@ close:
 					if (!e->empty_allowed[pair_type]) {
 						// Make sure they aren't consecutive tokens
 						if ((peek->next == walker) &&
-						        (peek->start + peek->len == walker->start)) {
+								(peek->start + peek->len == walker->start)) {
 							// i--;
 							i = start_counter;	// In this situation, we can't use this token as a closer
 							continue;

data/ext/mmd/token_pairs.h

@@ -99,24 +99,24 @@ 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
+	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
+	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
+	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
 );
 
 

data/ext/mmd/transclude.c

@@ -56,45 +56,10 @@
 #include <string.h>
 
 #include "d_string.h"
+#include "file.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) {
@@ -108,191 +73,6 @@ static char * my_strdup(const char * source) {
 }
 
 
-/// 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) {
@@ -467,11 +247,6 @@ void mmd_transclude_source(DString * source, const char * search_path, const cha
 
 				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);