Restructure repository to include all source folders

Move git root from Client/ to src/ to track all source code:
- Client: Game client source (moved to Client/Client/)
- Server: Game server source
- GameTools: Development tools
- CryptoSource: Encryption utilities
- database: Database scripts
- Script: Game scripts
- rylCoder_16.02.2008_src: Legacy coder tools
- GMFont, Game: Additional resources

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

CryptoSource/SQLExecute/Nave/NFFilePtr.h

@@ -0,0 +1,283 @@
+/** 
+ *  @file		NFFilePtrA.h
+ *  @brief		FILE auto close class
+ *  @remarks	
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+#include <stdio.h>
+
+namespace Nave {
+
+	/** 
+	 *  @class		  NFFilePtrW  
+	 *  @brief        FILE auto close class
+	 *  @remarks      NFFilePtrW file(L"c:\1.txt", L"rt");		\r\n
+	 *                fgets(str, 128, file);					\r\n
+	 *                return;
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-05
+	 */
+	class NFFilePtrW
+	{
+	public:
+		/// NFFilePtrW 생성자
+		NFFilePtrW() : m_pFile(NULL)
+		{
+		}
+
+		/**
+		 * @brief 파일 자동열기 생성자
+		 * @param file 파일명
+		 * @param mode 파일 모드
+		 */
+		NFFilePtrW(LPCWSTR file, LPCWSTR mode)
+		{
+			m_pFile = _wfopen(file, mode);
+		}
+
+		/// NFFilePtrW 소멸자
+		~NFFilePtrW()
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = NULL;
+		}
+
+		/**
+		 * @brief NFFilePtrW1 = FilePtrW2 이터레이터
+		 * @warning NFFilePtrW2는 더이상 사용할수 없습니다.
+		 */
+		NFFilePtrW& operator=(NFFilePtrW& _Right) throw()
+		{
+			Reset(_Right.Release());
+			return (*this);
+		}
+
+		/**
+		 * @brief NFFilePtrW = FILE* 이터레이터
+		 * @warning NFFilePtrW에서 자동 fclose가 됩니다.    \r\n
+		 *          FILE*객체를 fclose하면 문제가 발생할 수있습니다.
+		 */
+		NFFilePtrW& operator=(FILE* _Right) throw()
+		{
+			Reset(_Right);
+			return (*this);
+		}
+
+		/**
+		 * @brief FILE* 형변환 오퍼레이터 입니다.
+		 * @return 현재의 파일 포인터
+		 */
+		operator FILE*() const throw()
+		{
+			return m_pFile;
+		}
+
+		/**
+		 * @brief 파일 포인터를 초기화 합니다. FILE이 close 되지 않습니다.
+		 * @return  현재의 파일 포인터
+		 */
+		FILE* Release()
+		{
+			FILE* fp = m_pFile;
+			m_pFile = NULL;
+			return fp;
+		}
+
+		/**
+		 * @brief 새로운 값으로 재설정합니다. 기존의 FILE은 close 됩니다.
+		 * @param fp 새로운 파일 포인터
+		 */
+		void Reset(LPCWSTR file, LPCWSTR mode)
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = _wfopen(file, mode);
+		}
+
+		/**
+		 * @brief 새로운 값으로 재설정합니다.
+		 *   기존의 FILE은 close 됩니다.
+		 * @param fp 새로운 파일 포인터
+		 */
+		void Reset(FILE* fp)
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = fp;
+		}
+
+		/**
+		* @brief 파일의 끝인지 검사합니다.
+		*/
+		int IsEOF()
+		{
+			return feof(m_pFile);
+		}
+
+		/**
+		 * @brief 파일의 길이를 리턴합니다.
+		 * @return  파일의 길이
+		 */
+		long Length()
+		{
+			fpos_t cuspos;
+			if(fgetpos( m_pFile, &cuspos ) != 0)
+			return -1; // error
+
+			fseek( m_pFile, 0L, SEEK_END );
+			long length = ftell( m_pFile );
+
+			fsetpos(m_pFile, &cuspos);
+			return length;
+		}
+
+
+	private:
+		/// 파일 포인터
+		FILE* m_pFile;
+	};
+
+	/** 
+	 *  @class		  NFFilePtrA
+	 *  @brief        FILE auto close class
+	 *  @remarks      NFFilePtrA file("c:\1.txt", "rt");		\r\n
+	 *                fgets(str, 128, file);					\r\n
+	 *                return;
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-05
+	 */
+	class NFFilePtrA
+	{
+	public:
+		/// NFFilePtrA 생성자
+		NFFilePtrA() : m_pFile(NULL)
+		{
+		}
+
+		/**
+		 * @brief 파일 자동열기 생성자
+		 * @param file 파일명
+		 * @param mode 파일 모드
+		 */
+		NFFilePtrA(LPCSTR file, LPCSTR mode)
+		{
+			m_pFile = fopen(file, mode);
+		}
+
+		/// NFFilePtrA 소멸자
+		~NFFilePtrA()
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = NULL;
+		}
+
+		/**
+		 * @brief NFFilePtr1 = FilePtrW2 이터레이터
+		 * @warning NFFilePtr2는 더이상 사용할수 없습니다.
+		 */
+		NFFilePtrA& operator=(NFFilePtrA& _Right) throw()
+		{
+			Reset(_Right.Release());
+			return (*this);
+		}
+
+		/**
+		 * @brief NFFilePtrA = FILE* 이터레이터
+		 * @warning NFFilePtr에서 자동 fclose가 됩니다.    \r\n
+		 *          FILE*객체를 fclose하면 문제가 발생할 수있습니다.
+		 */
+		NFFilePtrA& operator=(FILE* _Right) throw()
+		{
+			Reset(_Right);
+			return (*this);
+		}
+
+		/**
+		 * @brief FILE* 형변환 오퍼레이터 입니다.
+		 * @return 현재의 파일 포인터
+		 */
+		operator FILE*() const throw()
+		{
+			return m_pFile;
+		}
+
+		/**
+		 * @brief 파일 포인터를 초기화 합니다. FILE이 close 되지 않습니다.
+		 * @return  현재의 파일 포인터
+		 */
+		FILE* Release()
+		{
+			FILE* fp = m_pFile;
+			m_pFile = NULL;
+			return fp;
+		}
+
+		/**
+		 * @brief 새로운 값으로 재설정합니다. 기존의 FILE은 close 됩니다.
+		 * @param fp 새로운 파일 포인터
+		 */
+		void Reset(LPCSTR file, LPCSTR mode)
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = fopen(file, mode);
+		}
+
+		/**
+		 * @brief 새로운 값으로 재설정합니다.
+		 *   기존의 FILE은 close 됩니다.
+		 * @param fp 새로운 파일 포인터
+		 */
+		void Reset(FILE* fp)
+		{
+			if(m_pFile)
+				fclose(m_pFile);
+
+			m_pFile = fp;
+		}
+
+		/**
+		* @brief 파일의 끝인지 검사합니다.
+		*/
+		int IsEOF()
+		{
+			return feof(m_pFile);
+		}
+
+		/**
+		 * @brief 파일의 길이를 리턴합니다.
+		 * @return  파일의 길이
+		 */
+		long Length()
+		{
+			fpos_t cuspos;
+			if(fgetpos( m_pFile, &cuspos ) != 0)
+			return -1; // error
+
+			fseek( m_pFile, 0L, SEEK_END );
+			long length = ftell( m_pFile );
+
+			fsetpos(m_pFile, &cuspos);
+			return length;
+		}
+
+
+	private:
+		/// 파일 포인터
+		FILE* m_pFile;
+	};
+
+}

