Strn.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	STRN_ZERO_PAD   1
#define	STRNP_ZERO_PAD   0
#define	STRNCPY(d, s)   Strncpy((d), (s), (size_t) sizeof(d))
#define	STRNCAT(d, s)   Strncat((d), (s), (size_t) sizeof(d))

Functions
char *	Strncat (char *const, const char *const, const size_t)
char *	Strncpy (char *const, const char *const, const size_t)
char *	Strnpcat (char *const, const char *const, size_t)
char *	Strnpcpy (char *const, const char *const, size_t)
char *	Strtok (char *, const char *)
int	Strntok (char *, size_t, char *, const char *)
char *	strtokc (char *, const char *, char **)
int	strntokc (char *, size_t, char *, const char *, char **)
char *	Dynscat (char **dst,...)

Macro Definition Documentation

STRN_ZERO_PAD

#define STRN_ZERO_PAD   1

Definition at line 8 of file Strn.h.

STRNCAT

#define STRNCAT	(		d,
			s
	)		Strncat((d), (s), (size_t) sizeof(d))

Definition at line 48 of file Strn.h.

STRNCPY

#define STRNCPY	(		d,
			s
	)		Strncpy((d), (s), (size_t) sizeof(d))

Definition at line 47 of file Strn.h.

STRNP_ZERO_PAD

#define STRNP_ZERO_PAD   0

Definition at line 13 of file Strn.h.

Function Documentation

Dynscat()

char* Dynscat	(	char **	dst,
			...
	)

Definition at line 9 of file Dynscat.c.

{
    va_list ap;
    const char *src;
    char *newdst, *dcp;
    size_t curLen, catLen, srcLen;

    if (dst == (char **) 0)
        return NULL;

    catLen = 0;
    va_start(ap, dst);
    src = va_arg(ap, char *);
    while (src != NULL) {
        catLen += strlen(src);
        src = va_arg(ap, char *);
    }
    va_end(ap);

    if ((*dst == NULL) || (**dst == '\0'))
        curLen = 0;
    else
        curLen = strlen(*dst);

    if (*dst == NULL)
        newdst = malloc(curLen + catLen + 2);
    else
        newdst = realloc(*dst, curLen + catLen + 2);
    if (newdst == NULL)
        return NULL;

    dcp = newdst + curLen;
    va_start(ap, dst);
    src = va_arg(ap, char *);
    while (src != NULL) {
        srcLen = strlen(src);
        memcpy(dcp, src, srcLen);
        dcp += srcLen;
        src = va_arg(ap, char *);
    }
    va_end(ap);
    *dcp = '\0';

    *dst = newdst;
    return (newdst);
}   /* Dynscat */

Referenced by ComputeLNames(), ComputeRNames(), and main().

Strncat()

char* Strncat	(	char * const	,
		const char * const	,
		const	size_t
	)

Definition at line 13 of file Strncat.c.

{
    register size_t i;
    register char *d;
    register const char *s;

    if (n != 0 && ((i = strlen(dst)) < (n - 1))) {
        d = dst + i;
        s = src;
        /* If they specified a maximum of n characters, use n - 1 chars to
         * hold the copy, and the last character in the array as a NUL.
         * This is the difference between the regular strncpy routine.
         * strncpy doesn't guarantee that your new string will have a
         * NUL terminator, but this routine does.
         */
        for (++i; i<n; i++) {
            if ((*d++ = *s++) == 0) {
#if (STRN_ZERO_PAD == 1)
                /* Pad with zeros. */
                for (; i<n; i++)
                    *d++ = 0;
#endif  /* STRN_ZERO_PAD */
                return dst;
            }
        }
        /* If we get here, then we have a full string, with n - 1 characters,
         * so now we NUL terminate it and go home.
         */
        *d = 0;
    }
    return (dst);
}   /* Strncat */

Referenced by AbbrevStr(), BookmarkToURL(), ExpandTilde(), FileToURL(), GetHomeDir(), GetOurHostName(), main(), MakePrompt(), Path(), SpoolName(), UnDosLine(), and UnLslRLine().

Strncpy()

char* Strncpy	(	char * const	,
		const char * const	,
		const	size_t
	)

Definition at line 11 of file Strncpy.c.

{
    register char *d;
    register const char *s;
    register size_t i;

    d = dst;
    *d = 0;
    if (n != 0) {
        s = src;
        /* If they specified a maximum of n characters, use n - 1 chars to
         * hold the copy, and the last character in the array as a NUL.
         * This is the difference between the regular strncpy routine.
         * strncpy doesn't guarantee that your new string will have a
         * NUL terminator, but this routine does.
         */
        for (i=1; i<n; i++) {
            if ((*d++ = *s++) == 0) {
#if (STRN_ZERO_PAD == 1)
                /* Pad with zeros. */
                for (; i<n; i++)
                    *d++ = 0;
#endif  /* STRN_ZERO_PAD */
                return dst;
            }
        }
        /* If we get here, then we have a full string, with n - 1 characters,
         * so now we NUL terminate it and go home.
         */
        *d = 0;
    }
    return (dst);
}   /* Strncpy */

