/*
 *	Parse a token into an array.
 *	The resulting array contains
 *	character pointers to specific
 *	locations in the first token, which
 *	is a copy of the passed token.
 *	Thus, after calling this function,
 *	the passed token will no longer be
 *	needed, so it may be freed.
 *
 *	Each element in the array starting
 *	with the first is a pointer to
 *	part of the tokenized string.
 *	The array is terminated by a NULL
 *	element.
 *	After the NULL element is an
 *	additional entry with a pointer
 *	to the duplicated parsed string
 *	block.
 *
 *	The delim is the delimiter in which
 *	the token will be split.
 *	The dump character is that in which
 *	if encountered will terminate parsing
 *	and put the rest of the token in the
 *	next element. Pass NULL if you do not
 *	wish to use this feature.
 *
 *	Be sure to free the resulting array
 *	when it is no longer needed.
 */
char** token_parse(char* token, char delim, char* dump) {
	int size = 2;
	char* ctoken = token;
	char** tok_arr = NULL;
	char* cpy = NULL;
	int index = 0;
	char* last = NULL;

	/*
	 *	Determine the number of elements.
	 */
	while (*ctoken) {
		if (*ctoken == delim)
			++size;
		else if (dump != NULL) {
			if (*ctoken == *dump) {
				++size;
				break;
			}
		}
		++ctoken;
	}
	
	/*
	 *	Allocate memory for the array.
	 */
	tok_arr = (char**)malloc(sizeof(char*) * size + sizeof(char*));
	
	/*
	 *	Copy token to first index of array.
	 */
	cpy = (char*)malloc(sizeof(char) * strlen(token) + sizeof(char));
	strcpy(cpy, token);
	token = cpy;
	
	/*
	 *	Parse the token.
	 */
	index = 0;
	last = token;
	while (*token) {
		if (*token == delim) {
			tok_arr[index] = last;
			*token = '\0';
			last = (token + 1);
			++index;
		} else if (dump != NULL) {
			if (*token == *dump) {
				last++;
				break;
			}
		}
		++token;
	}
	tok_arr[index] = last;
	tok_arr[index + 1] = NULL;
	tok_arr[index + 2] = cpy;

	return tok_arr;
}