CryptoSource/SQLExecute/Nave/NFIni.cpp

@@ -0,0 +1,100 @@
+#include "Nave.h"
+#include "NFIni.h"
+
+namespace Nave { 
+
+	NFIni::NFIni()
+	{
+		ZeroMemory(m_szFileName, sizeof(m_szFileName));
+	}
+
+	NFIni::~NFIni()
+	{
+	}
+
+	BOOL NFIni::Open(LPCWSTR fileName)
+	{
+		if (!fileName)
+			return FALSE;
+
+		wcsncpy(m_szFileName, fileName, MAX_PATH);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::Close()
+	{
+		return TRUE;
+	}
+
+	BOOL NFIni::GetValue(LPCWSTR keyName, LPCWSTR valueName, LPDWORD value)
+	{
+		if (!keyName || !valueName || !value)
+			return FALSE;
+
+		*value = GetPrivateProfileIntW(keyName, valueName, 0, m_szFileName);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::GetValue(LPCWSTR keyName, LPCWSTR valueName, FLOAT *value)
+	{
+		if (!keyName || !valueName || !value)
+			return FALSE;
+
+		WCHAR Value[16] = {0,};
+
+		GetPrivateProfileStringW(keyName, valueName, L"", Value, 16, m_szFileName);
+
+		*value = (FLOAT)_wtof(Value);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::GetValue(LPCWSTR keyName, LPCWSTR valueName, LPWSTR value, DWORD bufferLength)
+	{
+		if (!keyName || !valueName || !value || bufferLength == 0)
+			return FALSE;
+
+		GetPrivateProfileStringW(keyName, valueName, L"", value, bufferLength, m_szFileName);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::SetValue(LPCWSTR keyName, LPCWSTR valueName, DWORD value)
+	{
+		if (!keyName || !valueName)
+			return FALSE;
+
+		WCHAR Value[16]	= {0,};
+		_itow(value, Value, 10);
+
+		WritePrivateProfileStringW(keyName, valueName, Value, m_szFileName);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::SetValue(LPCWSTR keyName, LPCWSTR valueName, LPCWSTR value)
+	{
+		if (!keyName || !valueName || !value)
+			return FALSE;
+
+		WritePrivateProfileStringW(keyName, valueName, value, m_szFileName);
+
+		return TRUE;
+	}
+
+	BOOL NFIni::SetValue(LPCWSTR keyName, LPCWSTR valueName, FLOAT value)
+	{
+		if (!keyName || !valueName)
+			return FALSE;
+
+		WCHAR Value[16]	= {0,};
+		swprintf(Value, L"%f", value);
+
+		WritePrivateProfileStringW(keyName, valueName, Value, m_szFileName);
+
+		return TRUE;
+	}
+
+} 

CryptoSource/SQLExecute/Nave/NFIni.h

@@ -0,0 +1,103 @@
+/** 
+ *  @file		NFIni.h
+ *  @brief		INI 파일 관리자
+ *  @remarks	
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+namespace Nave { 
+
+	/** 
+	 *  @class        NFIni
+	 *  @brief        INI파일을 사용하기 쉽게 만든 관리 클래스
+	 *  @remarks      NFIni ini;										\r\n
+	 *                ini.Open(L"c:\\Init.ini");						\r\n
+	 *                ini.SetValue(L"SERVER CONFIG", L"PORT", dwPort);	\r\n
+	 *                ini.Close();										\r\n
+	 *                
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-04
+	 */
+	class NFIni
+	{
+	public:
+		/// NFIni 생성자
+		NFIni();
+		/// NFIni 소멸자
+		~NFIni();
+
+	public:
+		/**
+		 * @brief		INI파일을 오픈합니다.
+		 * @param fileName	파일명
+		 * @return		성공여부
+		 */
+		BOOL	Open(LPCWSTR fileName);
+
+		/**
+		 * @brief		INI파일을 종료합니다.
+		 * @return		성공여부
+		 */
+		BOOL	Close();
+
+		/**
+		 * @brief		INI파일에 값을 넣습니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			값
+		 * @return		성공여부
+		 */
+		BOOL	SetValue(LPCWSTR keyName, LPCWSTR valueName, LPCWSTR value);
+		/**
+		 * @brief		INI파일에 값을 넣습니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			값
+		 * @return		성공여부
+		 */
+		BOOL	SetValue(LPCWSTR keyName, LPCWSTR valueName, DWORD value);
+		/**
+		 * @brief		INI파일에 값을 넣습니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			값
+		 * @return		성공여부
+		 */
+		BOOL	SetValue(LPCWSTR keyName, LPCWSTR valueName, FLOAT value);
+
+		/**
+		 * @brief		INI파일에 값을 가져옵니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			저장 버퍼
+		 * @param bufferLength	퍼버의 길이
+		 * @return		성공여부
+		 */
+		BOOL	GetValue(LPCWSTR keyName, LPCWSTR valueName, LPWSTR value,  DWORD bufferLength);
+		/**
+		 * @brief		INI파일에 값을 가져옵니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			저장 버퍼
+		 * @return		성공여부
+		 */
+		BOOL	GetValue(LPCWSTR keyName, LPCWSTR valueName, LPDWORD value);
+		/**
+		 * @brief		INI파일에 값을 가져옵니다.
+		 * @param keyName		Key 이름
+		 * @param valueName		Value 이름
+		 * @param value			저장 버퍼
+		 * @return		성공여부
+		 */
+		BOOL	GetValue(LPCWSTR keyName, LPCWSTR valueName, FLOAT *value);
+
+	private:
+		/// INI 파일명
+		WCHAR	m_szFileName[MAX_PATH];
+	};
+
+} 

CryptoSource/SQLExecute/Nave/NFSingleton.h

@@ -0,0 +1,128 @@
+/** 
+ *  @file		NFSingleton.h
+ *  @brief		싱글톤 클래스
+ *  @remarks	
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+#include <windows.h>
+#include <stdio.h>
+#include <assert.h>
+
+/*
+#include "NFSingleton.h"
+
+class Test : public Nave::NFSingleton<Test>
+{
+public:
+	Test()
+	{
+		printf("Test::Test()\n");
+	}
+	~Test()
+	{
+		printf("Test::~Test()\n");
+	}
+
+	int GetType()
+	{
+		return 0;
+	}
+};
+
+INT _tmain(INT argc, WCHAR* argv[])
+{
+	// 만약 싱글톤 객체를 사용하려면 
+	// 아래와 같이 사용하기 위해서 한번 New를 하고
+	Test* pTest = new Test;
+
+
+	// 다른 위치의 다른함수.
+	Test::GetInstance().GetType(); 와 같이 사용하면 된다.
+
+
+	delete pTest;
+}
+*/
+
+#pragma warning (disable : 4311)
+#pragma warning (disable : 4312)
+
+namespace Nave {
+
+	/** 
+	 *  @class        NFSingleton
+	 *  @brief        클래스 객체를 싱글톤으로 생성합니다.
+	 *  @remarks      
+	 *             
+	 *  @warning	  해당 싱글톤 객체는 처음 생성은 직접 new로 생성을 해주고	\r\n
+	 *				  delete가 될때까지 싱글톤 같이 사용하며 프로그램이 종료될때\r\n
+	 *				  delete를 해주면 된다.										
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-05
+	 */
+	template <typename T> class NFSingleton
+	{
+	
+	public:
+		/// NFSingleton 생성자
+		NFSingleton (void)
+		{
+			assert( !s_pSingleton && "NFSingleton : You can't create more"
+					" object, because this object is SINGLETON.");
+
+	#if defined( _MSC_VER ) && _MSC_VER < 1200	 
+			int iOffset = (int)(T*)1 - (int)(NFSingleton <T>*)(T*)1;
+			s_pSingleton = (T*)((int) this + iOffset);
+	#else
+			s_pSingleton = static_cast< T* >( this );
+	#endif
+		}
+
+		/// NFSingleton 소멸자
+		~NFSingleton (void)
+		{
+			assert( s_pSingleton && "NFSingleton : This object may be "
+					"destroyed by someone's memory control or other causes.");
+
+			s_pSingleton = 0;
+		}
+
+		/// 해당 싱글톤 객체가 생성되는지 확인한다.
+		static bool IsAlive()
+		{
+			return s_pSingleton ? true : false;
+		}
+
+		/// 싱글톤 객체의 인스턴스를 얻는다.
+		static T& GetInstance(void)
+		{
+			assert (s_pSingleton && "NFSingleton : Something is wrong."
+						" This object destroyed by something bad method or"
+						"you didn't create yet!");
+
+			return *s_pSingleton;
+		}
+
+		/// 싱글톤 객체의 유일한 인스턴스의 포인터를 얻는다
+		static T* GetInstancePtr(void)
+		{
+			assert (s_pSingleton && "NFSingleton : Something is wrong."
+						" This object destroyed by something bad method.");
+
+			return s_pSingleton;
+		}
+
+	private:
+		/// 싱글톤 객체를 담을 객체의 포인터
+		static T* s_pSingleton;
+	};
+
+	/// 싱글톤 객체 변수를 초기화 한다.
+	template<typename T> T* NFSingleton<T>::s_pSingleton = 0;
+
+}

CryptoSource/SQLExecute/Nave/NFTokenizer.cpp

@@ -0,0 +1,322 @@
+#include "Nave.h"
+#include "NFTokenizer.h"
+
+namespace Nave { 
+
+	NFTokenizerA::NFTokenizerA(const std::string& _str, const std::string& _delim)
+	{
+
+	   if ((_str.length() == 0) || (_delim.length() == 0)) return;
+
+	   token_str = _str;
+	   delim     = _delim;
+
+	  /*
+		 Remove sequential delimiter
+	  */
+	   unsigned int curr_pos = 0;
+
+	   while(true)
+	   {
+		  if ((curr_pos = token_str.find(delim,curr_pos)) != std::string::npos)
+		  {
+			 curr_pos += delim.length();
+
+			 while(token_str.find(delim,curr_pos) == curr_pos)
+			 {
+				token_str.erase(curr_pos,delim.length());
+			 }
+		  }
+		  else
+		   break;
+	   }
+
+	   /*
+		 Trim leading delimiter
+	   */
+	   if (token_str.find(delim,0) == 0)
+	   {
+		  token_str.erase(0,delim.length());
+	   }
+
+	   /*
+		 Trim ending delimiter
+	   */
+	   curr_pos = 0;
+	   if ((curr_pos = token_str.rfind(delim)) != std::string::npos)
+	   {
+		  if (curr_pos != (token_str.length() - delim.length())) return;
+		  token_str.erase(token_str.length() - delim.length(),delim.length());
+	   }
+
+	}
+
+
+	int NFTokenizerA::CountTokens()
+	{
+
+	   unsigned int prev_pos = 0;
+	   int num_tokens        = 0;
+
+	   if (token_str.length() > 0)
+	   {
+		  num_tokens = 0;
+
+		  unsigned int curr_pos = 0;
+		  while(true)
+		  {
+			 if ((curr_pos = token_str.find(delim,curr_pos)) != std::string::npos)
+			 {
+				num_tokens++;
+				prev_pos  = curr_pos;
+				curr_pos += delim.length();
+			 }
+			 else
+			  break;
+		  }
+		  return ++num_tokens;
+	   }
+	   else
+	   {
+		  return 0;
+	   }
+
+	}
+
+	bool NFTokenizerA::HasMoreTokens()
+	{
+	   return (token_str.length() > 0);
+	}
+
+	std::string NFTokenizerA::NextToken()
+	{
+
+	   if (token_str.length() == 0)
+		 return "";
+
+	   std::string  tmp_str = "";
+	   unsigned int pos     = token_str.find(delim,0);
+
+	   if (pos != std::string::npos)
+	   {
+		  tmp_str   = token_str.substr(0,pos);
+		  token_str = token_str.substr(pos+delim.length(),token_str.length()-pos);
+	   }
+	   else
+	   {
+		  tmp_str   = token_str.substr(0,token_str.length());
+		  token_str = "";
+	   }
+
+	   return tmp_str;
+	}
+
+	int NFTokenizerA::NextIntToken()
+	{
+	   return atoi(NextToken().c_str());
+	}
+
+	double NFTokenizerA::NextFloatToken()
+	{
+	   return atof(NextToken().c_str());
+	}
+
+	std::string NFTokenizerA::NextToken(const std::string& delimiter)
+	{
+	   if (token_str.length() == 0)
+		 return "";
+
+	   std::string  tmp_str = "";
+	   unsigned int pos     = token_str.find(delimiter,0);
+
+	   if (pos != std::string::npos)
+	   {
+		  tmp_str   = token_str.substr(0,pos);
+		  token_str = token_str.substr(pos + delimiter.length(),token_str.length() - pos);
+	   }
+	   else
+	   {
+		  tmp_str   = token_str.substr(0,token_str.length());
+		  token_str = "";
+	   }
+
+	   return tmp_str;
+	}
+
+	std::string& NFTokenizerA::RemainingString()
+	{
+	   return token_str;
+	}
+
+	std::string NFTokenizerA::FilterNextToken(const std::string& filterStr)
+	{
+	   std::string  tmp_str    = NextToken();
+	   unsigned int currentPos = 0;
+
+	   while((currentPos = tmp_str.find(filterStr,currentPos)) != std::string::npos)
+	   {
+		  tmp_str.erase(currentPos,filterStr.length());
+	   }
+
+	   return tmp_str;
+	}
+
+
+	// unicode type
+	NFTokenizerW::NFTokenizerW(const std::wstring& _str, const std::wstring& _delim)
+	{
+
+	   if ((_str.length() == 0) || (_delim.length() == 0)) return;
+
+	   token_str = _str;
+	   delim     = _delim;
+
+	  /*
+		 Remove sequential delimiter
+	  */
+	   unsigned int curr_pos = 0;
+
+	   while(true)
+	   {
+		  if ((curr_pos = token_str.find(delim,curr_pos)) != std::wstring::npos)
+		  {
+			 curr_pos += delim.length();
+
+			 while(token_str.find(delim,curr_pos) == curr_pos)
+			 {
+				token_str.erase(curr_pos,delim.length());
+			 }
+		  }
+		  else
+		   break;
+	   }
+
+	   /*
+		 Trim leading delimiter
+	   */
+	   if (token_str.find(delim,0) == 0)
+	   {
+		  token_str.erase(0,delim.length());
+	   }
+
+	   /*
+		 Trim ending delimiter
+	   */
+	   curr_pos = 0;
+	   if ((curr_pos = token_str.rfind(delim)) != std::wstring::npos)
+	   {
+		  if (curr_pos != (token_str.length() - delim.length())) return;
+		  token_str.erase(token_str.length() - delim.length(),delim.length());
+	   }
+
+	}
+
+	int NFTokenizerW::CountTokens()
+	{
+	   unsigned int prev_pos = 0;
+	   int num_tokens        = 0;
+
+	   if (token_str.length() > 0)
+	   {
+		  num_tokens = 0;
+
+		  unsigned int curr_pos = 0;
+		  while(true)
+		  {
+			 if ((curr_pos = token_str.find(delim,curr_pos)) != std::wstring::npos)
+			 {
+				num_tokens++;
+				prev_pos  = curr_pos;
+				curr_pos += delim.length();
+			 }
+			 else
+			  break;
+		  }
+		  return ++num_tokens;
+	   }
+	   else
+	   {
+		  return 0;
+	   }
+
+	}
+
+	bool NFTokenizerW::HasMoreTokens()
+	{
+	   return (token_str.length() > 0);
+	}
+
+	std::wstring NFTokenizerW::NextToken()
+	{
+
+	   if (token_str.length() == 0)
+		 return L"";
+
+	   std::wstring  tmp_str = L"";
+	   unsigned int pos     = token_str.find(delim,0);
+
+	   if (pos != std::wstring::npos)
+	   {
+		  tmp_str   = token_str.substr(0,pos);
+		  token_str = token_str.substr(pos+delim.length(),token_str.length()-pos);
+	   }
+	   else
+	   {
+		  tmp_str   = token_str.substr(0,token_str.length());
+		  token_str = L"";
+	   }
+
+	   return tmp_str;
+	}
+
+	int NFTokenizerW::NextIntToken()
+	{
+	   return _wtoi(NextToken().c_str());
+	}
+
+	double NFTokenizerW::NextFloatToken()
+	{
+	   return _wtof(NextToken().c_str());
+	}
+
+	std::wstring NFTokenizerW::NextToken(const std::wstring& delimiter)
+	{
+	   if (token_str.length() == 0)
+		 return L"";
+
+	   std::wstring  tmp_str = L"";
+	   unsigned int pos     = token_str.find(delimiter,0);
+
+	   if (pos != std::wstring::npos)
+	   {
+		  tmp_str   = token_str.substr(0,pos);
+		  token_str = token_str.substr(pos + delimiter.length(),token_str.length() - pos);
+	   }
+	   else
+	   {
+		  tmp_str   = token_str.substr(0,token_str.length());
+		  token_str = L"";
+	   }
+
+	   return tmp_str;
+	}
+
+	std::wstring& NFTokenizerW::RemainingString()
+	{
+	   return token_str;
+	}
+
+	std::wstring NFTokenizerW::FilterNextToken(const std::wstring& filterStr)
+	{
+	   std::wstring  tmp_str    = NextToken();
+	   unsigned int currentPos = 0;
+
+	   while((currentPos = tmp_str.find(filterStr,currentPos)) != std::wstring::npos)
+	   {
+		  tmp_str.erase(currentPos,filterStr.length());
+	   }
+
+	   return tmp_str;
+	}
+
+} 

CryptoSource/SQLExecute/Nave/NFTokenizer.h

@@ -0,0 +1,120 @@
+/** 
+ *  @file		NFTokenizer.h
+ *  @brief		Tokenizer 클래스
+ *  @remarks	
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <string>
+
+namespace Nave { 
+
+	/** 
+	 *  @class			NFTokenizerA
+	 *  @brief			멀티바이트용 Tokenizer
+	 *  @remarks      
+	 *					Nave::String tempStr = L"01|02|03|04|05|06|07|08|09|10|11|12";		\r\n
+	 *																						\r\n
+	 *					Nave::NFTokenizer strtok = Nave::NFTokenizer(tempStr, L"|");		\r\n
+	 *																						\r\n
+	 *					LOG_IMPORTANT((L"Number Of Tokens: %d"), strtok.CountTokens());		\r\n
+	 *					LOG_IMPORTANT((L"String: %s"), strtok.RemainingString().c_str());	\r\n
+	 *																						\r\n
+	 *					int cnt = strtok.CountTokens();										\r\n
+	 *					Nave::String finalString = L"";										\r\n
+	 *																						\r\n
+	 *					for(int i = 0; i < cnt; i++)										\r\n
+	 *					{																	\r\n
+	 *						Nave::String tempStr = L"";										\r\n
+	 *																						\r\n
+	 *						LOG_IMPORTANT((L"Token[%d] ----> [%s]"), i, strtok.NextToken().c_str());\r\n
+	 *						LOG_IMPORTANT((L"Token Count : %d"), strtok.CountTokens());		\r\n
+	 *																						\r\n
+	 *						finalString += tempStr;											\r\n
+	 *					}																	\r\n
+	 *																						\r\n
+	 *					LOG_IMPORTANT((L"Final String : %s"), finalString.c_str());
+	 *                
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-05
+	 */
+	class NFTokenizerA
+	{
+	public:
+		NFTokenizerA(const std::string& _str, const std::string& _delim);
+		~NFTokenizerA(){};
+
+		int				CountTokens();
+		bool			HasMoreTokens();
+		std::string		NextToken();
+		int				NextIntToken();
+		double			NextFloatToken();
+		std::string		NextToken(const std::string& delim);
+		std::string&	RemainingString();
+		std::string		FilterNextToken(const std::string& filterStr);
+
+	private:
+		std::string		token_str;
+		std::string		delim;
+	};
+
+
+	/** 
+	 *  @class			NFTokenizerW
+	 *  @brief			유니코드용 Tokenizer
+	 *  @remarks      
+	 *					Nave::String tempStr = L"01|02|03|04|05|06|07|08|09|10|11|12";		\r\n
+	 *																						\r\n
+	 *					Nave::NFTokenizer strtok = Nave::NFTokenizer(tempStr, L"|");		\r\n
+	 *																						\r\n
+	 *					LOG_IMPORTANT((L"Number Of Tokens: %d"), strtok.CountTokens());		\r\n
+	 *					LOG_IMPORTANT((L"String: %s"), strtok.RemainingString().c_str());	\r\n
+	 *																						\r\n
+	 *					int cnt = strtok.CountTokens();										\r\n
+	 *					Nave::String finalString = L"";										\r\n
+	 *																						\r\n
+	 *					for(int i = 0; i < cnt; i++)										\r\n
+	 *					{																	\r\n
+	 *						Nave::String tempStr = L"";										\r\n
+	 *																						\r\n
+	 *						LOG_IMPORTANT((L"Token[%d] ----> [%s]"), i, strtok.NextToken().c_str());\r\n
+	 *						LOG_IMPORTANT((L"Token Count : %d"), strtok.CountTokens());		\r\n
+	 *																						\r\n
+	 *						finalString += tempStr;											\r\n
+	 *					}																	\r\n
+	 *																						\r\n
+	 *					LOG_IMPORTANT((L"Final String : %s"), finalString.c_str());
+	 *  @par          
+	 *  @author  Edith
+	 *  @date    2009-04-05
+	 */
+	class NFTokenizerW
+	{
+	public:
+		NFTokenizerW(const std::wstring& _str, const std::wstring& _delim);
+		~NFTokenizerW(){};
+
+		int				CountTokens();
+		bool			HasMoreTokens();
+		std::wstring	NextToken();
+		int				NextIntToken();
+		double			NextFloatToken();
+		std::wstring	NextToken(const std::wstring& delim);
+		std::wstring&	RemainingString();
+		std::wstring	FilterNextToken(const std::wstring& filterStr);
+
+	private:
+		std::wstring	token_str;
+		std::wstring	delim;
+	};
+
+	typedef NFTokenizerW		NFTokenizer;
+
+} 

CryptoSource/SQLExecute/Nave/NFTypes.h

@@ -0,0 +1,93 @@
+/** 
+ *  @file		NFTypes.h
+ *  @brief		Nave Basic Type 선언
+ *  @remarks	
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+#include <string>
+#include <d3dx9math.h>
+#include <atltypes.h>
+
+#pragma warning (disable : 4996)
+
+namespace Nave {
+
+/*
+	int				*				signed, signed int					System dependent 
+	unsigned int	*				unsigned							System dependent 
+	__int8			1				char, signed char					-128 to 127 
+	__int16			2				short, short int, signed short int	-32,768 to 32,767 
+	__int32			4				signed, signed int					-2,147,483,648 to 2,147,483,647 
+	__int64			8				none								-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 
+	bool			1				none								false or true 
+	char			1				signed char							-128 to 127 
+	unsigned char	1				none								0 to 255 
+	short			2				short int, signed short int			-32,768 to 32,767 
+	unsigned short	2				unsigned short int					0 to 65,535 
+	long			4				long int, signed long int			-2,147,483,648 to 2,147,483,647 
+	long long		8				none (but equivalent to __int64)	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 
+	unsigned long	4				unsigned long int					0 to 4,294,967,295 
+	enum			*				none								Same as int 
+	float			4				none								3.4E +/- 38 (7 digits) 
+	double			8				none								1.7E +/- 308 (15 digits) 
+	long double		same as double	none								same as double 
+	wchar_t			2				__wchar_t							0 to 65,535 
+
+
+	strlen		_tcslen
+	strcpy		_tcscpy
+	strncpy		_tcsncpy
+	strcat		_tcscat
+	strcmp		_tcscmp
+	strncmp		_tcsncmp
+	stricmp		_tcsicmp	
+	strnicmp	_tcsnicmp	
+	sscanf		_stscanf
+
+	strtok		_tcstok
+
+	_strdate	_tstrdate
+	_strtime	_tstrtime
+
+	sprintf		_stprintf
+	printf		_tprintf
+
+	atoi		_tstoi
+	atof		_tstof
+
+	fopen		_tfopen
+	fprintf		_ftprintf
+	fgets		_fgetts
+*/
+
+
+// AddFontResource : 특정경로의 ttf폰트를 로드한다, 다한다음 ReleaseAddFone 해줘야한다.
+// res = AddFontResource("C:\Fonts\Nordic__.ttf")
+// 폰트리스트 EnumFontFamilies 
+// gdi+에서 폰트등록 PrivateFontCollection::AddFontFile(...)  
+
+	// basic value types
+	typedef std::wstring		StringW;	/// std::wstring
+	typedef std::string			StringA;	/// std::string
+
+	typedef StringW				String;		/// default string
+
+	typedef char			    int8;		/// -128 to 127
+	typedef short			    int16;		/// -32,768 to 32,767
+	typedef long				int32;		/// -2,147,483,648 to 2,147,483,647
+	typedef __int64             int64;		/// -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
+
+	typedef unsigned char       uint8;		/// 0 to 255
+	typedef unsigned short int  uint16;		/// 0 to 65535
+	typedef unsigned long	    uint32;		/// 0 to 4,294,967,295
+	typedef unsigned __int64    uint64;		/// 0 to 18,446,744,073,709,551,615
+
+	typedef D3DXVECTOR2			float2;		/// 2vector float
+	typedef D3DXVECTOR3			float3;		/// 3vector float
+	typedef D3DXVECTOR4			float4;		/// 4vector float
+}
+

CryptoSource/SQLExecute/Nave/Nave.cpp

@@ -0,0 +1,396 @@
+#include "Nave.h"
+
+namespace Nave {
+
+	HWND			hMainWnd = NULL;
+	HINSTANCE		hInstance = NULL;	
+
+	void EnableLFH()
+	{
+		HANDLE hHeap[1025];
+		UINT uEA = GetProcessHeaps(1024, hHeap);
+
+		for (UINT i=0; i<uEA; ++i)
+		{
+			ULONG  HeapFragValue = 2;
+
+			HeapSetInformation(hHeap[i],
+				HeapCompatibilityInformation,
+				&HeapFragValue,
+				sizeof(HeapFragValue) );
+		}
+	}
+
+	void SetLocale(CHAR* pLocale)
+	{
+		::setlocale(LC_ALL, pLocale);
+	}
+
+	DWORD GetGUID()
+	{
+		static DWORD s_dwPerGUID = 0;
+
+		return ++s_dwPerGUID;
+	}
+
+	SIZE GetStringSize( const WCHAR* string, HFONT font )
+	{
+		HWND hWnd = Nave::hMainWnd;
+		HDC hDC = ::GetDC(hWnd);
+
+		SIZE size;
+		HFONT hOldFont = (HFONT)SelectObject(hDC, font);
+
+		GetTextExtentPoint32W(hDC, string, (INT)wcslen(string), &size);
+
+		TEXTMETRICW	tm; 
+		GetTextMetricsW(hDC, &tm);
+		size.cx -= tm.tmOverhang;
+
+		SelectObject(hDC, hOldFont);
+		::ReleaseDC(hWnd, hDC);
+
+		return size;
+	}
+
+	POINT GetMousePos()
+	{
+		POINT Point;
+		GetCursorPos(&Point);
+		ScreenToClient(hMainWnd, &Point);
+		return Point;
+	}
+
+	POINT GetMousePos( HWND wnd )
+	{
+		POINT Point;
+		GetCursorPos(&Point);
+		ScreenToClient(wnd, &Point);
+		return Point;
+	}
+
+	HWND IsWindowFromPoint()
+	{
+		POINT Point;
+		GetCursorPos(&Point);
+		return WindowFromPoint(Point);
+	}
+
+	INT	GetProgramName( LPWSTR buf, INT len )
+	{
+		WCHAR szDrive[MAX_PATH], szDir[MAX_PATH], szFilename[MAX_PATH], szExt[MAX_PATH];
+
+		// Figure out what the report file will be named, and store it away
+		GetModuleFileNameW(0, buf, len);
+
+		LPWSTR pszDot = buf;
+	    
+		// Look for the '.' before the "EXE" extension. Replace '.' to '\0'
+		if((pszDot = wcsrchr( pszDot, L'.'))) 
+		{
+			*pszDot = 0;
+		}
+
+		_wsplitpath(buf, szDrive, szDir, szFilename, szExt);
+		wcsncpy(buf, szFilename, len);
+
+		return (INT)wcslen( buf );
+	}
+
+	INT GetProgramDir( LPWSTR buf, INT len ) 
+	{
+		WCHAR* ProgDir;
+		INT result;
+
+		result = GetModuleFileNameW( hInstance, buf, len - 1 );
+		if( result == 0 )
+			return 0;
+
+		WCHAR pgmPtr[1024];
+		wcscpy( pgmPtr, buf );
+
+		ProgDir = buf;
+		ProgDir += wcslen( pgmPtr ) - 1;
+		while( *ProgDir != L'\\' && ProgDir != pgmPtr )
+			ProgDir--;
+
+		*ProgDir = 0;
+		return (INT)wcslen( buf );
+	}
+
+	INT GetDir( LPCWSTR path, LPWSTR buf )
+	{
+		wcscpy(buf, path);
+
+		WCHAR* ProgDir;
+		ProgDir = buf;
+		ProgDir += wcslen(buf);
+		while( *ProgDir != L'\\')
+		{
+			ProgDir[0] = 0;
+			ProgDir--;
+		}
+
+		ProgDir[0] = 0;
+		return (INT)wcslen( buf );
+	}
+
+	BOOL GetLine( const CHAR* sBuf, INT maxsBuf, CHAR* tBuf, INT maxtBuf, LONG& index )
+	{
+		ZeroMemory(tBuf, sizeof(tBuf));
+		INT DestIndex = index;
+
+		CHAR* pLine = "\n";
+		INT pLen = strlen(pLine);
+
+		for(INT i = 0; i < maxsBuf; i++)
+		{
+			if(index+i >= maxtBuf)
+				break;
+
+			if(strncmp(&sBuf[index+i], pLine, pLen) == 0)
+			{
+				CopyMemory(tBuf, sBuf+index, i);
+				index += (i+pLen);
+				tBuf[i] = 0;
+				return TRUE;
+			}
+		}
+		INT len = maxsBuf-index;
+		if(maxtBuf <= len)
+			len = maxtBuf-index;
+
+		CopyMemory(tBuf, sBuf+index, len);
+		tBuf[len] = 0;
+		index += len;
+		return FALSE;
+	}
+
+	VOID GetString( const CHAR* sBuf, CHAR* tBuf, INT len, LONG& index )
+	{
+		CopyMemory(tBuf, sBuf+index, len);
+		tBuf[len] = 0;
+		index += len;
+	}
+
+	BYTE GetByte( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(BYTE);
+		return *(BYTE*)(sBuf+t_index);
+	}
+
+	SHORT GetShort( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(SHORT);
+		return *(SHORT*)(sBuf+t_index);
+	}
+
+	INT GetInt( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(INT);
+		return *(INT*)(sBuf+t_index);
+	}
+
+	DWORD GetDWORD( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(DWORD);
+		return *(DWORD*)(sBuf+t_index);
+	}
+
+	FLOAT GetFloat( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(FLOAT);
+		return *(FLOAT*)(sBuf+t_index);
+	}
+
+	DOUBLE GetDouble( const CHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(DOUBLE);
+		return *(DOUBLE*)(sBuf+t_index);
+	}
+
+	VOID SetString( CHAR* tBuf, const CHAR* sBuf, INT len, LONG& index )
+	{
+		CopyMemory(tBuf+index, sBuf, len);
+		index += len;
+	}
+
+	VOID SetByte( CHAR* tBuf, BYTE sByte, LONG& index )
+	{
+		*(tBuf+index) = (BYTE)sByte;
+		index++;
+	}
+
+	VOID SetShort( CHAR* tBuf, SHORT sShort, LONG& index )
+	{
+		SHORT temp = (SHORT)sShort;
+
+		CopyMemory( tBuf+index, &temp, sizeof(SHORT));
+		index += sizeof(SHORT);
+	}
+
+	VOID SetInt( CHAR* tBuf, INT sInt, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sInt, sizeof(INT));
+		index += sizeof(INT);
+	}
+
+	VOID SetDWORD( CHAR* tBuf, DWORD sDword, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sDword, sizeof(DWORD));
+		index += sizeof(DWORD);
+	}
+
+	VOID SetFloat( CHAR* tBuf, FLOAT sFloat, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sFloat, sizeof(FLOAT));
+		index += sizeof(FLOAT);
+	}
+
+	VOID SetDouble( CHAR* tBuf, DOUBLE sDouble, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sDouble, sizeof(DOUBLE));
+		index += sizeof(DOUBLE);
+	}
+
+	BOOL GetLine( const WCHAR* sBuf, INT maxsBuf, WCHAR* tBuf, INT maxtBuf, LONG& index )
+	{
+		ZeroMemory(tBuf, sizeof(tBuf));
+		INT DestIndex = index;
+
+		WCHAR* pLine = L"\n";
+		INT pLen = wcslen(pLine);
+
+		for(INT i = 0; i < maxsBuf; i++)
+		{
+			if(index+i >= maxtBuf)
+				break;
+
+			if(wcsncmp(&sBuf[index+i], pLine, pLen) == 0)
+			{
+				CopyMemory(tBuf, sBuf+index, sizeof(WCHAR)*i);
+				index += (i+pLen);
+				tBuf[index-1] = 0;
+				return TRUE;
+			}
+		}
+		INT len = maxsBuf-index;
+		CopyMemory(tBuf, sBuf+index, sizeof(WCHAR)*len);
+		tBuf[len] = 0;
+		index += len;
+		return FALSE;
+	}
+
+	VOID GetString( const WCHAR* sBuf, WCHAR* tBuf, INT len, LONG& index )
+	{
+		CopyMemory(tBuf, sBuf+index, sizeof(WCHAR)*len);
+		tBuf[len] = 0;
+		index += len;
+	}
+
+	BYTE GetByte( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(BYTE);
+		return *(BYTE*)(sBuf+t_index);
+	}
+
+	SHORT GetShort( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(SHORT);
+		return *(SHORT*)(sBuf+t_index);
+	}
+
+	INT GetInt( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(INT);
+		return *(INT*)(sBuf+t_index);
+	}
+
+	DWORD GetDWORD( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(DWORD);
+		return *(DWORD*)(sBuf+t_index);
+	}
+
+	FLOAT GetFloat( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(FLOAT);
+		return *(FLOAT*)(sBuf+t_index);
+	}
+
+	DOUBLE GetDouble( const WCHAR* sBuf, LONG& index )
+	{
+		INT t_index = index;
+		index += sizeof(DOUBLE);
+		return *(DOUBLE*)(sBuf+t_index);
+	}
+
+	VOID SetString( WCHAR* tBuf, const WCHAR* sBuf, INT len, LONG& index )
+	{
+		CopyMemory(tBuf+index, sBuf, sizeof(WCHAR)*len);
+		index += len;
+	}
+
+	VOID SetByte( WCHAR* tBuf, BYTE sByte, LONG& index )
+	{
+		*(tBuf+index) = (BYTE)sByte;
+		index++;
+	}
+
+	VOID SetShort( WCHAR* tBuf, SHORT sShort, LONG& index )
+	{
+		SHORT temp = (SHORT)sShort;
+
+		CopyMemory( tBuf+index, &temp, sizeof(SHORT));
+		index += sizeof(SHORT);
+	}
+
+	VOID SetInt( WCHAR* tBuf, INT sInt, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sInt, sizeof(INT));
+		index += sizeof(INT);
+	}
+
+	VOID SetDWORD( WCHAR* tBuf, DWORD sDword, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sDword, sizeof(DWORD));
+		index += sizeof(DWORD);
+	}
+
+	VOID SetFloat( WCHAR* tBuf, FLOAT sFloat, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sFloat, sizeof(FLOAT));
+		index += sizeof(FLOAT);
+	}
+
+	VOID SetDouble( WCHAR* tBuf, DOUBLE sDouble, LONG& index )
+	{
+		CopyMemory( tBuf+index, &sDouble, sizeof(DOUBLE));
+		index += sizeof(DOUBLE);
+	}
+
+	VOID Read( const char* sBuf, void* tBuf, INT len, LONG& seek )
+	{
+		CopyMemory(tBuf, &sBuf[seek], len);
+		seek += len;
+	}
+
+	VOID Write( const void* sBuf, char* tBuf, INT len, LONG& seek )
+	{
+		CopyMemory(&tBuf[seek], sBuf, len);
+		seek += len;
+	}
+
+
+}

