From cb4a46e7fbe62d788e66ed6121c717a2d22a4d7c Mon Sep 17 00:00:00 2001 From: watcherhd Date: Thu, 21 Apr 2011 14:14:52 +0000 Subject: svn.miranda.im is moving to a new home! git-svn-id: http://miranda-plugins.googlecode.com/svn/trunk@7 e753b5eb-9565-29b2-b5c5-2cc6f99dfbcb --- delphi/Awkward/include/m_system.inc | 515 ++++++++++++++++++++++++++++++++++++ 1 file changed, 515 insertions(+) create mode 100644 delphi/Awkward/include/m_system.inc (limited to 'delphi/Awkward/include/m_system.inc') diff --git a/delphi/Awkward/include/m_system.inc b/delphi/Awkward/include/m_system.inc new file mode 100644 index 0000000..6532101 --- /dev/null +++ b/delphi/Awkward/include/m_system.inc @@ -0,0 +1,515 @@ +{ + Miranda IM: the free IM client for Microsoft Windows + + Copyright 2000-2003 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_SYSTEM} +{$DEFINE M_SYSTEM} + +{$IFNDEF MIRANDANAME} +{$DEFINE MIRANDANAME} +const + MIRANDANAME = 'Miranda IM'; +{$ENDIF} +{$IFNDEF MIRANDACLASS} +{$DEFINE MIRANDACLASS} +const + MIRANDACLASS = 'Miranda'; +{$ENDIF} + +// set the default compatibility lever for Miranda 0.4.x +{$IFNDEF MIRANDA_VER} +{$DEFINE MIRANDA_VER} +const + MIRANDA_VER = $0400; +{$ENDIF} + + { miranda/system/modulesloaded + called after all modules have been successfully initialised + wParam=lParam=0 + used to resolve double-dependencies in the module load order + } +const + ME_SYSTEM_MODULESLOADED:PAnsiChar = 'Miranda/System/ModulesLoaded'; + + { miranda/system/shutdown event + called just before the application terminates + the database is still guaranteed to be running during this hook. + wParam=lParam=0 + } + ME_SYSTEM_SHUTDOWN:PAnsiChar = 'Miranda/System/Shutdown'; + + { restarts miranda ( 0.8+ ) + wParam=lParam=0 + } + MS_SYSTEM_RESTART:PAnsiChar = 'Miranda/System/Restart'; + + { miranda/system/oktoexit event + called before the app goes into shutdown routine to make sure everyone is + happy to exit + wParam=lParam=0 + return nonzero to stop the exit cycle + } + ME_SYSTEM_OKTOEXIT:PAnsiChar = 'Miranda/System/OkToExitEvent'; + + { miranda/system/oktoexit service + Check if everyone is happy to exit + wParam=lParam=0 + if everyone acknowleges OK to exit then returns true, otherwise false + } + MS_SYSTEM_OKTOEXIT:PAnsiChar = 'Miranda/System/OkToExit'; + + { gets the version number of Miranda encoded as a DWORD v0.1.0.1+ + wParam=lParam=0 + returns the version number, encoded as one version per byte, therefore + version 1.2.3.10 is 0x0102030a + } + MS_SYSTEM_GETVERSION:PAnsiChar = 'Miranda/System/GetVersion'; + + { gets the version of Miranda encoded as text v0.1.0.1+ + wParam=cch + lParam=(LPARAM)(AnsiChar*)pszVersion + cch is the size of the buffer pointed to by pszVersion, in bytes + may return a build qualifier, such as "0.1.0.1 alpha" + returns 0 on success, nonzero on failure + } + MS_SYSTEM_GETVERSIONTEXT:PAnsiChar = 'Miranda/System/GetVersionText'; + + { Adds a HANDLE to the list to be checked in the main message loop v0.1.2.0+ + wParam=(WPARAM)(HANDLE)hObject + lParam=(LPARAM)(const AnsiChar*)pszService + returns 0 on success or nonzero on failure + Causes pszService to be CallService()d (wParam=hObject,lParam=0) from the + main thread whenever hObject is signalled. + The Miranda message loop has a MsgWaitForMultipleObjects() call in it to + implement this feature. See the documentation for that function for + information on what objects are supported. + There is a limit of MAXIMUM_WAIT_OBJECTS minus one (MWO is defined in winnt.h + to be 64) on the number of handles MSFMO() can process. This service will + return nonzero if that many handles are already being waited on. + As of writing, the following parts of Miranda are thread-safe, so can be + called from any thread: + All of modules.h except NotifyEventHooks() + Read-only parts of m_database.h (since the write parts will call hooks) + All of m_langpack.h + for all other routines your mileage may vary, but I would strongly recommend + that you call them from the main thread, or ask about it on plugin-dev if you + think it really ought to work. + Update during 0.1.2.0 development, 16/10/01: + NotifyEventHooks() now translates all calls into the context of the main + thread, which means that all of m_database.h is now completely safe. + Update during 0.1.2.2 development, 17/4/02: + The main thread's message loop now also deals with asynchronous procedure + calls. Loop up QueueUserAPC() for a neater way to accomplish a lot of the + things that used to require ms_system_waitonhandle. + Miranda is compiled with the multithreaded runtime - don't forget to do the + same with your plugin. + } + MS_SYSTEM_WAITONHANDLE:PAnsiChar = 'Miranda/System/WaitOnHandle'; + + {Removes a HANDLE from the wait list v0.1.2.0+ } + {wParam=(WPARAM)(HANDLE)hObject } + {lParam=0 } + {returns 0 on success or nonzero on failure. } + MS_SYSTEM_REMOVEWAIT:PAnsiChar = 'Miranda/System/RemoveWait'; + + { Returns Miranda's RTL/CRT function poiners to malloc() free() realloc() -- 0.1.2.2+ + This is useful for preallocation of memory for use with Miranda's services + that Miranda can free -- or reallocation of a block of memory passed with a + service. Do not use with memory unless it is explicitly expected the memory + can or shall be used in this way. the passed structure is expected to have + it's .cbSize initialised + wParam=0, lParam = (LPARAM) &MM_INTERFACE + } + +type + PMM_INTERFACE = ^TMM_INTERFACE; + TMM_INTERFACE = record + cbSize :integer; + malloc :function (para1:integer):pointer;cdecl; + realloc:function (para1:pointer; para2:integer):pointer;cdecl; + free :procedure (para1:pointer);cdecl; +// if MIRANDA_VER >= 0x0600 + calloc :function (para1:integer):pointer;cdecl; + strdup :function (const src:PAnsiChar):PAnsiChar;cdecl; + wstrdup:function (const src:PWideChar):PWideChar;cdecl; +// if MIRANDA_VER >= 0x0700 + mir_snprintf :function(buffer:PAnsiChar;count:size_t;fmt:PAnsiChar{, ...}):int; cdecl; + mir_sntprintf :function(buffer:TChar;count:size_t;fmt:TChar{, ...}):int; cdecl; + mir_vsnprintf :function(buffer:PAnsiChar;count:size_t;fmt:PAnsiChar;va:va_list):int; cdecl; + mir_vsntprintf:function(buffer:TChar;count:size_t;fmt:TChar;va:va_list):int; cdecl; + + mir_a2u_cp:function(src:PAnsiChar;codepage:int):pWideChar; cdecl; + mir_a2u :function(src:PAnsiChar):pWideChar; cdecl; + mir_u2a_cp:function(src:pWideChar;codepage:int):PAnsiChar; cdecl; + mir_u2a :function(src:pWideChar):PAnsiChar; cdecl; + end; + +const + MS_SYSTEM_GET_MMI:PAnsiChar = 'Miranda/System/GetMMI'; + + { Returns the pointer to the simple lists manager. + If the sortFunc member of the list gets assigned, the list becomes sorted + wParam=0, lParam = (LPARAM)LIST_INTERFACE* + } + LIST_INTERFACE_V1_SIZE = sizeof(size_t)+ 7*sizeof(pointer); + LIST_INTERFACE_V2_SIZE = sizeof(size_t)+ 9*sizeof(pointer); + LIST_INTERFACE_V3_SIZE = sizeof(size_t)+11*sizeof(pointer); + +type + TFSortFunc = function (para1:pointer; para2:pointer):longint;cdecl; + + PSortedList = ^TSortedList; + TSortedList = record + items : ^pointer; + realCount: int; + limit : int; + increment: int; + sortFunc : TFSortFunc; + end; + PLIST_INTERFACE = ^TLIST_INTERFACE; + TLIST_INTERFACE = record + cbSize :int; + List_Create :function (para1:longint; para2:longint):PSortedList;cdecl; + List_Destroy :procedure(para1:PSortedList);cdecl; + List_Find :function (para1:PSortedList; para2:pointer):pointer;cdecl; + List_GetIndex :function (para1:PSortedList; para2:pointer; para3:Plongint):longint;cdecl; + List_Insert :function (para1:PSortedList; para2:pointer; para3:longint):longint;cdecl; + List_Remove :function (para1:PSortedList; para2:longint):longint;cdecl; + List_IndexOf :function (para1:PSortedList; para2:pointer):longint;cdecl; +// if MIRANDA_VER >= 0x0600 + List_InsertPtr:function (list:PSortedList; p:pointer):int;cdecl; + List_RemovePtr:function (list:PSortedList; p:pointer):int;cdecl; +// if MIRANDA_VER >= 0x0800 + List_Copy :procedure (src:PSortedList; dst:PSortedList; size:size_t); cdecl; + List_ObjCopy :procedure (src:PSortedList; dst:PSortedList; size:size_t); cdecl; + + end; + +const + MS_SYSTEM_GET_LI:PAnsiChar = 'Miranda/System/GetLI'; + +{ + UTF8 Manager interface. 0.5.2+ + + Contains functions for utf8-strings encoding & decoding +} + +const + UTF8_INTERFACE_SIZEOF_V1 = (sizeof(size_t)+5*sizeof(dword));// 24; + UTF8_INTERFACE_SIZEOF_V2 = (sizeof(size_t)+6*sizeof(dword)); +type + pPWideChar = ^PWideChar; + UTF8_INTERFACE = record + cbSize:int; + + // decodes utf8 and places the result back into the same buffer. + // if the second parameter is present, the additional wchar_t* string gets allocated, + // and filled with the decoded utf8 content without any information loss. + // this string should be freed using mir_free() + utf8_decode :function (str:PAnsiChar; var ucs2:pPWideChar):PAnsiChar;cdecl; + utf8_decodecp:function (str:PAnsiChar; codepage:int; var ucs2:pPWideChar):PAnsiChar;cdecl; + + // encodes an ANSI string into a utf8 format using the current langpack code page, + // or CP_ACP, if lanpack is missing + // the resulting string should be freed using mir_free + utf8_encode :function(src:PAnsiChar):PAnsiChar;cdecl; + utf8_encodecp:function(src:PAnsiChar;codepage:int):PAnsiChar;cdecl; + + // encodes an WCHAR string into a utf8 format + // the resulting string should be freed using mir_free + utf8_encodeW :function(src:PWideChar):PAnsiChar;cdecl; + + // decodes utf8 and returns the result as wchar_t* that should be freed using + // mir_free() the input buffer remains unchanged + utf8_decodeW :function(str:PAnsiChar):pWideChar;cdecl; + // returns the predicted length of the utf-8 string + +// MIRANDA_VER >= 0x0900 + utf8_lenW :function(const src:pWideChar):int; cdecl; + end; + +const + MS_SYSTEM_GET_UTFI:PAnsiChar = 'Miranda/System/GetUTFI'; + +(* + -- Thread Safety -- + + Proper thread safe shutdown was implemented in 0.3.0.0 (2003/04/18) + and not before, therefore it is improper that any MT plugins be used + with earlier versions of Miranda (as hav0c will result) + + Note: This does not apply to MT plugins which included their own + thread-safe shutdown routines. + + Shutdown thread safety works thusly: + + All new threads must call MS_SYSTEM_THREAD_PUSH and MS_SYSTEM_THREAD_POP + when they return. + + Due to the nature of thread creation, it is illegal to assume + just a call pair of MS_SYSTEM_THREAD_PUSH inside the thread will + be enough -- the source thread may only return when the new child + thread has actually executed MS_SYSTEM_THREAD_PUSH + + This is because a thread maybe in an undefined state at the point + when the thread creation routine returns, thus Miranda may exit + thinking it is safe to do so, because MS_SYSTEM_THREAD_PUSH was not + called in time. + + See miranda.c for how this can be done using an event object + which is signalled just after the MS_SYSTEM_THREAD_PUSH call is executed + and so the source thread knows that the created thread is known to Miranda. + + -- What happens when Miranda exits -- + + Miranda will firstly set an event object to signalled, this will + make MS_SYSTEM_TERMINATED return TRUE, it will then fire ME_SYSTEM_PRESHUTDOWN + at this point, no plugins or modules are unloaded. + + Miranda will then enumerate all active threads and queue an APC call + to each thread, so any thread in an alertable state will become active, + this functionailty may not be required by your threads: but if you use + the Winsock2 event object system or Sleep() please use the alertable + wait functions, so that the thread will 'wake up' when Miranda queues + a message to it, SleepEx() will return WAIT_IO_COMPLETION if this happens. + + After all threads have been signalled, Miranda will spin on the unwind thread stack waiting + for it to become empty, in this time, it will carry on processing thread + switches, clearing it's own APC calls (used by NotifyEventHooks(), CallServiceSync()) + + So a thread should be written in this kind of form: + + void mythread(void arg) + { + // assume all thread pushing/popping is done by forkthread() + int run=1; + for (;run;) + { + Beep(4391,500); + SleepEx(1500,TRUE); + if (Miranda_Terminated()) { + Beep(5000,150); run=0; + } //if + } //for + } + + The above will make a nice Beep every 1.5 seconds and when the UI + quits, it will make a lower beep and then return. + + As many copies of this thread maybe running, the creator does not need + to worry about what to do with previous threads, as long as they're on the + unwind stack.If there are any global resources (and they're mutex) you can free() them + at Unload(), which will only be called, after all threads have returned. + + -- Summary -- + + MS_SYSTEM_TERMINATED (will start returning TRUE) + ME_SYSTEM_PRESHUTDOWN will be fired (The CList won't be visible at this point) + + All PROTOTYPE_PROTOCOL registered plugins will be sent ID_STATUS_OFFLINE + automatically. + + All the threads will be notified via QueueUserAPC() and then Miranda + will poll on the unwind thread queue until it is empty. + + ME_SYSTEM_SHUTDOWN will be fired, the database will be unloaded, the core + will be unloaded -- Miranda will return. +*) + +{ 0.5.2+ +wParam=function address +lParam=function parameter + +registers a thread in the core and forks it +} + +type + pThreadFunc = function(p:pointer):integer; cdecl; + +const + MS_SYSTEM_FORK_THREAD:PAnsiChar = 'Miranda/Thread/Fork'; + +{ 0.5.2+ +wParam=void* - thread owner object +lParam=FORK_THREADEX_PARAMS* + +registers a thread in the core and forks it +passes the extended parameters info and returns the thread id +} + +type + pThreadFuncEx = function(p:pointer):integer; stdcall; + pThreadFuncOwner = function(owner, param:pointer):integer; cdecl; + +type + FORK_THREADEX_PARAMS = record + pFunc :pThreadFuncEx; + iStackSize:int; + arg :pointer; + threadID :^dword; + end; + +const + MS_SYSTEM_FORK_THREAD_EX:PAnsiChar = 'Miranda/Thread/ForkEx'; +(* +static __inline int mir_forkthreadex( pThreadFuncEx aFunc, void* arg, int stackSize, unsigned* pThreadID ) +{ + FORK_THREADEX_PARAMS params; + params.pFunc = aFunc; + params.arg = arg; + params.iStackSize = stackSize; + params.threadID = pThreadID; + return CallService( MS_SYSTEM_FORK_THREAD_EX, 0, (LPARAM)¶ms ); +} +*) + +{ 0.8.0+ + wParam=(void*)owner + lParam=FORK_THREADEX_PARAMS* + + registers a thread, owned by some object, in the core and forks it + passes the owner info and extended parameters info and returns the thread id +} + +// MS_SYSTEM_FORK_OWNED_THREAD:PAnsiChar = 'Miranda/Thread/ForkOwned'; + +(* +static __inline int mir_forkthreadowner( pThreadFuncOwner aFunc, void* owner, void* arg, unsigned* pThreadID ) +{ + FORK_THREADEX_PARAMS params; + params.pFunc = ( pThreadFuncEx )aFunc; + params.arg = arg; + params.iStackSize = 0; + params.threadID = pThreadID; + return CallService( MS_SYSTEM_FORK_THREAD_EX, (WPARAM)owner, (LPARAM)¶ms ); +} +*) + { + wParam=0 + lParam=0 + + Add a thread to the unwind wait stack that Miranda will poll on + when it is tearing down modules. + + This must be called in the context of the thread that is to be pushed + i.e. there are no args, it works out what thread is being called + and gets itself a handle to the calling thread. + } + MS_SYSTEM_THREAD_PUSH:PAnsiChar = 'Miranda/Thread/Push'; + + { + wParam=0 + lParam=0 + + Remove a thread from the unwind wait stack -- it is expected + that the call be made in the context of the thread to be removed. + + Miranda will begin to tear down modules and plugins if/when the + last thread from the unwind stack is removed. + } + MS_SYSTEM_THREAD_POP:PAnsiChar = 'Miranda/Thread/Pop'; + { + wParam=0 + lParam=0 + + This hook is fired just before the thread unwind stack is used, + it allows MT plugins to shutdown threads if they have any special + processing to do, etc. + } + ME_SYSTEM_PRESHUTDOWN:PAnsiChar = 'Miranda/System/PShutdown'; + + { + wParam=0 + lParam=0 + + Returns TRUE when Miranda has got WM_QUIT and is in the process + of shutting down + } + MS_SYSTEM_TERMINATED:PAnsiChar = 'Miranda/SysTerm'; + + { + wParam : 0 + lParam : (address) void (__cdecl callback) (void) + Affect : Setup a function pointer to be called after main loop iterations, it allows for + idle processing, See notes + Returns: 1 on success, 0 on failure + + Notes : This service will only allow one function to be registered, if one is registered, 0 will be returned + Remember that this uses __cdecl. + Version: Added during 0.3.4+ + } + MS_SYSTEM_SETIDLECALLBACK:PAnsiChar = 'Miranda/SetIdleCallback'; + + { + wParam : 0 + lParam : &tick + Affect : return the last window tick where a monitored event was seen, currently WM_CHAR/WM_MOUSEMOVE + Returns: Always returns 0 + Version: Added during 0.3.4+ (2004/09/12) + } + MS_SYSTEM_GETIDLE:PAnsiChar = 'Miranda/GetIdle'; + + { + wParam: cchMax (max length of buffer) + lParam: pointer to buffer to fill + Affect: Returns the build timestamp of the core, as a string of YYYYMMDDhhmmss, this service might + not exist and therefore the build is before 2004-09-30 + Returns: zero on success, non zero on failure + Version: 0.3.4a+ (2004/09/30) + DEFUNCT: This service was removed on 0.3.4.3+ (2004/11/19) use APILEVEL + } + MS_SYSTEM_GETBUILDSTRING:PAnsiChar = 'Miranda/GetBuildString'; + + { + Missing service catcher + Is being called when one calls the non-existent service. + All parameters are stored in the special structure + + The event handler takes 0 as wParam and TMissingServiceParams* as lParam. + + 0.4.3+ addition (2006/03/27) + } +type + PTMissingServiceParams = ^TMissingServiceParams; + TMissingServiceParams = record + name :PAnsiChar; + wParam:WPARAM; + lParam:LPARAM; + end; + +const + ME_SYSTEM_MISSINGSERVICE:PAnsiChar = 'System/MissingService'; + +{ Unhandled exceptions filter +Is being called inside any thread launched via mir_forkthread, including the main thread. +If a plugin's author executes a large piece of code inside __try/__except, he should +obtain this filter and call it inside the __except section + +0.8.0+ addition (2008/07/20) +} + +type + PEXCEPTION_POINTERS = ^EXCEPTION_POINTERS; + pfnExceptionFilter = function(code:dword; info:PEXCEPTION_POINTERS):DWORD; cdecl; +const + MS_SYSTEM_GETEXCEPTFILTER:PAnsiChar = 'System/GetExceptFilter'; + + +{$ENDIF} -- cgit v1.2.3