trunk/Common/dummy.cpp

#include "dummy.h"

#include <cassert>
#include <cstdarg>
#include <cstdio>
#include <stdexcept>
#include <vector>
#include <iomanip>
#include <array>

#if defined(_WINDOWS)
#include <windows.h>
#include <shlwapi.h>
#if defined(_MSC_VER)
#pragma comment(lib, "shlwapi.lib")
#endif
#else
#include <iconv.h>

#define SYSTEM_CHARSET "EUC-JP"
#define WIDE_CHARSET "utf-16"

static iconv_t ic_c2w = 0, ic_w2c = 0;
#endif
#include <tchar.h>

#include "NsmTypes.h"

#ifdef WINCE
struct tm *__cdecl localtime(const time_t *t)
{
        static struct tm y;
        FILETIME uTm, lTm;
        SYSTEMTIME pTm;
        __int64 t64;
        t64 = *t;
        t64 = (t64 + 11644473600)*10000000;
        uTm.dwLowDateTime = static_cast<DWORD>(t64 & 0xFFFFFFFF);
        uTm.dwHighDateTime= static_cast<DWORD>(t64 >> 32);
        FileTimeToLocalFileTime(&uTm,&lTm);
        FileTimeToSystemTime(&lTm,&pTm);
        y.tm_year = pTm.wYear - 1900;
        y.tm_mon = pTm.wMonth - 1;
        y.tm_wday = pTm.wDayOfWeek;
        y.tm_mday = pTm.wDay;
        y.tm_hour = pTm.wHour;
        y.tm_min = pTm.wMinute;
        y.tm_sec = pTm.wSecond;
        return &y;
}

#endif

std::wstring c2w(const std::string &src)
{
#ifdef _WINDOWS
        int bufSize = MultiByteToWideChar(CP_THREAD_ACP, 0, src.c_str(), -1, NULL, 0);
        std::vector<wchar_t> buf(bufSize);
        MultiByteToWideChar(CP_THREAD_ACP, 0, src.c_str(), -1, &buf[0], bufSize);
        return &buf[0];
#else
        //              (void)src;
        //              assert(0);
        if (!ic_c2w) {
                ic_c2w = iconv_open(WIDE_CHARSET, SYSTEM_CHARSET);
        }
        std::vector<wchar_t> buf(src.size() * 3); // [TODO] ���������������[�E�E�E
        std::vector<char> src_buf(src.size() + 1);
        memcpy(&src_buf[0], src.c_str(), sizeof(char) * src.size());
        size_t in = src.size(), out = src.size() * 3;
        char *s_in = (char*)&src_buf[0], *s_out = (char*)&buf[0];
        iconv(ic_c2w, &s_in, &in, &s_out, &out);
        return &buf[0];
#endif
}

std::string w2c(const std::wstring &src)
{
#ifdef _WINDOWS
        int bufSize = WideCharToMultiByte(CP_THREAD_ACP, 0, src.c_str(), -1, NULL, 0, NULL, NULL);
        std::vector<char> buf(bufSize);
        WideCharToMultiByte(CP_THREAD_ACP, 0, src.c_str(), -1, &buf[0], bufSize, NULL, NULL);
        return &buf[0];
#else
        //              (void)src;
        //              assert(0);
        if (!ic_w2c) {
                ic_w2c = iconv_open(SYSTEM_CHARSET, WIDE_CHARSET);
        }
        std::vector<char> buf(src.size() * 3); // [TODO] ���������������[�E�E�E
        std::vector<wchar_t> src_buf(src.size() + 1);
        memcpy(&src_buf[0], src.c_str(), sizeof(wchar_t) * src.size());
        size_t in = src.size(), out = src.size() * 3;
        char *s_in = (char*)&src_buf[0], *s_out = (char*)&buf[0];
        iconv(ic_w2c, &s_in, &in, &s_out, &out);
        return &buf[0];
#endif
}

/*
[TODO]
�������������A���r�����K�v���������_�~�[�������Q
�����I���������K�v����
*/

Regnessem::tstring PtrToHex(const void* value)
{
        Regnessem::tstringstream strm;
        strm << std::hex << std::setfill(TEXT('0')) << std::setw(sizeof(void*) * 2) << value;
        return strm.str();
}

Regnessem::tstring TimeToStr(std::time_t t)
{
        std::array<TCHAR, 16> buffer;
#if defined(_MSC_VER) && !defined(WINCE)
        tm tmp;
        localtime_s(&tmp, &t);
        
        _tcsftime(buffer.data(), std::tuple_size<decltype(buffer)>::value, TEXT("%H:%M:%S"), &tmp);
#else
        _tcsftime(buffer.data(), std::tuple_size<decltype(buffer)>::value, TEXT("%H:%M:%S"), localtime(&t));
#endif
        return buffer.data();
}

Regnessem::tstring ExtractFileName(const Regnessem::tstring &fileName)
{
#ifdef _WINDOWS
        LPCTSTR result = PathFindFileName(fileName.c_str());

        if(!PathIsFileSpec(result))
                return Regnessem::tstring();

        return result;
#else
        tstring::size_type pos = fileName.find_last_of(TEXT("\\/"));
        return pos == tstring::npos ? fileName : fileName.substr( pos+1 );
#endif
}

