|
|
#ifdef CRTDLL
/***
*crtdll.c - CRT initialization for a DLL using the CRTDLL model of C run-time * * Copyright (c) 1991-1994, Microsoft Corporation. All rights reserved. * *Purpose: * This module contains the initialization entry point for the C run-time * stub in this DLL. All C run-time code is located in the C Run-Time * Library DLL "CRTDLL.DLL", except for a little bit of start-up code in * the EXE, and this code in each DLL. This code is necessary to invoke * the C++ constructors for the C++ code in this DLL. * * This entry point should either be specified as the DLL initialization * entry point, or else it must be called by the DLL initialization entry * point of the DLL with the same arguments that the entry point receives. * *Revision History: * 05-19-92 SKS Initial version * 08-01-92 SRW winxcpt.h replaced bu excpt.h which is included by oscalls.h * 09-16-92 SKS Prepare for C8 C++ for MIPS by calling C++ constructors * 09-29-92 SKS _CRT_DLL must be a WINAPI function! * 05-11-93 SKS Add _DllMainCRTStartup as an alternative to _CRT_INIT * 06-05-93 SRW Pin CRTDLL.DLL in memory once loaded. * 06-07-93 GJF Added __proc_attached flag. * 06-07-93 GJF Backed out SteveWo's change of 06-05 and put it into * crtlib.c * 06-08-93 SKS Clean up failure handling in _CRT_INIT * 07-16-93 SRW ALPHA Merge * 12-02-93 SKS Add atexit/_onexit support. These routines must be * defined here so that DLL's that are linked with * CRTDLL.LIB will get these versions (suitable for DLLs), * not the versions of atexit/_onexit from CRTDLL.DLL, * which are only suitable for an EXE file. * 07-18-94 GJF Moved over Win32s support from VC 2.0 tree. * *******************************************************************************/
/*
* SPECIAL BUILD MACRO! Note that crtexe.c (and crtexew.c) is linked in with * the client's code. It does not go into crtdll.dll! Therefore, it must be * built under the _DLL switch (like user code) and CRTDLL must be undefined. */ #undef CRTDLL
#define _DLL
#include <cruntime.h>
#include <oscalls.h>
#include <internal.h>
#include <stdlib.h>
#define _DECL_DLLMAIN /* enable prototypes for DllMain and _CRT_INIT */
#include <process.h>
/*
* routine in DLL to do initialization (in this case, C++ constructors) */ typedef void (_CALLTYPE1 *PF)(void);
extern void _CALLTYPE4 _initterm(PF *, PF *);
/*
* pointers to initialization sections */ extern PF __xc_a[], __xc_z[]; /* C++ initializers */
/*
* Flag identifying the host as Win32s or not-Win32s. */ int __win32sflag = 0;
static int onexitflag = 0;
/*
* flag set iff _CRTDLL_INIT was called with DLL_PROCESS_ATTACH */ static int __proc_attached = 0;
/*
* Pointers to beginning and end of the table of function pointers manipulated * by _onexit()/atexit(). The atexit/_onexit code is shared for both EXE's and * DLL's but different behavior is required. These values are initialized to * 0 by default and will be set to point to a malloc-ed memory block to mark * this module as an DLL. */
PF *__onexitbegin; PF *__onexitend;
/*
* User routine DllMain is called on all notifications */
extern BOOL WINAPI DllMain( HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved ) ;
/***
*BOOL WINAPI _CRT_INIT(hDllHandle, dwReason, lpreserved) - C++ DLL initialization. * *Purpose: * This routine does the C runtime initialization for a DLL using CRTDLL. * It may be specified as the entry point for the DLL, or it may be * called by the routine that is the DLL entry point. * * On DLL_PROCESS_ATTACH, the C++ constructors for the DLL will be called. * * On DLL_PROCESS_DETACH, the C++ destructors and _onexit/atexit routines * will be called. * *Entry: * *Exit: * *******************************************************************************/
BOOL WINAPI _CRT_INIT( HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved ) { unsigned osver;
/*
* First, set the __proc_attached flag */ if ( dwReason == DLL_PROCESS_ATTACH ) __proc_attached++; else if ( dwReason == DLL_PROCESS_DETACH ) { if ( __proc_attached > 0 ) __proc_attached--; else /*
* no prior process attach. just return failure. */ return FALSE; }
/*
* Get the host version (on first call). */ if ( __win32sflag == 0 ) { osver = GetVersion(); if ( ((osver & 0x00ff) == 3) && ((osver >> 31) & 1) ) __win32sflag++; else __win32sflag--; }
/*
* do C++ constructors (initializers) specific to this DLL */
if ( dwReason == DLL_PROCESS_ATTACH ) {
/*
* If the host is Win32s, create the onexit table and do C++ * constructors only for the first connecting process. */ if ( (__win32sflag < 0) || (__proc_attached == 1) ) {
if ( __win32sflag < 0 ) { /*
* not Win32s! just malloc the table. */ if ( (__onexitbegin = (PF *)malloc(32 * sizeof(PF))) == NULL ) /*
* cannot allocate minimal required * size. generate failure to load DLL */ return FALSE; } else if ( __proc_attached == 1 ) { if ( (__onexitbegin = (PF *)GlobalAlloc( GMEM_FIXED | GMEM_SHARE, 32 * sizeof(PF) )) == NULL ) /*
* cannot allocate minimal required * size. generate failure to load DLL */ return FALSE; }
*(__onexitbegin) = (PF) NULL;
__onexitend = __onexitbegin;
/*
* Invoke C++ constructors */ _initterm(__xc_a,__xc_z);
} } else if ( dwReason == DLL_PROCESS_DETACH ) {
if ( (__win32sflag < 0) || (__proc_attached == 0) ) { /*
* Any basic clean-up code that goes here must be * duplicated below in _DllMainCRTStartup for the * case where the user's DllMain() routine fails on a * Process Attach notification. This does not include * calling user C++ destructors, etc. */
/*
* do _onexit/atexit() terminators * (if there are any) * * These terminators MUST be executed in * reverse order (LIFO)! * * NOTE: * This code assumes that __onexitbegin * points to the first valid onexit() * entry and that __onexitend points * past the last valid entry. If * __onexitbegin == __onexitend, the * table is empty and there are no * routines to call. */
if (__onexitbegin) { PF * pfend = __onexitend;
while ( -- pfend >= __onexitbegin ) /*
* if current table entry is not * NULL, call thru it. */ if ( *pfend != NULL ) (**pfend)();
/*
* just in case Win32s doesn't clean up after * us (any bets?), free the block holding * onexit table */ if ( __win32sflag > 0 ) GlobalFree( (HGLOBAL)__onexitbegin ); else free(__onexitbegin); } } }
return TRUE; }
/***
*BOOL WINAPI _DllMainCRTStartup(hDllHandle, dwReason, lpreserved) - C++ DLL initialization. * *Purpose: * This is an alternative entry point for DLL's linked with the C run-time * libs, rather than using _CRT_INIT. The user should specify this routine * as the DLL entry point, and define his/her own routine DllMain to get * notifications in his/her code. CRT initialization/termination will be * done before or after calling DllMain, as appropriate. * *Entry: * *Exit: * *******************************************************************************/ BOOL WINAPI _DllMainCRTStartup( HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved ) { BOOL retcode = TRUE;
/*
* If this is a process detach notification, check that there has * been a prior process attach notification. */ if ( (dwReason == DLL_PROCESS_DETACH) && (__proc_attached == 0) ) return FALSE;
if ( dwReason == DLL_PROCESS_ATTACH || dwReason == DLL_THREAD_ATTACH ) retcode = _CRT_INIT(hDllHandle, dwReason, lpreserved);
if ( retcode ) retcode = DllMain(hDllHandle, dwReason, lpreserved);
/*
* If _CRT_INIT successfully handles a Process Attach notification * but the user's DllMain routine returns failure, we need to do * clean-up of the C run-time similar to what _CRT_INIT does on a * Process Detach Notification. */
if ( dwReason == DLL_PROCESS_DETACH || dwReason == DLL_THREAD_DETACH ) { if ( _CRT_INIT(hDllHandle, dwReason, lpreserved) == FALSE ) retcode = FALSE ; }
return retcode ; }
/***
*_onexit, atexit - calls to DLL versioons of _onexit & atexit in CRTDLL.DLL * *Purpose: * A DLL linked with CRTDLL.LIB must not call the standard _onexit or * atexit exported from CRTDLL.DLL, but an EXE linked with CRTDLL.LIB * will call the standard versions of those two routines. Since the * names are exported from CRTDLL.DLL, we must define them here for DLLs. * All DLLs linked with CRTDLL.LIB must pull in this startup object. * *Entry: * Same as the regular versions of _onexit, atexit. * *Exit: * Same as the regular versions of _onexit, atexit. * *Exceptions: * *******************************************************************************/
extern _onexit_t _CALLTYPE1 __dllonexit(_onexit_t, PF **, PF **);
_onexit_t _CALLTYPE1 _onexit ( _onexit_t func ) { unsigned osver; _onexit_t retval;
/*
* Get the host version (on first call). */ if ( __win32sflag == 0 ) { osver = GetVersion(); if ( ((osver & 0x00ff) == 3) && ((osver >> 31) & 1) ) __win32sflag++; else __win32sflag--; }
/*
* If we are running in Win32s, test and set the flag used to * serialize access. Note that we assume no process switch can take * place between a successful test of the flag and the setting of * the flag. */ if ( __win32sflag > 0 ) { while ( onexitflag > 0 ) Sleep(0); onexitflag++; }
retval = __dllonexit(func, &__onexitbegin, &__onexitend);
if ( __win32sflag > 0 ) onexitflag--;
return retval; }
int _CALLTYPE1 atexit ( PF func ) { return (_onexit((_onexit_t)func) == NULL) ? -1 : 0; }
#endif /* CRTDLL */
|