src/msw/main.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/main.cpp
   3 // Purpose:     WinMain/DllMain
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #include "wx/event.h"
  32 #include "wx/app.h"
  33 #include "wx/cmdline.h"
  34
  35 #include "wx/msw/private.h"
  36
  37 #if wxUSE_ON_FATAL_EXCEPTION
  38     #include "wx/datetime.h"
  39     #include "wx/msw/crashrpt.h"
  40
  41     #ifdef __VISUALC__
  42         #include <eh.h>
  43     #endif // __VISUALC__
  44 #endif // wxUSE_ON_FATAL_EXCEPTION
  45
  46 #ifdef __WXWINCE__
  47     // there is no ExitProcess() under CE but exiting the main thread has the
  48     // same effect
  49     #ifndef ExitProcess
  50         #define ExitProcess ExitThread
  51     #endif
  52 #endif // __WXWINCE__
  53
  54 #ifdef __BORLANDC__
  55     // BC++ has to be special: its run-time expects the DLL entry point to be
  56     // named DllEntryPoint instead of the (more) standard DllMain
  57     #define DllMain DllEntryPoint
  58 #endif // __BORLANDC__
  59
  60 #if defined(__WXMICROWIN__)
  61     #define HINSTANCE HANDLE
  62 #endif
  63
  64 // defined in common/init.cpp
  65 extern int wxEntryReal(int& argc, wxChar **argv);
  66
  67 // ============================================================================
  68 // implementation: various entry points
  69 // ============================================================================
  70
  71 #if wxUSE_BASE
  72
  73 #if wxUSE_ON_FATAL_EXCEPTION && defined(__VISUALC__) && !defined(__WXWINCE__)
  74     // VC++ (at least from 4.0 up to version 7.1) is incredibly broken in that
  75     // a "catch ( ... )" will *always* catch SEH exceptions in it even though
  76     // it should have never been the case... to prevent such catches from
  77     // stealing the exceptions from our wxGlobalSEHandler which is only called
  78     // if the exception is not handled elsewhere, we have to also call it from
  79     // a special SEH translator function which is called by VC CRT when a Win32
  80     // exception occurs
  81
  82     // this warns that /EHa (async exceptions) should be used when using
  83     // _set_se_translator but, in fact, this doesn't seem to change anything
  84     // with VC++ up to 7.1 -- to be confirmed with VC++ 8
  85     #if _MSC_VER <= 1310
  86         #pragma warning(disable:4535)
  87     #endif
  88
  89     // note that the SE translator must be called wxSETranslator!
  90     #define DisableAutomaticSETranslator() _set_se_translator(wxSETranslator)
  91 #else // !__VISUALC__
  92     #define DisableAutomaticSETranslator()
  93 #endif // __VISUALC__/!__VISUALC__
  94
  95 // ----------------------------------------------------------------------------
  96 // wrapper wxEntry catching all Win32 exceptions occuring in a wx program
  97 // ----------------------------------------------------------------------------
  98
  99 // wrap real wxEntry in a try-except block to be able to call
 100 // OnFatalException() if necessary
 101 #if wxUSE_ON_FATAL_EXCEPTION
 102
 103 // global pointer to exception information, only valid inside OnFatalException,
 104 // used by wxStackWalker and wxCrashReport
 105 extern EXCEPTION_POINTERS *wxGlobalSEInformation = NULL;
 106
 107 // flag telling us whether the application wants to handle exceptions at all
 108 static bool gs_handleExceptions = false;
 109
 110 static void wxFatalExit()
 111 {
 112     // use the same exit code as abort()
 113     ::ExitProcess(3);
 114 }
 115
 116 unsigned long wxGlobalSEHandler(EXCEPTION_POINTERS *pExcPtrs)
 117 {
 118     if ( gs_handleExceptions && wxTheApp )
 119     {
 120         // store the pointer to exception info
 121         wxGlobalSEInformation = pExcPtrs;
 122
 123         // give the user a chance to do something special about this
 124         __try
 125         {
 126             wxTheApp->OnFatalException();
 127         }
 128         __except ( EXCEPTION_EXECUTE_HANDLER )
 129         {
 130             // nothing to do here, just ignore the exception inside the
 131             // exception handler
 132             ;
 133         }
 134
 135         wxGlobalSEInformation = NULL;
 136
 137         // this will execute our handler and terminate the process
 138         return EXCEPTION_EXECUTE_HANDLER;
 139     }
 140
 141     return EXCEPTION_CONTINUE_SEARCH;
 142 }
 143
 144 #ifdef __VISUALC__
 145
 146 static void wxSETranslator(unsigned int WXUNUSED(code), EXCEPTION_POINTERS *ep)
 147 {
 148     switch ( wxGlobalSEHandler(ep) )
 149     {
 150         default:
 151             wxFAIL_MSG( _T("unexpected wxGlobalSEHandler() return value") );
 152             // fall through
 153
 154         case EXCEPTION_EXECUTE_HANDLER:
 155             // if wxApp::OnFatalException() had been called we should exit the
 156             // application -- but we shouldn't kill our host when we're a DLL
 157 #ifndef WXMAKINGDLL
 158             wxFatalExit();
 159 #endif // not a DLL
 160             break;
 161
 162         case EXCEPTION_CONTINUE_SEARCH:
 163             // we're called for each "catch ( ... )" and if we (re)throw from
 164             // here, the catch handler body is not executed, so the effect is
 165             // as if had inhibited translation of SE to C++ ones because the
 166             // handler will never see any structured exceptions
 167             throw;
 168     }
 169 }
 170
 171 #endif // __VISUALC__
 172
 173 bool wxHandleFatalExceptions(bool doit)
 174 {
 175     // assume this can only be called from the main thread
 176     gs_handleExceptions = doit;
 177
 178 #if wxUSE_CRASHREPORT
 179     if ( doit )
 180     {
 181         // try to find a place where we can put out report file later
 182         wxChar fullname[MAX_PATH];
 183         if ( !::GetTempPath(WXSIZEOF(fullname), fullname) )
 184         {
 185             wxLogLastError(_T("GetTempPath"));
 186
 187             // when all else fails...
 188             wxStrcpy(fullname, _T("c:\\"));
 189         }
 190
 191         // use PID and date to make the report file name more unique
 192         wxString name = wxString::Format
 193                         (
 194                             _T("%s_%s_%lu.dmp"),
 195                             wxTheApp ? wxTheApp->GetAppName().c_str()
 196                                      : _T("wxwindows"),
 197                             wxDateTime::Now().Format(_T("%Y%m%dT%H%M%S")).c_str(),
 198                             ::GetCurrentProcessId()
 199                         );
 200
 201         wxStrncat(fullname, name, WXSIZEOF(fullname) - wxStrlen(fullname) - 1);
 202
 203         wxCrashReport::SetFileName(fullname);
 204     }
 205 #endif // wxUSE_CRASHREPORT
 206
 207     return true;
 208 }
 209
 210 int wxEntry(int& argc, wxChar **argv)
 211 {
 212     DisableAutomaticSETranslator();
 213
 214     __try
 215     {
 216         return wxEntryReal(argc, argv);
 217     }
 218     __except ( wxGlobalSEHandler(GetExceptionInformation()) )
 219     {
 220         wxFatalExit();
 221
 222 #if !defined(_MSC_VER) || defined(__WXDEBUG__) || (defined(_MSC_VER) && _MSC_VER <= 1200)
 223         // this code is unreachable but put it here to suppress warnings in some compilers
 224         // and disable for others to supress warnings too
 225         return -1;
 226 #endif // !__VISUALC__ in release build
 227     }
 228 }
 229
 230 #else // !wxUSE_ON_FATAL_EXCEPTION
 231
 232 #if defined(__VISUALC__) && !defined(__WXWINCE__)
 233
 234 static void
 235 wxSETranslator(unsigned int WXUNUSED(code), EXCEPTION_POINTERS * WXUNUSED(ep))
 236 {
 237     // see wxSETranslator() version for wxUSE_ON_FATAL_EXCEPTION above
 238     throw;
 239 }
 240
 241 #endif // __VISUALC__
 242
 243 int wxEntry(int& argc, wxChar **argv)
 244 {
 245     DisableAutomaticSETranslator();
 246
 247     return wxEntryReal(argc, argv);
 248 }
 249
 250 #endif // wxUSE_ON_FATAL_EXCEPTION/!wxUSE_ON_FATAL_EXCEPTION
 251
 252 #endif // wxUSE_BASE
 253
 254 #if wxUSE_GUI
 255
 256 // ----------------------------------------------------------------------------
 257 // Windows-specific wxEntry
 258 // ----------------------------------------------------------------------------
 259
 260 WXDLLEXPORT int wxEntry(HINSTANCE hInstance,
 261                         HINSTANCE WXUNUSED(hPrevInstance),
 262                         wxCmdLineArgType WXUNUSED(pCmdLine),
 263                         int nCmdShow)
 264 {
 265     // remember the parameters Windows gave us
 266     wxSetInstance(hInstance);
 267     wxApp::m_nCmdShow = nCmdShow;
 268
 269     // parse the command line: we can't use pCmdLine in Unicode build so it is
 270     // simpler to never use it at all (this also results in a more correct
 271     // argv[0])
 272
 273     // break the command line in words
 274     wxArrayString args;
 275
 276     const wxChar *cmdLine = ::GetCommandLine();
 277     if ( cmdLine )
 278     {
 279         args = wxCmdLineParser::ConvertStringToArgs(cmdLine);
 280     }
 281
 282 #ifdef __WXWINCE__
 283     // WinCE doesn't insert the program itself, so do it ourselves.
 284     args.Insert(wxGetFullModuleName(), 0);
 285 #endif
 286
 287     int argc = args.GetCount();
 288
 289     // +1 here for the terminating NULL
 290     wxChar **argv = new wxChar *[argc + 1];
 291     for ( int i = 0; i < argc; i++ )
 292     {
 293         argv[i] = wxStrdup(args[i]);
 294     }
 295
 296     // argv[] must be NULL-terminated
 297     argv[argc] = NULL;
 298
 299     return wxEntry(argc, argv);
 300 }
 301
 302 // May wish not to have a DllMain or WinMain, e.g. if we're programming
 303 // a Netscape plugin or if we're writing a console application
 304 #if !defined(NOMAIN)
 305
 306 extern "C"
 307 {
 308
 309 // ----------------------------------------------------------------------------
 310 // WinMain
 311 // ----------------------------------------------------------------------------
 312
 313 // Note that WinMain is also defined in dummy.obj, which is linked to
 314 // an application that is using the DLL version of wxWidgets.
 315
 316 #if defined(_WINDLL)
 317
 318 // DLL entry point
 319
 320 BOOL WINAPI
 321 DllMain(HINSTANCE hModule, DWORD fdwReason, LPVOID WXUNUSED(lpReserved))
 322 {
 323     // Only call wxEntry if the application itself is part of the DLL.
 324     // If only the wxWidgets library is in the DLL, then the
 325     // initialisation will be called when the application implicitly
 326     // calls WinMain.
 327 #ifndef WXMAKINGDLL
 328     switch (fdwReason)
 329     {
 330         case DLL_PROCESS_ATTACH:
 331             return wxEntry(hModule);
 332
 333         case DLL_PROCESS_DETACH:
 334             wxEntryCleanup();
 335             break;
 336     }
 337 #else
 338     (void)hModule;
 339     (void)fdwReason;
 340 #endif // !WXMAKINGDLL
 341
 342     return TRUE;
 343 }
 344
 345 #endif // _WINDLL
 346
 347 } // extern "C"
 348
 349 #endif // !NOMAIN
 350
 351 #endif // wxUSE_GUI
 352
 353 // ----------------------------------------------------------------------------
 354 // global HINSTANCE
 355 // ----------------------------------------------------------------------------
 356
 357 #if wxUSE_BASE
 358
 359 HINSTANCE wxhInstance = 0;
 360
 361 extern "C" HINSTANCE wxGetInstance()
 362 {
 363     return wxhInstance;
 364 }
 365
 366 void wxSetInstance(HINSTANCE hInst)
 367 {
 368     wxhInstance = hInst;
 369 }
 370
 371 #endif // wxUSE_BASE
 372