Referenced by AbbrevStr(), AbsoluteToRelative(), BookmarkToURL(), Chdirs(), DefaultBookmarkName(), ExpandTilde(), FileToURL(), FTPChdir3(), FTPChdirAndGetCWD(), FTPGetCWD(), FTPGetLocalCWD(), GetHomeDir(), GetHostByName(), GetOurHostName(), GetUsrName(), GmTimeStr(), main(), MakePrompt(), MyInetAddr(), nFTPChdirAndGetCWD(), Path(), RunBookmarkEditor(), SetXtermTitle(), SpoolName(), UnDosLine(), and UnLslRLine().

Strnpcat()

char* Strnpcat	(	char * const	,
		const char * const	,
		size_t
	)

Definition at line 16 of file Strnpcat.c.

{
    register size_t i;
    register char *d;
    register const char *s;
    register char c;
    char *ret;

    if (n != 0 && ((i = strlen(dst)) < (n - 1))) {
        d = dst + i;
        s = src;
        /* If they specified a maximum of n characters, use n - 1 chars to
         * hold the copy, and the last character in the array as a NUL.
         * This is the difference between the regular strncpy routine.
         * strncpy doesn't guarantee that your new string will have a
         * NUL terminator, but this routine does.
         */
        for (++i; i<n; i++) {
            c = *s++;
            if (c == '\0') {
                ret = d;    /* Return ptr to end byte. */
                *d++ = c;
#if (STRNP_ZERO_PAD == 1)
                /* Pad with zeros. */
                for (; i<n; i++)
                    *d++ = 0;
#endif  /* STRNP_ZERO_PAD */
                return ret;
            }
            *d++ = c;
        }
        /* If we get here, then we have a full string, with n - 1 characters,
         * so now we NUL terminate it and go home.
         */
        *d = 0;
        return (d); /* Return ptr to end byte. */
    }
    return (dst);
}   /* Strnpcat */

Referenced by FTPFtwL2(), main(), and PathCat().

Strnpcpy()

char* Strnpcpy	(	char * const	,
		const char * const	,
		size_t
	)

Definition at line 12 of file Strnpcpy.c.

{
    register char *d;
    register const char *s;
    register char c;
    char *ret;
    register size_t i;

    d = dst;
    if (n != 0) {
        s = src;
        /* If they specified a maximum of n characters, use n - 1 chars to
         * hold the copy, and the last character in the array as a NUL.
         * This is the difference between the regular strncpy routine.
         * strncpy doesn't guarantee that your new string will have a
         * NUL terminator, but this routine does.
         */
        for (i=1; i<n; i++) {
            c = *s++;
            if (c == '\0') {
                ret = d;    /* Return ptr to end byte. */
                *d++ = c;
#if (STRNP_ZERO_PAD == 1)
                /* Pad with zeros. */
                for (; i<n; i++)
                    *d++ = 0;
#endif  /* STRNP_ZERO_PAD */
                return ret;
            }
            *d++ = c;
        }
        /* If we get here, then we have a full string, with n - 1 characters,
         * so now we NUL terminate it and go home.
         */
        *d = '\0';
        return (d); /* Return ptr to end byte. */
    } else {
        *d = 0;
    }
    return (d); /* Return ptr to end byte. */
}   /* Strnpcpy */

Referenced by main(), and PathCat().

Strntok()

int Strntok	(	char *	,
		size_t	,
		char *	,
		const char *
	)

Definition at line 80 of file Strntok.c.

{
    static char *p = NULL;
    char *end;
    char *lim;
    char *dst;
    int len;

    dst = dstTokenStart;
    lim = dst + tokenSize - 1;      /* Leave room for nul byte. */

    if (buf != NULL) {
        p = buf;
    } else {
        if (p == NULL) {
            *dst = '\0';
            return (-1);        /* No more tokens. */
        }
    }

    for (end = p; ; end++) {
        if (*end == '\0') {
            p = NULL;       /* This is the last token. */
            break;
        }
        if (strchr(delims, (int) *end) != NULL) {
            ++end;
            p = end;
            break;
        }
        if (dst < lim)          /* Don't overrun token size. */
            *dst++ = *end;
    }
    *dst = '\0';
    len = (int) (dst - dstTokenStart);  /* Return length of token. */

#if (STRN_ZERO_PAD == 1)
    /* Pad with zeros. */
    for (++dst; dst <= lim; )
        *dst++ = 0;
#endif  /* STRN_ZERO_PAD */

    return (len);
}   /* Strntok */

