root/lang/cplusplus/i3/trunk/src/mol/include/mol/MscCrt.h @ 28097

#pragma once

#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <limits>

namespace mol
{
namespace msccrt
{
template <typename Char>
inline static size_t basic_strnlen_s(const Char* str, size_t numberOfElements)
{
    using namespace std;

    if (str == NULL)
    {
        return 0;
    }
    if (numberOfElements == 0)
    {
        return 0;
    }
    if (str + numberOfElements < str) {
        return numberOfElements; //TODO
    }
    size_t size = 0;
    for (; size != numberOfElements &&
           str[size] &&
           size < (numeric_limits<size_t>::max)(); size++) {}
    return size;
}

template <typename Char>
inline static int basic_strcpy_s(Char* strDestination,
                                 size_t numberOfElements,
                                 const Char* strSource)
{
    using namespace std;

    if (strDestination == 0)
    {
        return EINVAL;
    }
    if (strSource == 0)
    {
        return EINVAL;
    }
    if (numberOfElements == 0)
    {
        return ERANGE;
    }
    if (strSource[0] == 0) {
        strDestination[0] = 0;
        return 0;
    }
    size_t strSourceElements = basic_strnlen_s<Char>(strSource, numberOfElements);
    if (strSourceElements == numberOfElements)
    {
        return ERANGE;
    }
    size_t memcpyBytes = sizeof(Char) * (strSourceElements);
    if (memcpyBytes < sizeof(Char) ||
        memcpyBytes < strSourceElements) {
        return ERANGE; //TODO
    }
    if (reinterpret_cast<char*>(strDestination) + memcpyBytes < 
            reinterpret_cast<char*>(strDestination)) {
        return ERANGE; //TODO
    }
    memcpy(reinterpret_cast<void*>(strDestination),
           reinterpret_cast<const void*>(strSource),
           memcpyBytes);
    strDestination[strSourceElements] = 0;
    return 0;
}

template <typename Char>
inline static int basic_strcat_s(Char* strDestination,
                                 size_t numberOfElements,
                                 const Char* strSource)
{
    using namespace std;

    if (strDestination == 0)
    {
        return EINVAL;
    }
    if (strSource == 0)
    {
        return EINVAL;
    }
    if (numberOfElements == 0)
    {
        return ERANGE;
    }
    size_t strDestinationElements = basic_strnlen_s<Char>(strDestination,
                                    numberOfElements);
    if (strDestinationElements == numberOfElements)
    {
        return EINVAL;
    }
    if (numberOfElements < strDestinationElements) {
        return EINVAL; //TODO
    }
    size_t strDestinationElementsLeft =
        numberOfElements - strDestinationElements;
    size_t strSourceElements =
        basic_strnlen_s<Char>(strSource, strDestinationElementsLeft);
    if (strSourceElements == strDestinationElementsLeft)
    {
        return ERANGE;
    }
    if (strDestination + strDestinationElements < strDestination) {
        return ERANGE; //TODO
    }
    if (strSourceElements + 1 < strSourceElements) {
        return ERANGE; //TODO
    }
    return basic_strcpy_s<Char>(
        strDestination + strDestinationElements,
        strSourceElements + 1,
        strSource
        );
}

template <typename Char, size_t size>
inline static int basic_strcpy_s(Char (&strDestination)[size],
                                 const Char* strSource)
{
    return basic_strcpy_s(strDestination, size, strSource);
}

template <typename Char, size_t size>
inline static int basic_strcat_s(Char (&strDestination)[size],
                                 const Char* strSource)
{
    return basic_strcat_s(strDestination, size, strSource);
}

}
}


using mol::msccrt::basic_strnlen_s;
using mol::msccrt::basic_strcpy_s;
using mol::msccrt::basic_strcat_s;

#if !defined(_MSC_VER)

#define strnlen_s basic_strnlen_s<char>
#define strcpy_s basic_strcpy_s<char>
#define strcat_s basic_strcat_s<char>

#define wcsnlen_s basic_strnlen_s<wchar_t>
#define wcscpy_s basic_strcpy_s<wchar_t>
#define wcscat_s basic_strcat_s<wchar_t>

#define _tcsnlen basic_strnlen_s<TCHAR>
#define _tcscpy_s basic_strcpy_s<TCHAR>
#define _tcscat_s basic_strcat_s<TCHAR>

#include <time.h>
#include <string.h>
#include <errno.h>

#ifndef _countof
#define _countof(array) (sizeof(array)/sizeof(array[0]))
#endif

namespace mol
{
namespace msccrt
{


#ifndef _T
#define _T TEXT
#endif

#if defined(UNICODE) || defined(_UNICODE)

#ifndef TEXT
#define TEXT(x) L##x
#endif

#define _tprintf wprintf
#define _stprintf_s swprintf_s

#else

#ifndef TEXT
#define TEXT(x) x
#endif

#define _tprintf printf
#define _stprintf_s sprintf_s

#endif

// XXX ???
typedef int errno_t;

#ifndef __GNUC__

template <size_t size>
inline static int swprintf_s(wchar_t (&buffer)[size],
                             const wchar_t *format, ...)
{
    va_list ap;
    va_start(ap, format);
    int result = vswprintf(buffer,size,format,ap);
    va_end(ap);
    return result;
}


template <size_t size>
inline static int sprintf_s(char (&buffer)[size],
                            const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    int result = snprintf(buffer,size,format,ap);
    va_end(ap);
    return result;
}

#endif

inline static errno_t localtime_s(struct tm* tm_, const time_t *time_)
{
    *tm_ = *localtime(time_); // XXX localtime is not thread safe !
    return !EINVAL;
}

#ifdef __CYGWIN__
#define wcsdup _wcsdup
inline static wchar_t* _wcsdup(const wchar_t *str)
{
    size_t len = 0;
    for (; len<str[len]; len++);
    if (len == 0)
    {
        return NULL;
    }
    size_t memory_size = sizeof(wchar_t)*(len+1);
    wchar_t* d = reinterpret_cast<wchar_t*>(malloc(memory_size));
    if (!d)
    {
        return NULL;
    }
    memcpy(d, str, memory_size);
    return d;
}
#endif

#if (defined(WIN32) || defined(_WIN32) || defined(_WIN64) || defined(_WIN32_WCE)) && !defined(__CYGWIN__)
#include <windows.h>
#include <tchar.h>

template <size_t drivesize, size_t dirsize, size_t fnamesize, size_t extsize>
inline static errno_t _tsplitpath_s(
    const TCHAR *path,
    TCHAR (&drive)[drivesize],
    TCHAR (&dir)[dirsize],
    TCHAR (&fname)[fnamesize],
    TCHAR (&ext)[extsize])
{
    _tsplitpath(path, drive, dir, fname, ext);
    return !EINVAL;
}

template <size_t size>
inline static errno_t _tmakepath_s(
    TCHAR (&path)[size],
    const TCHAR *drive,
    const TCHAR *dir,
    const TCHAR *fname,
    const TCHAR *ext)
{
    _tmakepath(path, drive, dir, fname, ext);
    return !EINVAL;
}

#endif

}
}

#endif