常用快速流处理函数

#pragma once

typedef union _EFFICA {
	struct {
		char v1;
		char v2;
		char v3;
		char v4;
	};
	int effica;
} EFFICA, *PEFFICA;

static size_t __cdecl fast_strlen(const char * str)
{
	register PEFFICA peffica;

	if (0 == str) {
		return 0;
	}

	peffica = (PEFFICA)str;

	for ( ;; )
	{
		if ((peffica->v2 && peffica->v4) && (peffica->v1 && peffica->v3))
		{
			++peffica;
			continue;
		}
		else
		{
			if (0 == peffica->v1)
				return ((size_t)peffica - (size_t)str);
			if (0 == peffica->v2)
				return ((size_t)peffica - (size_t)str + 1);
			if (0 == peffica->v3)
				return ((size_t)peffica - (size_t)str + 2);
			if (0 == peffica->v4)
				return ((size_t)peffica - (size_t)str + 3);
			break;
		}
	}
	return 0;
}

static size_t __cdecl fast_strcpy(char * des, const char * src, size_t len)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == des || 0 == src) {
		return 0;
	}

	dwordCount = len / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i) {
		((size_t *)des)[i] = ((size_t *)src)[i];
	}

	i = i * sizeof(size_t);

	for (; i < len; ++i) {
		des[i] = src[i];
	}

	des[i] = 0;
	return (i);
}

static size_t __cdecl fast_strcmp(const char * des, const char * src, size_t len)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == des || 0 == src) {
		return 0;
	}

	dwordCount = len / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i)
	{
		if (((size_t *)des)[i] != ((size_t *)src)[i]) {
			return (i);
		}
	}

	i = i * sizeof(size_t);

	for (; i < len; ++i)
	{
		if (des[i] != src[i]) {
			return (i);
		}
	}
	return (i);
}

static size_t __cdecl fast_strcat(char * des, const char * src, size_t len)
{
	register size_t dwordCount;
	register char * pdes;
	register size_t i;

	if (0 == des || 0 == src) {
		return 0;
	}

	dwordCount = len / sizeof(size_t);
	pdes = des + fast_strlen(des);
	i = 0;

	for (; i < dwordCount; ++i) {
		((size_t *)pdes)[i] = ((size_t *)src)[i];
	}

	i = i * sizeof(size_t);

	for (; i < len; ++i) {
		pdes[i] = src[i];
	}

	pdes[i] = 0;
	return (i);
}

static size_t __cdecl fast_strxch(char * des, char * src, size_t len)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == des || 0 == src) {
		return 0;
	}

	dwordCount = len / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i)
	{
		((size_t *)des)[i] = ((size_t *)des)[i] ^ ((size_t *)src)[i];
		((size_t *)src)[i] = ((size_t *)des)[i] ^ ((size_t *)src)[i];
		((size_t *)des)[i] = ((size_t *)des)[i] ^ ((size_t *)src)[i];
	}

	i = i * sizeof(size_t);

	for (; i < len; ++i)
	{
		des[i] = des[i] ^ src[i];
		src[i] = des[i] ^ src[i];
		des[i] = des[i] ^ src[i];
	}
	return (i);
}

static int __cdecl fast_strstr(const char * des, const char * src, size_t len)
{
	int s;
	int cx,cy,cz;
	int sx,sy;
	register int i,sz;

	if (0 == des || 0 == src) {
		return (-1);
	}

	cx = (int)len / 2;
	cy = (int)len - cx;
	cz = (int)len - 1;

	i = cx;
	s = (int)fast_strlen(des);

	for (; i < s; )
	{
		if (des[i] == src[cx])
		{
			sx = i - 1;
			sz = cx - 1;

			for (; sz >= 0; )
			{
				if (des[sx] != src[sz])
				{
					i = i + (cx - sz);
					break;
				}
				--sx;
				--sz;
			}

			if (sz < 0)
			{
				i = i + 1;
				sy = cx + 1;

				for (; (int)len > sy; )
				{
					if (des[i] != src[sy])
					{
						i = i + cy;
						break;
					}
					++i;
					++sy;
				}

				if (len == sy) {
					return (i - sy);
				}
			}
			continue;
		}

		if (src[cz] != des[(i + cy)]) {
			i = i + 2;
		}
		else {
			i = i + 1;
		}
	}
	return (-1);
}

static size_t fast_memset(void * d, int v, size_t l)
{
	register size_t dwordCount;
	register char * pval;
	register size_t i;

	if (0 == d) {
		return 0;
	}

	dwordCount = l / sizeof(size_t);
	pval = (char *)&v;
	i = 0;

	for (; i < dwordCount; ++i) {
		((size_t *)d)[i] = v;
	}

	i = i * sizeof(size_t);

	for (; i < l; ++i) {
		((char *)d)[i] = *pval++;
	}
	return (i);
}

static size_t __cdecl fast_memcpy(void * d, const void * s, size_t l)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == d || 0 == s) {
		return 0;
	}

	dwordCount = l / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i) {
		((size_t *)d)[i] = ((size_t *)s)[i];
	}

	i = i * sizeof(size_t);

	for (; i < l; ++i) {
		((char *)d)[i] = ((char *)s)[i];
	}
	return (i);
}

static size_t __cdecl fast_memcmp(const void * d, const void * s, size_t l)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == d || 0 == s) {
		return 0;
	}

	dwordCount = l / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i)
	{
		if (((size_t *)d)[i] != ((size_t *)s)[i]) {
			return (i);
		}
	}

	i = i * sizeof(size_t);

	for (; i < l; ++i)
	{
		if (((char *)d)[i] != ((char *)s)[i]) {
			return (i);
		}
	}
	return (i);
}

static size_t __cdecl fast_memxch(void * d, void * s, size_t l)
{
	register size_t dwordCount;
	register size_t i;

	if (0 == d || 0 == s) {
		return 0;
	}

	dwordCount = l / sizeof(size_t);
	i = 0;

	for (; i < dwordCount; ++i)
	{
		((size_t *)d)[i] = ((size_t *)d)[i] ^ ((size_t *)s)[i];
		((size_t *)s)[i] = ((size_t *)d)[i] ^ ((size_t *)s)[i];
		((size_t *)d)[i] = ((size_t *)d)[i] ^ ((size_t *)s)[i];
	}

	i = i * sizeof(size_t);

	for (; i < l; ++i)
	{
		((char *)d)[i] = ((char *)d)[i] ^ ((char *)s)[i];
		((char *)s)[i] = ((char *)d)[i] ^ ((char *)s)[i];
		((char *)d)[i] = ((char *)d)[i] ^ ((char *)s)[i];
	}
	return (i);
}