- microkernel addded;

- version bumped to 0.92.2

git-svn-id: http://svn.miranda-ng.org/main/trunk@641 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 396 insertions, 0 deletions

diff --git a/include/m_core.h b/include/m_core.h
new file mode 100644
index 0000000000..0aeff8ae2f
--- /dev/null
+++ b/include/m_core.h
@@ -0,0 +1,396 @@
+/*

+

+Miranda IM: the free IM client for Microsoft* Windows*

+

+Copyright 2000-2008 Miranda ICQ/IM project,

+all portions of this codebase are copyrighted to the people

+listed in contributors.txt.

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public License

+as published by the Free Software Foundation; either version 2

+of the License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program; if not, write to the Free Software

+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

+*/

+

+#ifndef M_CORE_H__

+#define M_CORE_H__ 1

+

+#ifdef MIR_CORE_EXPORTS

+	#define MIR_CORE_DLL(T) __declspec(dllexport) T __cdecl

+#else

+	#define MIR_CORE_DLL(T) __declspec(dllimport) T __cdecl

+#endif

+

+#if defined(__cplusplus)

+extern "C"

+{

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+// events, hooks & services

+

+#define MAXMODULELABELLENGTH 64

+

+typedef int (*MIRANDAHOOK)(WPARAM, LPARAM);

+typedef int (*MIRANDAHOOKPARAM)(WPARAM, LPARAM, LPARAM);

+typedef int (*MIRANDAHOOKOBJ)(void*, WPARAM, LPARAM);

+typedef int (*MIRANDAHOOKOBJPARAM)(void*, WPARAM, LPARAM, LPARAM);

+

+typedef INT_PTR (*MIRANDASERVICE)(WPARAM, LPARAM);

+typedef INT_PTR (*MIRANDASERVICEPARAM)(WPARAM, LPARAM, LPARAM);

+typedef INT_PTR (*MIRANDASERVICEOBJ)(void*, LPARAM, LPARAM);

+typedef INT_PTR (*MIRANDASERVICEOBJPARAM)(void*, WPARAM, LPARAM, LPARAM);

+

+#ifdef _WIN64

+	#define CALLSERVICE_NOTFOUND      ((INT_PTR)0x8000000000000000)

+#else

+	#define CALLSERVICE_NOTFOUND      ((int)0x80000000)

+#endif

+

+MIR_CORE_DLL(HANDLE) CreateHookableEvent(const char *name);

+MIR_CORE_DLL(int)    DestroyHookableEvent(HANDLE hEvent);

+MIR_CORE_DLL(int)    SetHookDefaultForHookableEvent(HANDLE hEvent, MIRANDAHOOK pfnHook);

+MIR_CORE_DLL(int)    CallPluginEventHook(HINSTANCE hInst, HANDLE hEvent, WPARAM wParam, LPARAM lParam);

+MIR_CORE_DLL(int)    CallHookSubscribers(HANDLE hEvent, WPARAM wParam, LPARAM lParam);

+MIR_CORE_DLL(int)    NotifyEventHooks(HANDLE hEvent, WPARAM wParam, LPARAM lParam);

+

+MIR_CORE_DLL(HANDLE) HookEvent(const char* name, MIRANDAHOOK hookProc);

+MIR_CORE_DLL(HANDLE) HookEventParam(const char* name, MIRANDAHOOKPARAM hookProc, LPARAM lParam);

+MIR_CORE_DLL(HANDLE) HookEventObj(const char* name, MIRANDAHOOKOBJ hookProc, void* object);

+MIR_CORE_DLL(HANDLE) HookEventObjParam(const char* name, MIRANDAHOOKOBJPARAM hookProc, void* object, LPARAM lParam);

+MIR_CORE_DLL(HANDLE) HookEventMessage(const char* name, HWND hwnd, UINT message);

+MIR_CORE_DLL(int)    UnhookEvent(HANDLE hHook);

+MIR_CORE_DLL(void)   KillObjectEventHooks(void* pObject);

+MIR_CORE_DLL(void)   KillModuleEventHooks(HINSTANCE pModule);

+

+MIR_CORE_DLL(HANDLE) CreateServiceFunction(const char *name, MIRANDASERVICE serviceProc);

+MIR_CORE_DLL(HANDLE) CreateServiceFunctionParam(const char *name, MIRANDASERVICEPARAM serviceProc, LPARAM lParam);

+MIR_CORE_DLL(HANDLE) CreateServiceFunctionObj(const char *name, MIRANDASERVICEOBJ serviceProc, void* object);

+MIR_CORE_DLL(HANDLE) CreateServiceFunctionObjParam(const char *name, MIRANDASERVICEOBJPARAM serviceProc, void* object, LPARAM lParam);

+MIR_CORE_DLL(int)    DestroyServiceFunction(HANDLE hService);

+MIR_CORE_DLL(int)    ServiceExists(const char *name);

+

+MIR_CORE_DLL(INT_PTR) CallService(const char *name, WPARAM wParam, LPARAM lParam);

+MIR_CORE_DLL(INT_PTR) CallServiceSync(const char *name, WPARAM wParam, LPARAM lParam);

+

+MIR_CORE_DLL(int)     CallFunctionAsync(void (__stdcall *func)(void *), void *arg);

+MIR_CORE_DLL(void)    KillModuleServices(HINSTANCE hInst);

+MIR_CORE_DLL(void)    KillObjectServices(void* pObject);

+

+#if defined(_STATIC)

+__declspec(dllexport) INT_PTR CallContactService(HANDLE, const char *, WPARAM, LPARAM);

+__declspec(dllexport) INT_PTR CallProtoService(const char *szModule, const char *szService, WPARAM wParam, LPARAM lParam);

+#else

+MIR_CORE_DLL(INT_PTR) CallContactService(HANDLE, const char *, WPARAM, LPARAM);

+MIR_CORE_DLL(INT_PTR) CallProtoService(const char *szModule, const char *szService, WPARAM wParam, LPARAM lParam);

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+// exceptions

+

+typedef DWORD (__cdecl *pfnExceptionFilter)(DWORD code, EXCEPTION_POINTERS* info);

+

+MIR_CORE_DLL(pfnExceptionFilter) GetExceptionFilter(void);

+MIR_CORE_DLL(pfnExceptionFilter) SetExceptionFilter(pfnExceptionFilter pMirandaExceptFilter);

+

+///////////////////////////////////////////////////////////////////////////////

+// language packs support

+

+#define LANG_UNICODE 0x1000

+

+extern int hLangpack;

+

+MIR_CORE_DLL(void)   LangPackDropUnusedItems(void);

+MIR_CORE_DLL(int)    LangPackGetDefaultCodePage( void );

+MIR_CORE_DLL(int)    LangPackGetDefaultLocale(void);

+MIR_CORE_DLL(TCHAR*) LangPackPcharToTchar(const char* pszStr);

+

+MIR_CORE_DLL(int)    LoadLangPack(const TCHAR *szLangPack);

+MIR_CORE_DLL(void)   ReloadLangpack(TCHAR *pszStr);

+

+MIR_CORE_DLL(char*)  TranslateA_LP(const char* str, int hLang);

+MIR_CORE_DLL(WCHAR*) TranslateW_LP(const WCHAR* str, int hLang);

+MIR_CORE_DLL(void)   TranslateMenu_LP(HMENU, int hLang);

+MIR_CORE_DLL(void)   TranslateDialog_LP(HWND hDlg, int hLang);

+

+#define Translate(s) TranslateA_LP(s, hLangpack)

+#define TranslateW(s) TranslateW_LP(s, hLangpack)

+#define TranslateMenu(h) TranslateMenu_LP(h,hLangpack)

+#define TranslateDialogDefault(h) TranslateDialog_LP(h,hLangpack)

+

+#ifdef _UNICODE

+	#define TranslateT(s)	 TranslateW_LP(_T(s),hLangpack)

+	#define TranslateTS(s)	 TranslateW_LP(s,hLangpack)

+	#define TranslateTH(l,s) TranslateW_LP(s,l)

+#else

+	#define TranslateT(s)	 TranslateA_LP(s,hLangpack)

+	#define TranslateTS(s)	 TranslateA_LP(s,hLangpack)

+	#define TranslateTH(l,s) TranslateA_LP(s,l)

+#endif

+

+MIR_CORE_DLL(unsigned int) mir_hash(const void * key, unsigned int len);

+

+#pragma optimize("gt", on)

+__inline unsigned int mir_hashstr(const char * key)

+{

+	if (key == NULL) return 0;

+	else {

+		unsigned int len = (unsigned int)strlen((const char*)key);

+		return mir_hash(key, len);

+}	}

+

+__inline unsigned int mir_hashstrW(const wchar_t * key)

+{

+	if (key == NULL) return 0;

+	else {

+		unsigned int len = (unsigned int)wcslen((const wchar_t*)key);

+		return mir_hash(key, len * sizeof(wchar_t));

+}	}

+#pragma optimize("", on)

+

+#define mir_hashstrT mir_hashstrW

+

+///////////////////////////////////////////////////////////////////////////////

+// lists

+

+typedef int (*FSortFunc)(void*, void*);  // sort function prototype

+

+// Assumes first 32 bit value of the data is the numeric key

+// and uses it to perform sort/search operations, this results

+// in much better performance as no compare function calls needed

+// Incredibly useful for Hash Tables

+#define NumericKeySort (FSortFunc)(void*) -1

+#define HandleKeySort  (FSortFunc)(void*) -2

+#define PtrKeySort     (FSortFunc)(void*) -3

+

+typedef struct

+{

+	void**		items;

+	int			realCount;

+	int			limit;

+	int			increment;

+

+	FSortFunc	sortFunc;

+}

+	SortedList;

+

+MIR_CORE_DLL(SortedList*) List_Create(int p_limit, int p_increment);

+MIR_CORE_DLL(void)        List_Destroy(SortedList* p_list);

+MIR_CORE_DLL(void*)       List_Find(SortedList* p_list, void* p_value);

+MIR_CORE_DLL(int)         List_GetIndex(SortedList* p_list, void* p_value, int* p_index);

+MIR_CORE_DLL(int)         List_IndexOf(SortedList* p_list, void* p_value);

+MIR_CORE_DLL(int)         List_Insert(SortedList* p_list, void* p_value, int p_index);

+MIR_CORE_DLL(int)         List_InsertPtr(SortedList* list, void* p);

+MIR_CORE_DLL(int)         List_Remove(SortedList* p_list, int index);

+MIR_CORE_DLL(int)         List_RemovePtr(SortedList* list, void* p);

+MIR_CORE_DLL(void)        List_Copy(SortedList* s, SortedList* d, size_t itemSize);

+MIR_CORE_DLL(void)        List_ObjCopy(SortedList* s, SortedList* d, size_t itemSize);

+

+///////////////////////////////////////////////////////////////////////////////

+// memory functions

+

+MIR_CORE_DLL(void*)  mir_alloc(size_t);

+MIR_CORE_DLL(void*)  mir_calloc(size_t);

+MIR_CORE_DLL(void*)  mir_realloc(void* ptr, size_t);

+MIR_CORE_DLL(void)   mir_free(void* ptr);

+MIR_CORE_DLL(char*)  mir_strdup(const char* str);

+MIR_CORE_DLL(WCHAR*) mir_wstrdup(const WCHAR* str);

+MIR_CORE_DLL(char*)  mir_strndup(const char* str, size_t len);

+

+///////////////////////////////////////////////////////////////////////////////

+// modules

+

+MIR_CORE_DLL(void) RegisterModule(HINSTANCE hInst);

+MIR_CORE_DLL(void) UnregisterModule(HINSTANCE hInst);

+

+MIR_CORE_DLL(HINSTANCE) GetInstByAddress(void* codePtr);

+

+///////////////////////////////////////////////////////////////////////////////

+// path utils

+

+MIR_CORE_DLL(void)   CreatePathToFile(char* wszFilePath);

+MIR_CORE_DLL(int)    CreateDirectoryTree(const char* szDir);

+MIR_CORE_DLL(int)    PathToAbsolute(const char *pSrc, char *pOut, char* base);

+MIR_CORE_DLL(int)    PathToRelative(const char *pSrc, char *pOut);

+

+MIR_CORE_DLL(void)   CreatePathToFileW(WCHAR* wszFilePath);

+MIR_CORE_DLL(int)    CreateDirectoryTreeW(const WCHAR* szDir);

+MIR_CORE_DLL(int)    PathToAbsoluteW(const WCHAR *pSrc, WCHAR *pOut, WCHAR* base);

+MIR_CORE_DLL(int)    PathToRelativeW(const WCHAR *pSrc, WCHAR *pOut);

+

+#define CreatePathToFileT CreatePathToFileW

+#define CreateDirectoryTreeT CreateDirectoryTreeW

+#define PathToAbsoluteT PathToAbsoluteW

+#define PathToRelativeT PathToRelativeW

+

+///////////////////////////////////////////////////////////////////////////////

+// print functions

+

+MIR_CORE_DLL(int)    mir_snprintf(char *buffer, size_t count, const char* fmt, ...);

+MIR_CORE_DLL(int)    mir_sntprintf(TCHAR *buffer, size_t count, const TCHAR* fmt, ...);

+MIR_CORE_DLL(int)    mir_vsnprintf(char *buffer, size_t count, const char* fmt, va_list va);

+MIR_CORE_DLL(int)    mir_vsntprintf(TCHAR *buffer, size_t count, const TCHAR* fmt, va_list va);

+

+///////////////////////////////////////////////////////////////////////////////

+// strings

+

+MIR_CORE_DLL(char*)  rtrim(char *str);

+MIR_CORE_DLL(WCHAR*) wrtrim(WCHAR *str);

+

+#ifdef _UNICODE

+	#define trtrim wrtrim

+#else

+	#define trtrim rtrim

+#endif

+

+MIR_CORE_DLL(char*) ltrim(char *str);   // returns pointer to the beginning of string

+MIR_CORE_DLL(char*) ltrimp(char *str);  // returns pointer to the trimmed portion of string

+

+MIR_CORE_DLL(int)   wildcmp(char *name, char *mask);

+

+__inline char* lrtrim(char* str) { return ltrim(rtrim(str)); };

+__inline char* lrtrimp(char* str) { return ltrimp(rtrim(str)); };

+

+///////////////////////////////////////////////////////////////////////////////

+// text conversion functions

+

+#ifdef _UNICODE

+	#define mir_t2a(s) mir_u2a(s)

+	#define mir_a2t(s) mir_a2u(s)

+	#define mir_t2u(s) mir_wstrdup(s)

+	#define mir_u2t(s) mir_wstrdup(s)

+

+	#define mir_t2a_cp(s,c) mir_u2a_cp(s,c)

+	#define mir_a2t_cp(s,c) mir_a2u_cp(s,c)

+	#define mir_t2u_cp(s,c) mir_wstrdup(s)

+	#define mir_u2t_cp(s,c) mir_wstrdup(s)

+

+	#define mir_tstrdup mir_wstrdup

+#else

+	#define mir_t2a(s) mir_strdup(s)

+	#define mir_a2t(s) mir_strdup(s)

+	#define mir_t2u(s) mir_a2u(s)

+	#define mir_u2t(s) mir_u2a(s)

+

+	#define mir_t2a_cp(s,c) mir_strdup(s)

+	#define mir_a2t_cp(s,c) mir_strdup(s)

+	#define mir_t2u_cp(s,c) mir_a2u_cp(s,c)

+	#define mir_u2t_cp(s,c) mir_u2a_cp(s,c)

+

+	#define mir_tstrdup mir_strdup

+#endif

+

+MIR_CORE_DLL(WCHAR*) mir_a2u_cp(const char* src, int codepage);

+MIR_CORE_DLL(WCHAR*) mir_a2u(const char* src);

+MIR_CORE_DLL(char*)  mir_u2a_cp(const wchar_t* src, int codepage);

+MIR_CORE_DLL(char*)  mir_u2a(const wchar_t* src);

+

+#if defined(__cplusplus)

+

+class _A2T

+{

+	TCHAR* buf;

+

+public:

+	__forceinline _A2T(const char* s) : buf(mir_a2t(s)) {}

+	__forceinline _A2T(const char* s, int cp) : buf(mir_a2t_cp(s, cp)) {}

+	~_A2T() { mir_free(buf); }

+

+	__forceinline operator TCHAR*() const

+	{	return buf;

+	}

+};

+

+class _T2A

+{

+	char* buf;

+

+public:

+	__forceinline _T2A(const TCHAR* s) : buf(mir_t2a(s)) {}

+	__forceinline _T2A(const TCHAR* s, int cp) : buf(mir_t2a_cp(s, cp)) {}

+	__forceinline ~_T2A() { mir_free(buf); }

+

+	__forceinline operator char*() const

+	{	return buf;

+	}

+};

+

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+// threads

+

+MIR_CORE_DLL(INT_PTR) UnwindThreadPush(WPARAM wParam, LPARAM lParam);

+MIR_CORE_DLL(INT_PTR) UnwindThreadPop(WPARAM, LPARAM);

+MIR_CORE_DLL(void)    UnwindThreadWait(void);

+

+MIR_CORE_DLL(UINT_PTR) forkthread( void (__cdecl *threadcode)(void*), unsigned long stacksize, void *arg);

+MIR_CORE_DLL(UINT_PTR) forkthreadex(void *sec, unsigned stacksize, unsigned (__stdcall *threadcode)(void*), void* owner, void *arg, unsigned *thraddr);

+

+MIR_CORE_DLL(void) KillObjectThreads(void* pObject);

+

+///////////////////////////////////////////////////////////////////////////////

+// utf8 interface

+

+MIR_CORE_DLL(char*) Utf8Decode(char* str, wchar_t** ucs2);

+MIR_CORE_DLL(char*) Utf8DecodeCP(char* str, int codepage, wchar_t** ucs2);

+

+MIR_CORE_DLL(wchar_t*) Utf8DecodeW(const char* str);

+

+MIR_CORE_DLL(char*) Utf8Encode(const char* str);

+MIR_CORE_DLL(char*) Utf8EncodeCP(const char* src, int codepage);

+

+MIR_CORE_DLL(char*) Utf8EncodeW(const wchar_t* str);

+

+MIR_CORE_DLL(int)   Ucs2toUtf8Len(const wchar_t *src);

+

+#define Utf8DecodeT Utf8DecodeW

+#define Utf8EncodeT Utf8EncodeW

+

+#define mir_utf8decode(A, B)      Utf8Decode(A, B)

+#define mir_utf8decodecp(A, B, C) Utf8DecodeCP(A, B, C)

+#define mir_utf8decodeW(A)   	    Utf8DecodeW(A)

+#define mir_utf8encode(A)         Utf8Encode(A)

+#define mir_utf8encodecp(A, B)    Utf8EncodeCP(A, B)

+#define mir_utf8encodeW(A)        Utf8EncodeW(A)

+#define mir_utf8lenW(A)           Ucs2toUtf8Len(A)

+

+__forceinline char* mir_utf8decodeA(const char* src)

+{

+    char* tmp = mir_strdup(src);

+    mir_utf8decode(tmp, NULL);

+    return tmp;

+}

+

+#if defined(_UNICODE)

+	#define mir_utf8decodeT mir_utf8decodeW

+	#define mir_utf8encodeT mir_utf8encodeW

+#else

+	#define mir_utf8decodeT mir_utf8decodeA

+	#define mir_utf8encodeT mir_utf8encode

+#endif

+

+///////////////////////////////////////////////////////////////////////////////

+

+#if defined(__cplusplus)

+}

+#endif

+

+#ifndef MIR_CORE_EXPORTS

+	#if !defined( _WIN64 )

+		#pragma comment(lib, "mir_core.lib")

+	#else

+		#pragma comment(lib, "mir_core64.lib")

+	#endif

+#endif

+

+#endif // M_CORE_H