nsmsgs/src/nsmsgs.cpp

#include "nsmsgs.h"

#include <array>
#include <algorithm>

#if defined(_WINDOWS)
#include <windows.h>
#else
#include <unistd.h>
#endif
#include <tchar.h>

#include "../../Common/tstring.h"
#include "../../Common/dummy.h"

#include "UFrmNsmMain.h"
#include "UFrmNsmMainDebug.h"
#include "UNsmCom.h"
#include "UNsmSystem.h"
#include "APCQueue.h"

#define CN_BASE 0xBC00

using namespace Regnessem::System;
using Regnessem::tstring;

#ifdef WINCE
class CDelete {
public:
        int operator ()(void* ptr) {
                delete ptr;
                return 0;
        }
};
template <typename T>
class CDynamicAllocator {
private:
        std::vector<T*> m_memmap;
public:
        CDynamicAllocator() {}
        ~CDynamicAllocator() {
                std::for_each(m_memmap.begin(), m_memmap.end(), CDelete());
        }
        T* alloc(int size) {
                return (T*)malloc(sizeof(T)*size);
        }
        void free(T* ptr) {
                std::vector<T*>::iterator it = std::find(m_memmap.begin(), m_memmap.end());
                if (it != m_memmap.end()) {
                        delete *it;
                }
        }
};

CDynamicAllocator<WCHAR> g_da_wchar;
CDynamicAllocator<LPWSTR> g_da_ptr;
LPWSTR* CommandLineToArgvW(LPCWSTR lpCmdLine, int* pNumArgs)
{
        std::vector<LPWSTR> v;
        bool dquote = false;
        *pNumArgs = 1;
        for (LPCWSTR p = lpCmdLine; ; ) {
                if ((*lpCmdLine == L' ' && !dquote) || (*lpCmdLine == L'\0')) {
                        int sz = lpCmdLine - p;
                        wchar_t* ptr = g_da_wchar.alloc(sz+1);
                        memcpy(ptr, p, sizeof(wchar_t)*sz);
                        *(ptr+sz) = L'\0';
                        (*pNumArgs)++;
                        v.push_back(ptr);
                        p = ++lpCmdLine;
                        if ((*lpCmdLine == L'\0'))
                                break;
                }
                if (*lpCmdLine == L'"')
                        dquote = !dquote;
                lpCmdLine++;
        }

        LPWSTR* ptr = g_da_ptr.alloc(v.size()+1);
        LPWSTR* p = ptr;
        LPWSTR exename = g_da_wchar.alloc(MAX_PATH+1);
        GetModuleFileName(NULL, exename, MAX_PATH);
        *(ptr++) = exename;
        for (unsigned int i = 0; i < v.size(); ++i)
                *(ptr++) = v[i];
        return p;
}
#endif

namespace nsmsgs
{
#ifndef _WINDOWS
        void TApplication::Terminate()
        {
                //[TODO]test test
                //assert(0);
                // Linux�p���R�[�h���������B
                m_quit = true;
        }
#endif

        WPARAM Initialize(int argc, TCHAR** argv)
        {
                HANDLE mutex = CreateMutex(NULL, FALSE, Application::Title);
                if(!mutex)
                        return 0;

                const bool isRestart = (std::find(argv + 1, argv + argc, tstring(CommandLineOption::Restart)) != argv + argc);

                if(WaitForSingleObject(mutex, isRestart ? 60000 : 0) == WAIT_TIMEOUT)
                {
                        // ���d�N�����~
                        if(std::find(argv + 1, argv + argc, tstring(CommandLineOption::ForceExecute)) == argv + argc)
                                return 0;
                }

#ifndef WINCE
                g_NsmCom.DebugMode = (std::find(argv + 1, argv + argc, tstring(CommandLineOption::Debug)) != argv + argc);
#else
                g_NsmCom.DebugMode = false;
#endif
                std::unique_ptr<NsmMain> FrmNsmMain;    //���u��

                if (!g_NsmCom.DebugMode)
                {
                        FrmNsmMain.reset(new NsmMain());
                        FrmNsmMain->Initialize();
                }
                else
                {
                        g_NsmCom.DebugWindow.reset(new NsmMainDebug());
                        g_NsmCom.DebugWindow->Initialize();
                }

                /* �������[�����[�� */
#ifdef _WINDOWS
                MSG msg;

                for(;;)
                {
                        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                        {
                                // HACK:delphi���b�Z�[�W
                                if((WM_KEYFIRST <= msg.message && msg.message <= WM_KEYLAST))
                                {
                                        if(SendMessage(msg.hwnd, CN_BASE + msg.message, msg.wParam, msg.lParam))
                                                continue;
                                }

                                TranslateMessage(&msg);
                                DispatchMessage(&msg);

                                if(msg.message == WM_QUIT)
                                        break;
                        }
                        else
                        {
                                //��������������������������������������
                                //if (Application.OnIdle)
                                //      Application.OnIdle();

                                ApcQueue::Wait();
                        }
                }

#else
                while (true) {
                        usleep(10*1000);
                        if (Application.OnIdle)
                                Application.OnIdle();
                        if (Application.Terminated())
                                break;
                }
#endif

                g_NsmSystem.Terminate();

                if(ReleaseMutex(mutex))
                        CloseHandle(mutex);

                return msg.wParam;
        }
}

#if defined(_WINDOWS)  
int APIENTRY _tWinMain(HINSTANCE /* hInstance */, HINSTANCE /* hPrevInstance */, LPTSTR /* lptCmdLine */, int /* nCmdShow */)
{
#if defined(_MSC_VER)
        return static_cast<int>(nsmsgs::Initialize(__argc, __targv));
#else

        int argc;
        TCHAR** argv;

#ifdef UNICODE
        argv = CommandLineToArgvW(GetCommandLine(), &argc);
#else
        assert(0);
#endif

        return (int) nsmsgs::Initialize(argc,argv);

#endif
}
#else  
int main (int argc, char* argv[])  
{
        nsmsgs::Initialize(argc,argv);
        return 0;
}
#endif 

//------------------------------------------------------------------------------------------------

namespace Regnessem
{
        namespace System
        {
                const LPCTSTR Application::Title = TEXT("++Regnessem");

                tstring Application::ExeName()
                {
#ifdef _WINDOWS
                        std::array<TCHAR, MAX_PATH> filename;
                        GetModuleFileName(GetModuleHandle(NULL), filename.data(), std::tuple_size<decltype(filename)>::value);
                        return filename.data();
#else
                        // [TODO] �e�X�g�p�����������@Binary Hacks�������Q��
                        return "./a.exe";
#endif
                }

                void Application::Terminate()
                {
                        PostQuitMessage(0);
                }
        }
}