stringextra.c File Reference

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

Go to the source code of this file.

Functions
int	strnicmp (const char *s1, const char *s2, size_t len)
	strnicmp - Case insensitive, length-limited string comparison : One string : The other string : the maximum number of characters to compare
char *	strncat (char *dest, const char *src, size_t count)
	strncat - Append a length-limited, NUL-terminated string to another : The string to be appended to : The string to append to it : The maximum numbers of bytes to copy
size_t	strspn (const char *s, const char *accept)
	strspn - Calculate the length of the initial substring of which only contain letters in : The string to be searched : The string to search for
size_t	strcspn (const char *s, const char *reject)
	strcspn - Calculate the length of the initial substring of which only contain letters not in : The string to be searched : The string to search for
char *	strpbrk (const char *cs, const char *ct)
	strpbrk - Find the first occurrence of a set of characters : The string to be searched : The characters to search for
char *	strtok (char *s, const char *ct)
	strtok - Split a string into tokens : The string to be searched : The characters to search for
char *	strsep (char **s, const char *ct)
	strsep - Split a string into tokens : The string to be searched : The characters to search for
char *	bcopy (const char *src, char *dest, int count)
	bcopy - Copy one area of memory to another : Where to copy from : Where to copy to : The size of the area.
void *	memscan (const void *addr, int c, size_t size)
	memscan - Find a character in an area of memory.
Variables
char *	___strtok

---

Function Documentation

int strnicmp	(	const char *	s1,
		const char *	s2,
		size_t	len
	)

strnicmp - Case insensitive, length-limited string comparison : One string : The other string : the maximum number of characters to compare

Definition at line 46 of file stringextra.c.

References tolower().

{
        /* Yes, Virginia, it had better be unsigned */
        unsigned char c1, c2;

        c1 = 0; c2 = 0;
        if (len) {
                do {
                        c1 = *s1; c2 = *s2;
                        s1++; s2++;
                        if (!c1)
                                break;
                        if (!c2)
                                break;
                        if (c1 == c2)
                                continue;
                        c1 = tolower(c1);
                        c2 = tolower(c2);
                        if (c1 != c2)
                                break;
                } while (--len);
        }
        return (int)c1 - (int)c2;
}

char* strncat	(	char *	dest,
		const char *	src,
		size_t	count
	)

strncat - Append a length-limited, NUL-terminated string to another : The string to be appended to : The string to append to it : The maximum numbers of bytes to copy

Note that in contrast to strncpy, strncat ensures the result is terminated.

Definition at line 84 of file stringextra.c.

{
        char *tmp = dest;

        if (count) {
                while (*dest)
                        dest++;
                while ((*dest++ = *src++)) {
                        if (--count == 0) {
                                *dest = '\0';
                                break;
                        }
                }
        }

        return tmp;
}

size_t strspn	(	const char *	s,
		const char *	accept
	)

strspn - Calculate the length of the initial substring of which only contain letters in : The string to be searched : The string to search for

Definition at line 110 of file stringextra.c.

Referenced by strtok().

{
        const char *p;
        const char *a;
        size_t count = 0;

        for (p = s; *p != '\0'; ++p) {
                for (a = accept; *a != '\0'; ++a) {
                        if (*p == *a)
                                break;
                }
                if (*a == '\0')
                        return count;
                ++count;
        }

        return count;
}

size_t strcspn	(	const char *	s,
		const char *	reject
	)

strcspn - Calculate the length of the initial substring of which only contain letters not in : The string to be searched : The string to search for

Definition at line 137 of file stringextra.c.

References r.

{
        const char *p;
        const char *r;
        size_t count = 0;

        for (p = s; *p != '\0'; ++p) {
                for (r = reject; *r != '\0'; ++r) {
                        if (*p == *r)
                                return count;
                }
                ++count;
        }

        return count;
}

char* strpbrk	(	const char *	cs,
		const char *	ct
	)

strpbrk - Find the first occurrence of a set of characters : The string to be searched : The characters to search for

Definition at line 161 of file stringextra.c.

References NULL.

Referenced by strsep(), and strtok().

{
        const char *sc1,*sc2;

        for( sc1 = cs; *sc1 != '\0'; ++sc1) {
                for( sc2 = ct; *sc2 != '\0'; ++sc2) {
                        if (*sc1 == *sc2)
                                return (char *) sc1;
                }
        }
        return NULL;
}

char* strtok	(	char *	s,
		const char *	ct
	)

strtok - Split a string into tokens : The string to be searched : The characters to search for

WARNING: strtok is deprecated, use strsep instead.

Definition at line 183 of file stringextra.c.

References ___strtok, NULL, strpbrk(), and strspn().

{
        char *sbegin, *send;

        sbegin  = s ? s : ___strtok;
        if (!sbegin) {
                return NULL;
        }
        sbegin += strspn(sbegin,ct);
        if (*sbegin == '\0') {
                ___strtok = NULL;
                return( NULL );
        }
        send = strpbrk( sbegin, ct);
        if (send && *send != '\0')
                *send++ = '\0';
        ___strtok = send;
        return (sbegin);
}

char* strsep	(	char **	s,
		const char *	ct
	)

strsep - Split a string into tokens : The string to be searched : The characters to search for

strsep() updates to point after the token, ready for the next call.

It returns empty tokens, too, behaving exactly like the libc function of that name. In fact, it was stolen from glibc2 and de-fancy-fied. Same semantics, slimmer shape. ;)

Definition at line 216 of file stringextra.c.

References NULL, and strpbrk().

{
        char *sbegin = *s, *end;

        if (sbegin == NULL)
                return NULL;

        end = strpbrk(sbegin, ct);
        if (end)
                *end++ = '\0';
        *s = end;

        return sbegin;
}

char* bcopy	(	const char *	src,
		char *	dest,
		int	count
	)

bcopy - Copy one area of memory to another : Where to copy from : Where to copy to : The size of the area.

Note that this is the same as memcpy(), with the arguments reversed. memcpy() is the standard, bcopy() is a legacy BSD function.

You should not use this function to access IO space, use memcpy_toio() or memcpy_fromio() instead.

Definition at line 245 of file stringextra.c.

References memmove().

{
        return memmove(dest,src,count);
}

void* memscan	(	const void *	addr,
		int	c,
		size_t	size
	)

memscan - Find a character in an area of memory.

: The memory area : The byte to search for : The size of the area.

returns the address of the first occurrence of , or 1 byte past the area if is not found

Definition at line 261 of file stringextra.c.

{
        unsigned char * p = (unsigned char *) addr;

        while (size) {
                if (*p == c)
                        return (void *) p;
                p++;
                size--;
        }
        return (void *) p;
}

---

Variable Documentation

char* ___strtok

Definition at line 72 of file stringextra.c.

Referenced by strtok().