strntokc()

int strntokc	(	char *	,
		size_t	,
		char *	,
		const char *	,
		char **
	)

Definition at line 92 of file strtokc.c.

{
    char *cp;
    const char *cp2;
    char c, c2;
    char *start;
    int len;
    char *dst, *lim;

    dst = dstTokenStart;
    lim = dst + tokenSize - 1;      /* Leave room for nul byte. */

    if (parsestr == NULL)
        start = *context;
    else
        start = parsestr;

    if ((start == NULL) || (delims == NULL)) {
        *context = NULL;
        goto done;
    }

    /* Eat leading delimiters. */
    for (cp = start; ; ) {
next1:
        c = *cp++;
        if (c == '\0') {
            /* No more tokens. */
            *context = NULL;
            goto done;
        }
        for (cp2 = delims; ; ) {
            c2 = (char) *cp2++;
            if (c2 == '\0') {
                /* This character was not a delimiter.
                 * The token starts here.
                 */
                start = cp - 1;
                if (dst < lim)
                    *dst++ = c;
                goto starttok;
            }
            if (c2 == c) {
                /* This char was a delimiter. */
                /* Skip it, look at next character. */
                goto next1;
            }
        }
        /*NOTREACHED*/
    }

starttok:
    for ( ; ; cp++) {
        c = *cp;
        if (c == '\0') {
            /* Token is finished. */
            *context = cp;
            break;
        }
        for (cp2 = delims; ; ) {
            c2 = (char) *cp2++;
            if (c2 == '\0') {
                /* This character was not a delimiter.
                 * Keep it as part of current token.
                 */
                break;
            }
            if (c2 == c) {
                /* This char was a delimiter. */
                /* End of token. */
                *cp++ = '\0';
                *context = cp;
                goto done;
            }
        }
        if (dst < lim)          /* Don't overrun token size. */
            *dst++ = c;
    }

done:
    *dst = '\0';
    len = (int) (dst - dstTokenStart);  /* Return length of token. */

#if (STRN_ZERO_PAD == 1)
    /* Pad with zeros. */
    for (++dst; dst <= lim; )
        *dst++ = 0;
#endif  /* STRN_ZERO_PAD */

    return (len);
}   /* strntokc */

Strtok()

char* Strtok	(	char *	,
		const char *
	)

Definition at line 35 of file Strntok.c.

{
    static char *p = NULL;
    char *start, *end;

    if (buf != NULL) {
        p = buf;
    } else {
        if (p == NULL)
            return (NULL);      /* No more tokens. */
    }
    for (start = p, end = p; ; end++) {
        if (*end == '\0') {
            p = NULL;       /* This is the last token. */
            break;
        }
        if (strchr(delims, (int) *end) != NULL) {
            *end++ = '\0';
            p = end;
            break;
        }
    }
    return (start);
}   /* Strtok */

strtokc()

char* strtokc	(	char *	,
		const char *	,
		char **
	)

Definition at line 7 of file strtokc.c.

{
    char *cp;
    const char *cp2;
    char c, c2;
    char *start;

    if (parsestr == NULL)
        start = *context;
    else
        start = parsestr;

    if ((start == NULL) || (delims == NULL)) {
        *context = NULL;
        return NULL;
    }

    /* Eat leading delimiters. */
    for (cp = start; ; ) {
next1:
        c = *cp++;
        if (c == '\0') {
            /* No more tokens. */
            *context = NULL;
            return (NULL);
        }
        for (cp2 = delims; ; ) {
            c2 = (char) *cp2++;
            if (c2 == '\0') {
                /* This character was not a delimiter.
                 * The token starts here.
                 */
                start = cp - 1;
                goto starttok;
            }
            if (c2 == c) {
                /* This char was a delimiter. */
                /* Skip it, look at next character. */
                goto next1;
            }
        }
        /*NOTREACHED*/
    }

starttok:
    for ( ; ; cp++) {
        c = *cp;
        if (c == '\0') {
            /* Token is finished. */
            *context = cp;
            break;
        }
        for (cp2 = delims; ; ) {
            c2 = (char) *cp2++;
            if (c2 == '\0') {
                /* This character was not a delimiter.
                 * Keep it as part of current token.
                 */
                break;
            }
            if (c2 == c) {
                /* This char was a delimiter. */
                /* End of token. */
                *cp++ = '\0';
                *context = cp;
                return (start);
            }
        }
    }
    return (start);
}   /* strtokc */