CryptoSource/SQLExecute/Nave/Nave.h

@@ -0,0 +1,436 @@
+/** 
+ *  @file		Nave.h
+ *  @brief		Nave Library Core Header
+ *  @remarks	NaveGDK 라이브러리의 선언부 Header
+ *  @author		강동명(edith2580@gmail.com)
+ *  @date		2009-04-02
+ */
+
+#pragma once
+
+/// 거의 사용되지 않는 내용은 Windows 헤더에서 제외합니다.
+#define WIN32_LEAN_AND_MEAN		
+
+#pragma comment(lib,"winmm.lib")
+#pragma comment(lib,"imm32.lib")
+
+#include <windows.h>
+#include <mmsystem.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <WCHAR.h>
+#include <stddef.h>	
+#include <conio.h>
+
+#include "NFTypes.h"
+#include "NFSingleton.h"
+
+/// 문자열 앞에 L을 연결하여 WCHAR 타입으로 변환함
+#define WIDEN2(x) L ## x
+/// CHAR의 값을 WCHAR로 변환하기 위한 정의
+#define WIDEN(x) WIDEN2(x)
+/// __FILE__ 의 WCHAR형 정의
+#define __WFILE__ WIDEN(__FILE__)
+/// __FUNCSIG__ 의 WCHAR형 정의
+#define __WFUNCSIG__ WIDEN(__FUNCSIG__)
+
+/// 단일 객체 DELETE 디파인
+#ifndef _DELETE
+#define _DELETE(p)       { if(p) { delete (p);     (p)=NULL; } }
+#endif
+/// 배열형 객체 DELETE 디파인
+#ifndef _DELETE_ARRAY
+#define _DELETE_ARRAY(p) { if(p) { delete[] (p);   (p)=NULL; } }
+#endif
+/// RELEASE 디파인
+#ifndef _RELEASE
+#define _RELEASE(p)      { if(p) { (p)->Release(); (p)=NULL; } }
+#endif
+
+/// MAKEINTRESOURCE 재정의
+#define MIS(a)					MAKEINTRESOURCEW(a)
+/// InvalidateRect 재정의
+#define Redraw(hWnd, bErase)	InvalidateRect(hWnd, NULL, bErase)
+
+/// DWORD 에서 Alpha 구하기
+#define GetAColor(Color)      ((BYTE)((Color)>>24)&0xff)
+/// DWORD 에서 Red 구하기
+#define GetRColor(Color)      ((BYTE)((Color)>>16)&0xff)
+/// DWORD 에서 Green 구하기
+#define GetGColor(Color)      ((BYTE)(((WORD)(Color)) >> 8)&0xff)
+/// DWORD 에서 Blue 구하기
+#define GetBColor(Color)      ((BYTE)(Color)&0xff)
+
+namespace Nave {
+
+	/// 메인 윈도우 핸들
+	extern HWND				hMainWnd;
+
+	/// 윈도으의 인스턴스
+	extern HINSTANCE		hInstance;
+
+	/**
+	 * @brief	LFH 메모리풀을 사용한다
+	 * @remarks	
+	 *		Low-Fragmentation Heap의 사용											\r\n
+	 *		프로그램이 시작할때 한번호출해준다.										\r\n
+	 *		디버거가 연결되면(F5) 디버그 힙을 사용하므로 CTRL+F5를 눌러야			\r\n
+	 *		Low-Fragmentation Heap이 사용되고, TRUE가 리턴되는것을 알수있다.		\r\n
+	 *																				\r\n
+	 *		Low-Fragmentation Heap의 장점											\r\n
+	 *		특별히 프로그래머는 신경쓰지 않아도, 메모리풀을 사용,					\r\n	
+	 *		프로그램의 질을 높일수있다.												\r\n
+	 *		메모리 단편화를 예방할수있고, 힙메모리생성, 삭제시 효율이 높아진다.		\r\n
+	 *		특히, 멀티코어 시스템에서 높은 성능향상이 있다.							\r\n
+	 *																				\r\n
+	 *		Low-Fragmentation Heap사용시 참고										\r\n
+	 *		이 함수가 호출되지 않아도, 이코드가 있으면 Win2000Pro Sp4이상의			\r\n
+	 *		OS에서만 동작하므로, Win98을 지원하려고 한다면, 주석화시켜야 한다.		\r\n
+	 *																				\r\n
+	 *		비스타는 이함수를 호출하지 않아도 기본동작한다.							\r\n
+	 *		16K보다 작은 메모리를 할당하면, LFH에 메모리가 할당,					\r\n
+	 *		그이상은 기존힙에서 할당된다.											\r\n
+	 */
+	void EnableLFH();
+
+	/**
+	 * @brief	프로그램의 국가언어 정보를 설정합니다.
+	 * @param pLocale 언어명 
+	 * @remarks	wprintf 등 유니코드 문자열을 콘솔에 출력하기 위해서는 로케일 설정을 해야함.	\r\n
+	 *			한국어 : Korean																\r\n
+	 *			영어 : English																\r\n
+	 */
+	void SetLocale(CHAR* pLocale);
+
+	/**
+	 * @brief	게임에서 사용할 Object의 GUID를 얻어온다	
+	 * @return	생성된 GUID값 0x00000001 ~ 0xFFFFFFFF 까지
+	 */
+	DWORD	GetGUID();
+
+	/**
+	 * @brief	String의 크기Pixel을 구한다.
+	 * @param string	사이즈를 구할 스트링
+	 * @param font		사용할 폰트
+	 * @return			얻어진 String의 크기
+	 */
+	SIZE	GetStringSize( const WCHAR* string, HFONT font );
+
+	/**
+	 * @brief	윈도우 커서를 가져온다.
+	 * @return	Main윈도우에서의 마우스 포지션
+	 * @warning	Nave::hMainWnd 가 설정되어있어야한다.
+	 */
+	POINT	GetMousePos();
+
+	/**
+	 * @brief	윈도우 커서를 가져온다.
+	 * @param wnd	윈도우 핸들
+	 * @return	윈도우에서의 마우스 포지션
+	 */
+	POINT	GetMousePos( HWND wnd );
+
+	/**
+	 * @brief	현재 마우스가 어느 윈도우에 올라가 있는지 
+	 * @return	마우스가 존재하는 윈도우의 핸들
+	 */
+	HWND	IsWindowFromPoint();
+
+	/**
+	 * @brief	현재 프로그램의 이름을 구한다
+	 * @param buf	어플리케이션의 이름을 저장할 버퍼
+	 * @param len	버퍼의 크기
+	 * @return	어플리케이션 이름의 길이
+	 */
+	INT		GetProgramName( LPWSTR buf, INT len );	
+
+	/**
+	 * @brief	현재 프로그램의 경로를 구한다.
+	 * @param buf	어플리케이션의 디렉토리를 저장할 버퍼
+	 * @param len	버퍼의 크기
+	 * @return	어플리케이션 디렉토리의 길이
+	 */
+	INT		GetProgramDir( LPWSTR buf, INT len );	
+
+	/**
+	 * @brief	Path에서 경로를 구한다
+	 * @param path	경로 정보
+	 * @param buf	경로에서 구한 디렉토리
+	 * @return	디렉토리의 길이
+	 */
+	INT		GetDir( LPCWSTR path, LPWSTR buf );		
+
+
+	/**
+	 * @brief	문자열에서 1Line을 읽어들인다 한라인은 \n으로 구분된다.
+	 * @param sBuf		소스 버퍼
+	 * @param maxsBuf	소스 버퍼 크기
+	 * @param tBuf		저장 버퍼
+	 * @param maxtBuf	저장 버퍼 크기
+	 * @param index		소스 버퍼에서 읽어들일 시작위치
+	 * @return	성공여부
+	 */
+	BOOL	GetLine( const CHAR* sBuf, INT maxsBuf, CHAR* tBuf, INT maxtBuf, LONG& index );
+
+	/**
+	 * @brief	문자열을 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param tBuf	저장 버퍼
+	 * @param len	저장 버퍼 크기
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 */
+	VOID	GetString( const CHAR* sBuf, CHAR* tBuf, INT len, LONG& index );
+
+	/**
+	 * @brief	1바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	BYTE 결과값
+	 */
+	BYTE	GetByte( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	2바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	SHORT 결과값
+	 */
+	SHORT 	GetShort( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	INT 결과값
+	 */
+	INT		GetInt( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	DWORD 결과값
+	 */
+	DWORD   GetDWORD( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	FLOAT 결과값
+	 */
+	FLOAT	GetFloat( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	8바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	DOUBLE 결과값
+	 */
+	DOUBLE	GetDouble( const CHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	문자열을 셋팅한다
+	 * @param tBuf	저장 버퍼
+	 * @param sBuf	저장할 값
+	 * @param len	저장할 길이
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetString( CHAR* tBuf, const CHAR* sBuf, INT len, LONG& index );
+
+	/**
+	 * @brief	1바이트 BYTE를 셋팅한다.
+	 * @param tBuf	저장 버퍼
+	 * @param sByte 저장할 값
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetByte( CHAR* tBuf, BYTE sByte, LONG& index );
+
+	/**
+	 * @brief	2바이트 SHORT를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sShort	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetShort( CHAR* tBuf, SHORT sShort, LONG& index );
+
+	/**
+	 * @brief	4바이트 INT를 셋팅한다.
+	 * @param tBuf	저장 버퍼
+	 * @param sInt	저장할 값
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetInt( CHAR* tBuf, INT sInt, LONG& index);
+
+	/**
+	 * @brief	4바이트 DWORD를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sDword	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetDWORD( CHAR* tBuf, DWORD sDword, LONG& index );
+
+	/**
+	 * @brief	4바이트 FLOAT를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sFloat	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetFloat( CHAR* tBuf, FLOAT sFloat, LONG& index );
+
+	/**
+	 * @brief	8바이트 double를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sDouble	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetDouble( CHAR* tBuf, DOUBLE sDouble, LONG& index );
+
+
+	/**
+	 * @brief	문자열에서 1Line을 읽어들인다 한라인은 \n으로 구분된다.
+	 * @param sBuf		소스 버퍼
+	 * @param maxsBuf	소스 버퍼 크기
+	 * @param tBuf		저장 버퍼
+	 * @param maxtBuf	저장 버퍼 크기
+	 * @param index		소스 버퍼에서 읽어들일 시작위치
+	 * @return	성공여부
+	 */
+	BOOL	GetLine( const WCHAR* sBuf, INT maxsBuf, WCHAR* tBuf, INT maxtBuf, LONG& index );
+
+	/**
+	 * @brief	문자열을 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param tBuf	저장 버퍼
+	 * @param len	저장 버퍼 크기
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 */
+	VOID	GetString( const WCHAR* sBuf, WCHAR* tBuf, INT len, LONG& index );
+
+	/**
+	 * @brief	1바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	BYTE 결과값
+	 */
+	BYTE	GetByte( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	2바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	SHORT 결과값
+	 */
+	SHORT 	GetShort( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	INT 결과값
+	 */
+	INT		GetInt( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	DWORD 결과값
+	 */
+	DWORD   GetDWORD( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	4바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	FLOAT 결과값
+	 */
+	FLOAT	GetFloat( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	8바이트를 읽어들인다.
+	 * @param sBuf	소스 버퍼
+	 * @param index 소스 버퍼에서 읽어들일 시작위치
+	 * @return	DOUBLE 결과값
+	 */
+	DOUBLE	GetDouble( const WCHAR* sBuf, LONG& index );
+
+	/**
+	 * @brief	문자열을 셋팅한다
+	 * @param tBuf	저장 버퍼
+	 * @param sBuf	저장할 값
+	 * @param len	저장할 길이
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetString( WCHAR* tBuf, const WCHAR* sBuf, INT len, LONG& index );
+
+	/**
+	 * @brief	1바이트 BYTE를 셋팅한다.
+	 * @param tBuf	저장 버퍼
+	 * @param sByte 저장할 값
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetByte( WCHAR* tBuf, BYTE sByte, LONG& index );
+
+	/**
+	 * @brief	2바이트 SHORT를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sShort	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetShort( WCHAR* tBuf, SHORT sShort, LONG& index );
+
+	/**
+	 * @brief	4바이트 INT를 셋팅한다.
+	 * @param tBuf	저장 버퍼
+	 * @param sInt	저장할 값
+	 * @param index 저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetInt( WCHAR* tBuf, INT sInt, LONG& index);
+
+	/**
+	 * @brief	4바이트 DWORD를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sDword	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetDWORD( WCHAR* tBuf, DWORD sDword, LONG& index );
+
+	/**
+	 * @brief	4바이트 FLOAT를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sFloat	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetFloat( WCHAR* tBuf, FLOAT sFloat, LONG& index );
+
+	/**
+	 * @brief	8바이트 double를 셋팅한다.
+	 * @param tBuf		저장 버퍼
+	 * @param sDouble	저장할 값
+	 * @param index		저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	SetDouble( WCHAR* tBuf, DOUBLE sDouble, LONG& index );
+
+
+	/**
+	 * @brief	바이너리 정보를 Read 들입니다.
+	 * @param sBuf	소스 버퍼
+	 * @param tBuf	저장 버퍼
+	 * @param len	읽을 길이
+	 * @param seek	소스 버퍼에서 읽을 시작위치
+	 */
+	VOID	Read( const char* sBuf, void* tBuf, INT len, LONG& seek );
+
+	/**
+	 * @brief	바이너리 정보를 Write 합니다.
+	 * @param sBuf	저장 버퍼
+	 * @param tBuf	저장할 값
+	 * @param len	저장할 길이
+	 * @param seek	저장 버퍼에서 저장될 시작위치
+	 */
+	VOID	Write( const void* sBuf, char* tBuf, INT len, LONG& seek );
+
+}