SF_Std.h

Go to the documentation of this file.

/*
 * Copyright 2016 Autodesk, Inc. All rights reserved.
 * Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
 * or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
 */

#pragma once

#include "gwnavruntime/kernel/SF_Types.h"
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(KY_CC_MSVC)
#define KY_MSVC_SAFESTRING
#include <errno.h>
#endif

// Wide-char funcs
#include <wchar.h>
#include <wctype.h>

namespace Kaim
{

inline UPInt SFstrlen(const char* str) { return strlen(str); }

inline char* SFstrcpy(char* dest, UPInt destsize, const char* src)
{
#if defined(KY_MSVC_SAFESTRING)
    strcpy_s(dest, destsize, src);
    return dest;
#else
    KY_UNUSED(destsize);
    return strcpy(dest, src);
#endif
}

// Note that when using strncpy no null-character is implicitly appended at the end of destination if source is longer than num
// (thus, in this case, destination may not be a null terminated C string).
inline char* SFstrncpy(char* dest, UPInt destsize, const char* src, UPInt count)
{
#if defined(KY_MSVC_SAFESTRING)
    strncpy_s(dest, destsize, src, count);
    return dest;
#else
    KY_UNUSED(destsize);
    return strncpy(dest, src, count);
#endif
}

inline int SFstrcmp(const char* dest, const char* src) { return strcmp(dest, src); }

inline char* SFstrchr(char* str, char c) { return strchr(str, c); }

inline const char* SFstrrchr(const char* str, char c)
{
    UPInt len = SFstrlen(str);
    for (UPInt i = len; i > 0; i--)
    {
        if (str[i] == c)
            return str + i;
    }
    return 0;
}

inline char* SFstrrchr(char* str, char c)
{
    UPInt len = SFstrlen(str);
    for (UPInt i = len; i > 0; i--)
    {
        if (str[i] == c)
            return str + i;
    }
    return 0;
}

inline long SFstrtol(const char* string, char** tailptr, int radix) { return strtol(string, tailptr, radix); }

inline long SFstrtoul(const char* string, char** tailptr, int radix) { return strtoul(string, tailptr, radix); }

inline int SFstrncmp(const char* ws1, const char* ws2, UPInt size) { return strncmp(ws1, ws2, size); }

inline UInt64 SFstrtouq(const char* nptr, char** endptr, int base)
{
#if defined(KY_CC_MSVC)
    return _strtoui64(nptr, endptr, base);
#else
    return strtoull(nptr, endptr, base);
#endif
}

inline SInt64 SFstrtoq(const char* nptr, char** endptr, int base)
{
#if defined(KY_CC_MSVC)
    return _strtoi64(nptr, endptr, base);
#else
    return strtoll(nptr, endptr, base);
#endif
}

inline SInt64 SFatoq(const char* string)
{
#if defined(KY_CC_MSVC)
    return _atoi64(string);
#else
    return atoll(string);
#endif
}

inline UInt64 SFatouq(const char* string) { return SFstrtouq(string, NULL, 10); }

int SFstricmp(const char* dest, const char* src);

int SFstrnicmp(const char* dest, const char* src, UPInt count);

inline UPInt SFsprintf(char* dest, UPInt destsize, const char* format, ...)
{
    va_list argList;
    va_start(argList, format);
    UPInt ret = vsnprintf(dest, destsize, format, argList);
    va_end(argList);
    return ret;
}

inline UPInt SFvsprintf(char* dest, UPInt destsize, const char* format, va_list argList) { return vsnprintf(dest, destsize, format, argList); }

inline wchar_t SFtowlower(wchar_t c) { return (wchar_t)towlower(c); }

inline wchar_t SFtowupper(wchar_t c) { return (wchar_t)towupper(c); }

// ASCII versions of tolower and toupper. Don't use "char"
inline int SFtolower(int c) { return (c >= 'A' && c <= 'Z') ? c - 'A' + 'a' : c; }

}