C String Algorithms

#include <stdio.h>
#include <stdlib.h>
 
unsigned int StringLength(char *string) //Returns length of string, not including null-terminator
{
	char *stringPosition=string;
	while(*(string++));
	return string-stringPosition-1;
}
 
int StringContains(char *source, char *search) //Returns 1 if search exists within source, 0 otherwise
{
	unsigned int charsFound=0;
	while(*source)
	{
		if(*source==search[charsFound])
		{
			charsFound++;
			if(!search[charsFound])
			{
				return 1;
			}
		}
		else
		{
			charsFound=0;
		}
		source++;
	}
	return 0;
}
 
int StringBeginsWith(char *source, char *search) //Returns 1 if search is the beginning of source, 0 otherwise
{
	while(*source&&*search)
	{
		if(*source!=*search)
		{
			return 0;
		}
		source++;
		search++;
	}
	if(!(*source)&&*search)
	{
		return 0;
	}
	return 1;
}
 
int StringEndsWith(char *source, char *search) //Returns 1 if search is the end of source, 0 otherwise
{
	unsigned int charsFound=0;
	while(*source)
	{
		if(*source==search[charsFound])
		{
			charsFound++;
		}
		else
		{
			charsFound=0;
		}
		source++;
	}
	if(search[charsFound])
	{
		return 0;
	}
	return 1;
}
 
int IndexOfString(char *source, char *search) //Returns the index of the first occurence of search within source, -1 if not found
{
	unsigned int charsFound=0, i=0;
	while(*source)
	{
		if(*source==search[charsFound])
		{
			charsFound++;
			if(!search[charsFound])
			{
				return i-charsFound+1;
			}
		}
		else
		{
			charsFound=0;
		}
		i++;
		source++;
	}
	return -1;
}
 
unsigned int CopyString(char *dest, char *source, unsigned int bufferSize) //Copies the string from source to dest, to a maximum of bufferSize characters
																		//(including null-byte). Safe function; ALWAYS null-terminates.
{
	unsigned int bytesCopied=0;
	bufferSize--;
	while(*source&&bytesCopied<bufferSize)
	{
		dest[bytesCopied]=*source;
		bytesCopied++;
		source++;
	}
	dest[bytesCopied++]=0;
	return bytesCopied;
}
 
unsigned int ConcatenateStrings(char *dest, char *source, unsigned int bufferSize) //Concatenates source to dest; length of end result will never exceed bufferSize
																		//(including null-byte). Safe function; ALWAYS null-terminates.
{
	unsigned int i=0;
	while(dest[i]) { i++; }
	bufferSize--;
	while(*source&&i<bufferSize)
	{
		dest[i]=*source;
		i++;
		source++;
	}
	dest[i]=0;
	return i;
}
 
void ReverseString(char *string) //Reverses the given string 'in-place'
{
	char charBuffer;
	unsigned int length=StringLength(string), i, bound=length/2, swap;
	for(i=0;i<bound;i++)
	{
		swap=length-i-1;
		charBuffer=string[i];
		string[i]=string[swap];
		string[swap]=charBuffer;
	}
}
 
void Substring(char *string, unsigned int startIndex, unsigned int length, char *outputString) //Copies the substring (starting at startIndex, continuing for length)
																						//from string to output string. This function does not check for overflows.
{
	unsigned int i;
	for(i=0;i<length;i++)
	{
		if(!string[i+startIndex]) { break; }
		*outputString=string[i+startIndex];
		outputString++;
	}
	*outputString=0;
}
 
void PutString(char *string) //Puts a given string to stdin
{
	while(*string)
	{
		putchar(*(string++));
	}
}
 
void PutStringFile(char *string, FILE *output) //Puts a given string to a file handle
{
	while(*string)
	{
		fputc(*(string++),output);
	}
}
 
void SetMemory(unsigned char *memory, unsigned char value, unsigned int length) //Sets a given block of memory to a given unsigned char value
{
	while(length--)
	{
		*(memory++)=value;
	}
}
 
void CopyMemory(unsigned char *source, unsigned char *dest, unsigned int length) //Copies memory from source to dest (not overlap-safe)
{
	while(length--)
	{
		*(dest++)=*(source++);
	}
}
 
int CopyMemoryBuffered(unsigned char *source, unsigned char *dest, unsigned int length) //Same as above, except works correctly when source and dest overlap
																						//Returns 0 on failure, 1 on success
{
	unsigned char *buf=malloc(length);
	if(!buf) { return 0; }
	unsigned int i=0;
	while(i<length)
	{
		buf[i]=*source;
		source++;
		i++;
	}
	while(length--)
	{
		*(dest++)=*(buf++);
	}
	return 1;
}
 
int CompareMemory(unsigned char *source, unsigned char *compare, unsigned int length) //Returns 1 if memory blocks are equal, 0 otherwise
{
	while(length--)
	{
		if(*(source++)!=*(compare++))
		{
			return 0;
		}
	}
	return 1;
}