Regnessem::tstring ExtractFilePath(const Regnessem::tstring &fileName)
{
#ifdef _WINDOWS
        std::vector<TCHAR> buff(fileName.size() + 2);

#ifdef _MSC_VER
        fileName._Copy_s(&buff[0], buff.size(), fileName.size());
#else
        fileName.copy(&buff[0], fileName.size());
#endif

        PathRemoveFileSpec(&buff[0]);
        PathAddBackslash(&buff[0]);

        return &buff[0];
#else
        tstring::size_type pos = fileName.find_last_of(TEXT("\\/"));
        return pos == tstring::npos ? TEXT(".\\") : fileName.substr(0,pos+1 );
#endif
}

bool ForceDirectories(const Regnessem::tstring &dirPath)
{
        for(LPCTSTR begin = dirPath.c_str(), p = PathFindNextComponent(begin); p != NULL; p = PathFindNextComponent(p))
        {
                const Regnessem::tstring work = dirPath.substr(0, p - begin);
                const DWORD attr = GetFileAttributes(work.c_str());
                if(attr == INVALID_FILE_ATTRIBUTES)
                {
                        if(!CreateDirectory(work.c_str(), NULL))
                                return false;
                }
                else if((attr & FILE_ATTRIBUTE_DIRECTORY) == 0)
                        return false;
        }

        return true;
}

std::string formatA(const char* fmt, ...)
{
        std::vector<char> buffer;
        va_list ls;
        va_start(ls,fmt);

        try
        {
#if defined(_MSC_VER) && !defined(WINCE)
                int length = _vscprintf(fmt, ls) + 1;
                if(length < 1)
                        throw std::invalid_argument("error");
                buffer.resize(length);
                int result = _vsprintf_p(&buffer.front(),length,fmt,ls);
#else
                int length;
                buffer.resize(8192);
#if defined(_MSC_VER) && defined(WINCE)
                int result = _vsnprintf(&buffer.front(),8192,fmt,ls);
#else
                int result = vsnprintf(&buffer.front(),8192,fmt,ls);
#endif
                length = result;
#endif
                if(result < 0)
                        throw std::invalid_argument("error");
                buffer[length-1] = '\0';
        }
        catch(...)
        {
                va_end(ls);
                throw;
        }

        va_end(ls);
        return &buffer.front();
}

Regnessem::tstring format(const TCHAR*fmt,...)
{
        class AutoVaList
        {
        public:
                va_list List;
                ~AutoVaList()
                {
                        va_end(List);
                }
        };

        AutoVaList ls;

        va_start(ls.List, fmt);

#if defined(_MSC_VER) && !defined(WINCE)
        int length = _vsctprintf(fmt, ls.List) + 1;
        if(length < 1)
                return fmt;

        std::vector<TCHAR> buffer(length);
        int result = _vstprintf_s(buffer.data(), buffer.size(), fmt, ls.List);
#else
        std::array<TCHAR, 8192> buffer;
        int result = _vsntprintf(buffer.data(), buffer.size(), fmt, ls.List);
        buffer.back() = TCHAR();
#endif
        if(result < 0)
                return fmt;

        return buffer.data();
}

#if defined(WINCE)
LONG_PTR GetWindowLongPtr(
                                                  HWND hWnd,  // �E�B���h�E���n���h��
                                                  int nIndex  // ���������l���I�t�Z�b�g
                                                  )
{
        switch (nIndex) {
case GWLP_WNDPROC:
        nIndex = GWL_WNDPROC;
        break;
case GWLP_HINSTANCE:
        return (LONG_PTR)GetModuleHandle(NULL);
        break;
case GWLP_HWNDPARENT:
        return (LONG_PTR)GetParent(hWnd);
        break;
case GWLP_USERDATA:
        nIndex = GWL_USERDATA;
        break;
case GWLP_ID:
        nIndex = GWL_ID;
        break;
        }
        return (LONG_PTR)GetWindowLong(hWnd, nIndex);
}

LONG_PTR SetWindowLongPtr(
                                                  HWND hWnd,           // �E�B���h�E���n���h��
                                                  int nIndex,          // ���X�����l���I�t�Z�b�g
                                                  LONG_PTR dwNewLong   // �V�����l
                                                  )
{
        switch (nIndex) {
case GWLP_WNDPROC:
        nIndex = GWL_WNDPROC;
        break;
case GWLP_HINSTANCE:
        return (LONG_PTR)GetModuleHandle(NULL);
        break;
case GWLP_HWNDPARENT:
        {
                HWND hPrevWnd = GetParent(hWnd);
                SetParent(hWnd, (HWND)dwNewLong);
                return (LONG_PTR)hPrevWnd;
        }
        break;
case GWLP_USERDATA:
        nIndex = GWL_USERDATA;
        break;
case GWLP_ID:
        nIndex = GWL_ID;
        break;
        }
        return (LONG_PTR)SetWindowLong(hWnd, nIndex, dwNewLong);
}
#endif