LibMain.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#include <stdlib.h>         // malloc, free
#if __DCL_PTHREAD
#include <pthread.h>        // pthread_mutex_lock, pthread_mutex_unlock
#elif __DCL_WINDOWS
#include <windows.h>        // InterlockedIncrement, InterlockedDecrement
#endif
 
#include <dcl/Object.h>
#include <dcl/Exception.h>
#include <dcl/Thread.h>
#include <dcl/StringWriter.h>
#include "LibState.h"
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/LibMain.cpp");
 
//#undef new
#undef malloc
#undef realloc
#undef calloc
#undef free
 
__DCL_BEGIN_NAMESPACE
 
#if __DCL_PTHREAD
static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER;
 
inline long __incrementAndGet(volatile long& _n)
{
    pthread_mutex_lock(&__mutex);
    long n = ++_n;
    pthread_mutex_unlock(&__mutex);
    return n;
}
 
inline long __decrementAndGet(volatile long& _n)
{
    pthread_mutex_lock(&__mutex);
    long n = --_n;
    pthread_mutex_unlock(&__mutex);
    return n;
}
#elif __DCL_WINDOWS
inline long __incrementAndGet(volatile long& _n)
{
    return InterlockedIncrement(&_n);
}
 
inline long __decrementAndGet(volatile long& _n)
{
    return InterlockedDecrement(&_n);
}
#endif
 
LibState*   __pLibState = NULL;
static long __initializeCount = 0;
 
// Thread.cpp
extern void __initializeThreadEnvironment();
extern void __cleanupThreadEnvironment();
 
static int __DCLInitialize()
{
    long initCount =__incrementAndGet(__initializeCount);
#if __DCL_DEBUG
    if (__pLibState) {
        __DCL_TRACE1(__T("__DCLInitialize initCount [%d]\n"), initCount);
    }
#endif
 
    if (initCount == 1) {
        __initializeThreadEnvironment();
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
#endif
        /*
        __pLibState = new LibState();
        Object.h에서 정의한 new가 호출되기 때문에 이것을 사용할 수 없다.
        */
        __pLibState = (LibState*) malloc(sizeof(LibState));
        new((void*)__pLibState) LibState;
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
    }
 
    return initCount;
}
 
static void __DCLCleanup()
{
    if (__decrementAndGet(__initializeCount) == 0) {
        if (__pLibState->pfnSQLCleanup)  {
            __pLibState->pfnSQLCleanup();
            __pLibState->pfnSQLCleanup = NULL;
        }
#ifndef __DCL_HAVE_ALLOC_DEBUG
        // 2024-11-16
        // regex에서
        // 메모리 디버깅을 위한 DCL의  new, new[]이 호출 된다.
        // 이들은 main을 빠져 나간 후, 프로세스 종료 직전에 컴파일러에에 의해
        // delete가 호출된다.
        // ALLOC_DEBUG 상태의 delete, delete[]가 사용될 수 있도록 남겨놓는다.
        __pLibState->~LibState();
        free(__pLibState);
        __pLibState = NULL;
#endif
        __cleanupThreadEnvironment();
    }
}
 
__DCL_END_NAMESPACE
 
__DCL_USING_NAMESPACE
 
#if __DCL_DEBUG
 
static Writer*    __pGlobalDebugOut = NULL;
 
DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetGlobalReport(
                __DCL_NAMESPACE Writer* pNewOut
                )
{
    __pLibState->lockGlobalOutput.lock();
    Writer* pOld = __pGlobalDebugOut;
    __pGlobalDebugOut = pNewOut;
    __pLibState->lockGlobalOutput.unlock();
    return pOld;
}
 
DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetThreadReport(
                unsigned long uThreadId,
                __DCL_NAMESPACE Writer* pNewOut
                )
{
    Writer* pOldOut = NULL;
 
    __pLibState->lockThreadOutput.lock();
 
    PtrHashMap::Node* pNode = __pLibState->mapThreadOutput.find((const void*)(size_t) uThreadId);
    if (pNode) {
        pOldOut = (Writer*)(pNode->value);
        pNode->value = pNewOut;
    }
    else {
        __pLibState->mapThreadOutput[(const void*)(size_t) uThreadId] = pNewOut;
    }
 
    __pLibState->lockThreadOutput.unlock();
 
    return pOldOut;
}

 
DCLCAPI void DCLDebugAssert(
                const char_t*     _filename, 
                unsigned int        _line,
                const char_t*     _expr,
                const char_t*     _message
                ) __DCL_THROWS1(AssertError*)
{
    throw new AssertError(_filename, _line, _expr, _message);
}
 

 
DCLCAPI void DCLDebugTrace(
                const char_t*     _filename,
                unsigned int        _line,
                const char_t*     _format,
                ...
                )
{
    Writer* pOut = NULL;
    __pLibState->lockThreadOutput.lock();
    PtrHashMap::Node* pNode =
        __pLibState->mapThreadOutput.find((const void*)(size_t) Thread::getCurrentThreadId());
    if (pNode) {
        pOut = (Writer*)(pNode->value);
    }
    __pLibState->lockThreadOutput.unlock();
 
    if (!pOut) {
        pOut = __pGlobalDebugOut;
    }
 
    if (pOut) {
        // Writer::vprintf의 구현에 __DCL_TRACE 코드가 있으면 이 부분이 재귀적으로 호출된다.
        StringWriter sw(256);
        sw.printf(__T("%ls:%u "), _filename, _line);
 
        va_list arglist;
        va_start(arglist, _format);
        sw.vprintf(_format, arglist);
        va_end(arglist);
 
        // __pLibState->lockGlobalOutput
        // WIndows CriticalSection, pthread_mutex로 구현되어 있다.
        // CriticalSection의 경우 단일 프로세스, 단일 스레드에서 Block되지 않는다.
        // pthread_mutex는 단일 프로세스, 단일 스레데에서 Block된다.
        if (pOut == __pGlobalDebugOut) {
            __pLibState->lockGlobalOutput.lock();
        }
        try {
            *pOut << sw.toString();
            pOut->flush();
        }
        catch(IOException* e) {
            *pOut << e->toStringAll() << endl;
            e->destroy();
        }
        if (pOut == __pGlobalDebugOut) {
            __pLibState->lockGlobalOutput.unlock();
        }
    }
}
 
#endif  // __DCL_DEBUG
 
#if __DCL_HAVE_MANUAL_INITIALIZE
DCLCAPI int DCLInitialize()
{
    return __DCLInitialize();
}
 
DCLCAPI void DCLCleanup()
{
    __DCLCleanup();
}
#elif defined(__DCL_CORE_EXPORTS)
// DSO Initialize
#if __DCL_WINDOWS
BOOL WINAPI DllMain(
    HINSTANCE hinstDLL, // handle to DLL module
    DWORD fdwReason,    // reason for calling function
    LPVOID lpReserved ) // reserved
{
    switch (fdwReason) {
        case DLL_PROCESS_ATTACH:
            __DCLInitialize();
            break;
        case DLL_PROCESS_DETACH:
            __DCLCleanup();
            break;
        case DLL_THREAD_ATTACH:
            __DCL_TRACE0(__T("DCLCored.dll DLL_THREAD_ATTACH\n"));
            break;
        case DLL_THREAD_DETACH:
            __DCL_TRACE0(__T("DCLCored.dll DLL_THREAD_DETACH\n"));
            break;
    }
    return TRUE;
}
#else
__attribute__((constructor))
void _DCL_init()
{
    __DCLInitialize();
}
 
__attribute__((destructor))
void _DCL_fini() 
{
    __DCLCleanup();
}
#endif
 
#else
 
// Static Library
#ifdef _MSC_VER
#pragma optimize ("", off)
#endif
 
class __LibInitializer
{
public:
    __LibInitializer()
    {
        __DCLInitialize();
    }
    ~__LibInitializer()
    {
        __DCLCleanup();
    }
};
 
static __LibInitializer __libInitializer;
 
#ifdef _MSC_VER
#pragma optimize ("", off)
#endif
 
#endif