mystring.c

来自「自己做的常用库和实现的数据结构。public domain.」· C语言 代码 · 共 279 行

#include "my.h"

void *mymemcpy(void *dst, const void *src, size_t n)
{
	char *p = dst; 
	const char *q = src, *r = q + n;
	for(; q < r; *p++ = *q++);	
	return dst;
}	
char *mystrcpy(char *dst, const char *src)
{
	char *p = dst;
	while( (*p++ = *src++) != '\0');
	return dst;
}
char *mystrncpy(char *dst, const char *src, size_t n)
{
	char *p = dst;
	const char *q = src + n;
	while(src < q && (*p++ = *src++) != '\0');
	return dst;
}
char *mystrcat(char *dst, const char *src)
{
	char *p = dst;
	while(*p++);
	mystrcpy(--p,src);
	return dst;
}
char *mystrncat(char *dst, const char *src, size_t n)
{
	char *p = dst;
	while(*p++);
	mystrncpy(--p, src, n);
	return dst;
}
int mystrcmp(const char *s1, const char *s2)
{
	for(; *s1 && *s2 && *s1 == *s2; s1++,s2++);
	return(*s1 - *s2);
}
int mystrncmp(const char *s1, const char *s2, size_t n)
{
	const char *s3 = s1 + n;
	for(; s1 < s3 && *s1 && *s2 && *s1 == *s2; s1++,s2++);
	return(*s1 - *s2);
}
int mymemcmp(const void *s1, const void *s2, size_t n)
{
	const char *p = s1, *q = s2, *r = p + n;
	for(; p < r && *p == *q; p++,q++);	
	return(*p - *q);
}
void *mymemchr(const void *src, int c, size_t n)
{
	const unsigned char *p = src, *q = p + n;
	for(; p < q && *p && *p != (unsigned char)c; p++);
	return *p && p != q ? (void *)p : NULL;
}
char *mystrchr(const char *src, int c)
{
	for(; *src && *src != (char)c; src++);
	return *src ? (char *)src : NULL;
}
char *mystrrchr(const char *src, int c)
{
	const char *p = src;
	while(*p++);
	while(--p >= src)
		if(*p == (char)c)	
			return (char *)p;
	return NULL;
}
size_t mystrcspn(const char *src, const char *sub)
{
	const char *p = src, *q;
	for(; *p; p++)
		for(q=sub; *q; q++)
			if(*p == *q)
				return p-src;
	return p-src;
}
char *mystrpbrk(const char *src, const char *sub)
{
	const char *q;
	for(; *src; src++)
		for(q=sub; *q; q++)
			if(*src == *q)
				return (char *)src;
	return NULL;
}
size_t mystrlen(const char *src)
{
	const char *p = src;
	while(*p++);
	return(--p - src);
}
char *mystrstr(const char *src, const char *sub)
{
	const char *p,*q;
	int flag;
	for(; *src; src++) {
		for(p=src,flag=1,q=sub; *q; q++,src++)
			if(*src != *q) {
				flag=0; break;
			}
		if(flag)
			return (char *)p;
	}
	return NULL;
}
void *mymemset(void *src, int c, size_t n)
{
	unsigned char *p = src, *q = p + n;
	for(; p < q; *p++ = (unsigned char)c);
	return src;
}

/* Yet another strcpy(), [begin, end] points to sequential location in ONE source. */
char *yastrcpy(char *dst, const char *begin, const char * const end)
{
	char *p = dst;
	for(; begin <= end; *p++ = *begin++);
	return dst;
}

/* Place source string in revsered order. */
char *strrev(char *src)
{
	char t, *p = src, *q = src;
	for(; *q; q++);
	while( p < --q) {
		t = *p; *p++ = *q; *q = t;
	}
	return src;
}

/* Locate the last occurence of matching substring in given source string. */
char *strrstr(const char *src, const char *sub)
{
	const char *p=src, *q=sub, *t;
	int flag;
	while(*p++);
       	while(*q++);
	while(--p >= src) {
		for(t=--q,flag=1; t >= sub; t--,p--)
			if(*p != *t) {
				flag=0; break;
			}
		if(flag)
			return (char *)++p;
	}
	return NULL;
}

/* Count how many ASCII words in given string,
 * including compound word with joint dash symbol(s). */
size_t scntwd(const char *src)
{
	int t;
	size_t cnt = 0;
	while((t = *src++) != '\0')
		if(isalpha(t)) {
loop:
			if(*src == '\0') 
				return ++cnt;
			if(isalpha(t = *src++) || t == '-') 
				goto loop;
			else 
				cnt++;
		}
	return cnt;
}
/* Count how many ASCII words in given open stream,
 * including compound word with joint dash symbol(s). */
size_t fcntwd(FILE *fp)
{
	int t;
	size_t cnt = 0;
	while(!feof(fp)) 
		if(isalpha(t=fgetc(fp))) {
loop:
			if(feof(fp))
				return ++cnt;
			if(isalpha(t=fgetc(fp)) || t == '-') 
				goto loop;
			else 
				cnt++;
		}
	return cnt;
}

/* Check for identical chars in given string,
 * return true if yes, false if no or string empty. */
bool isdupchr(const unsigned char *src)
{
	int buf[256] = {0};
	while(*src) {
		if(buf[*src] == 1)
			return true;	
		buf[*src++] = 1;
	}
	return false;
}

static void strmv(char *src, ssize_t n)
{
	char *p = src;
	if(n<0) {
		for(; *p; *(p+n) = *p++);
		*(p+n) = '\0';
	} else if(n>0) {
		while(*p++);
		for(; --p >= src; *(p+n) = *p);		
	}
}
/* Substitute all matching substr(s) with replstr in given source string,
 * which is supposed to be big enough to hold all changes;
 * if replace string is empty, it means delete all matching substring(s). */
char *strsstr(char *src, const char *sub, const char *repl)
{
	char *p = src, *t;
	size_t lens = strlen(sub), lenr = strlen(repl);
	for(; *p; p++) 
		if((t=strstr(--p,sub)) != NULL) {
			if(lens >= lenr) {
				strncpy(t, repl, lenr);	
				strmv(t+lens, lenr-lens);
			} else {
				strncpy(t, repl, lens);	
				strmv(t+lens, lenr-lens);
				strncpy(t+lens, repl+lenr-lens, lenr-lens);	
			}
			p = t+lenr-1;
		}
	return src;
}

static long writechar(FILE *fp, long offset, int flag, int c)
{
	long t = fseek(fp, offset, SEEK_CUR);
	if(flag)
		fputc(c, fp);
	return t;
}
/* Format source stream into n byte wide, stream must be "rb+" or "r+b";
 * fp will be rewinded when done; returns 0 on success, -1 on failure. */
int ffmt(FILE *fp, size_t n)
{
	int c,t,flag;
	size_t i;
	for(;;) {
		for(flag=i=1; i<n; i++) {
			if( (c=fgetc(fp)) == EOF) {
				rewind(fp);
				return 0;
			}
			if(isspace(c)) {
				writechar(fp, -1L, 1, (int)' ');
				flag=0;
			}
		}
loop:
		if(flag || writechar(fp, -2L, 0, 0) == -1) {
			rewind(fp);
			return -1;
		}
		t=fgetc(fp), c=fgetc(fp);
		if(c == ' ') 
			writechar(fp, -1L, 1, (int)'\n');
		else if(t == ' ' && c != ' ')
			writechar(fp, -2L, 1, (int)'\n');
		else {
			writechar(fp, -2L, 0, 0);
			goto loop;
		}
	}
}