SYS/SYS_String.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Joe Drew
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        SYS_String.h (SYS Library, C++)
 *
 * COMMENTS:
 *      System-independent string manipulation functions.
 */

#ifndef __SYS_String__
#define __SYS_String__

#include "SYS_API.h"

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

#if defined(GAMEOS)
static char *
memccpy(char *dest, const char *src, char find, int size)
{
    int         i;
    for (i = 0; i < size; i++)
    {
        if (*src == find) return dest;
        *dest++ = *src++;
    }
    return 0;
}
#endif

/// A standard name for a strtok that doesn't maintain state between calls.
/// This version is thus both reentrant and threadsafe.
/// SYSstrtok parses a string into a sequence of tokens. On the first call to
/// SYSstrtok, the string to be parsed must be specified as the parameter
/// 'string'. This parameter *will be modified* (destroying your copy).
/// 'delimit' specifies an array of single characters that will be used
/// as delimiters.
/// 'context' is a char * variable used internally by SYSstrtok to maintain
/// context between calls. Subsequent calls must specify the same unchanged
/// context variable as the first call.
/// To use SYSstrtok, on the first call first pass in your string as the 
/// parameter 'string'; on subsequent calls, pass it in as NULL.
/// SYSstrtok returns non-empty strings pointing to the first non-delimiter
/// character of each token, or NULL if no further tokens are available.
/// Example:
/// \code
/// char *string = strdup(getString());
/// char *strptr = string;
/// char *context;
/// char *token = SYSstrtok(string, MY_DELIMITERS, &context);
/// while (token)
/// {
///     do_some_stuff();
///     SYSstrtok(NULL, MY_DELIMITERS, &context);
/// }
/// free(strptr);
/// \endcode
inline char *
SYSstrtok(char *string, const char *delimit, char **context)
{
#ifdef LINUX
    return strtok_r(string, delimit, context);
#else
    // MSVC 2003 doesn't have strtok_r. 2005 has strtok_s, which is the same
    // as strtok_r. Until we upgrade, use this C version of strtok_r.
    if (string == NULL)
    {
        string = *context;
    }

    // Find and skip any leading delimiters.
    string += strspn(string, delimit);

    // There are only delimiters (or no text at all), so we've reached the end
    // of the string.
    if (*string == '\0')
    {
        *context = string;
        return NULL;
    }

    // String now points at a token.
    char *token = string;

    // Find the end of the token.
    string = strpbrk(token, delimit);
    if (!string)
    {
        // This token is at the end of the string. Set the context to point at
        // the end of the string so on the next call, we'll return NULL.
        *context = strchr(token, '\0');
    }
    else
    {
        // This is a token somewhere in the string. Set the found delimiter to
        // zero and initialize the context to the next character.
        *string = '\0';
        *context = string + 1;
    }

    return token;
#endif
}

/// The semantics for strncpy() leave a little to be desired
///  - If the buffer limit is hit, the string isn't guaranteed to be null
///     terminated.
///  - If the buffer limit isn't hit, the entire remainder of the string is
///     filled with nulls (which can be costly with large buffers).
/// The following implements the strlcpy() function from OpenBSD.  The function
/// is very similar to strncpy() but
///     The return code is the length of the src string
///     The resulting string is always null terminated (unless size == 0)
///     The remaining buffer is not touched
/// It's possible to check for errors by testing rcode >= size.
inline size_t
SYSstrlcpy(char *dest, const char *src, size_t size)
{
    char        *end;
    end = (char *)::memccpy(dest, src, 0, size);
    if (end)
    {
        *end = 0;
        return end - dest - 1;
    }
    // No null terminator found in the first size-1 bytes
    if (size)
        dest[size-1] = 0;
    return size + ::strlen(src+size);
}

/// The following implements the strlcpy() function from OpenBSD.  The
/// differences between strlcpy() and strncpy() are:
///     - The buffer will not be filled with null
///     - The size passed in is the full length of the buffer (not
///             remaining length)
///     - The dest will always be null terminated (unless it is already larger
///             than the size passed in)
/// The function returns strln(src) + SYSmin(size, strlen(dest))
/// If rcode >= size, truncation occurred

inline size_t
SYSstrlcat(char *dest, const char *src, size_t size)
{
    char        *end;
    size_t       dlen;

    // Find the length of the dest buffer.  Only check for a null within the
    // allocated space of the buffer (i.e. we can't use strlen()).
    for (dlen = 0; dlen < size; dlen++)
        if (!dest[dlen])
            break;
    if (dlen == size)
        return size + ::strlen(src);    // Not enough space left
    // Now, copy the source over
    end = (char *)::memccpy(dest+dlen, src, 0, size-dlen);
    if (end)
    {
        *end = 0;
        return end - dest - 1;
    }
    if (size)
        dest[size-1] = 0;
    return dlen + ::strlen(src);
}

inline bool
SYSisspace(char c)
{
    // cast to unsigned so that we don't pass negative numbers to isspace
    // or else it will assert on Windows
    return isspace((unsigned char)c);
}

inline bool
SYSisspace(unsigned char c)
{
    return isspace(c);
}

inline bool
SYSisspace(int c)
{
    if (c < 0 || c > 127)
        return false;
    else
        return isspace(c);
}

#endif

---