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 defined(__WINNT__)
#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
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("dcl/LibMain.cpp");
#endif
 
//#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 defined(__WINNT__)
inline long __incrementAndGet(volatile long& _n)
{
    return InterlockedIncrement(&_n);
}
 
inline long __decrementAndGet(volatile long& _n)
{
    return InterlockedDecrement(&_n);
}
#endif
 
LibState*   __LibState__ = NULL;
static long __initializeCount__ = 0;
 
// Thread.cpp
extern void __initializeThreadEnvironment();
extern void __cleanupThreadEnvironment();
 
static int __DCLInitialize()
{
    long initCount =__incrementAndGet(__initializeCount__);
#ifdef __DCL_DEBUG
    if (__LibState__) {
        __DCL_TRACE1(__T("__DCLInitialize initCount [%d]\n"), initCount);
    }
#endif
 
    if (initCount == 1) {
        __initializeThreadEnvironment();
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
#endif
        /*
        __LibState__ = new LibState();
        Object.h에서 정의한 new가 호출되기 때문에 이것을 사용할 수 없다.
        */
        __LibState__ = (LibState*) malloc(sizeof(LibState));
        new((void*)__LibState__) LibState;
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
    }
 
    return initCount;
}
 
static void __DCLCleanup()
{
    if (__decrementAndGet(__initializeCount__) == 0) {
        if (__LibState__->pfnSQLCleanup)    {
            __LibState__->pfnSQLCleanup();
            __LibState__->pfnSQLCleanup = NULL;
        }
#ifndef __DCL_HAVE_ALLOC_DEBUG
        // 2024-11-16
        // regex에서
        // 메모리 디버깅을 위한 DCL의  new, new[]이 호출 된다.
        // 이들은 main을 빠져 나간 후, 프로세스 종료 직전에 컴파일러에에 의해
        // delete가 호출된다.
        // ALLOC_DEBUG 상태의 delete, delete[]가 사용될 수 있도록 남겨놓는다.
        __LibState__->~LibState();
        free(__LibState__);
        __LibState__ = NULL;
#endif
        __cleanupThreadEnvironment();
    }
}
 
__DCL_END_NAMESPACE
 
__DCL_USING_NAMESPACE
 
#ifdef __DCL_DEBUG
 
static Writer*    __pGlobalDebugOut = NULL;
 
DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetGlobalReport(
    __DCL_NAMESPACE Writer* _newOutput
)
{
    __LibState__->lockGlobalOutput.lock();
    Writer* oldOutput = __pGlobalDebugOut;
    __pGlobalDebugOut = _newOutput;
    __LibState__->lockGlobalOutput.unlock();
 
    return oldOutput;
}
 
DCLCAPI __DCL_NAMESPACE Writer* DCLDebugSetThreadReport(
    thread_t _threadId,
    __DCL_NAMESPACE Writer* _newOutput
)
{
    Writer* oldOutput = NULL;
 
    __LibState__->lockThreadOutput.lock();
    PtrHashMap::Node* node = __LibState__->mapThreadOutput.find((const void*)(size_t) _threadId);
    if (node) {
        oldOutput = (Writer*)(node->value);
        node->value = _newOutput;
    }
    else {
        __LibState__->mapThreadOutput[(const void*)(size_t) _threadId] = _newOutput;
    }
    __LibState__->lockThreadOutput.unlock();
 
    return oldOutput;
}

 
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* output = NULL;
    __LibState__->lockThreadOutput.lock();
    PtrHashMap::Node* node =
        __LibState__->mapThreadOutput.find((const void*)(size_t) Thread::self());
    if (node) {
        output = (Writer*)(node->value);
    }
    __LibState__->lockThreadOutput.unlock();
 
    if (!output) {
        output = __pGlobalDebugOut;
    }
 
    if (output) {
        // 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);
 
        // __LibState__->lockGlobalOutput
        // WIndows CriticalSection, pthread_mutex로 구현되어 있다.
        // CriticalSection의 경우 단일 프로세스, 단일 스레드에서 Block되지 않는다.
        // pthread_mutex는 단일 프로세스, 단일 스레데에서 Block된다.
        if (output == __pGlobalDebugOut) {
            __LibState__->lockGlobalOutput.lock();
        }
        try {
            *output << sw.toString();
            output->flush();
        }
        catch(IOException* e) {
            *output << e->toStringAll() << endl;
            e->destroy();
        }
        if (output == __pGlobalDebugOut) {
            __LibState__->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
#ifdef __WINNT__
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