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 occurring 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     // the first thing to do is to check if we're trying to run an Unicode
 266     // program under Win9x w/o MSLU emulation layer - if so, abort right now
 267     // as it has no chance to work and has all chances to crash
 268 #if wxUSE_UNICODE && !wxUSE_UNICODE_MSLU && !defined(__WXWINCE__)
 269     if ( wxGetOsVersion() != wxWINDOWS_NT )
 270     {
 271         // note that we can use MessageBoxW() as it's implemented even under
 272         // Win9x - OTOH, we can't use wxGetTranslation() because the file APIs
 273         // used by wxLocale are not
 274         ::MessageBox
 275         (
 276          NULL,
 277          _T("This program uses Unicode and requires Windows NT/2000/XP.\nProgram aborted."),
 278          _T("wxWidgets Fatal Error"),
 279          MB_ICONERROR | MB_OK
 280         );
 281
 282         return -1;
 283     }
 284 #endif // wxUSE_UNICODE && !wxUSE_UNICODE_MSLU
 285
 286
 287     // remember the parameters Windows gave us
 288     wxSetInstance(hInstance);
 289     wxApp::m_nCmdShow = nCmdShow;
 290
 291     // parse the command line: we can't use pCmdLine in Unicode build so it is
 292     // simpler to never use it at all (this also results in a more correct
 293     // argv[0])
 294
 295     // break the command line in words
 296     wxArrayString args;
 297
 298     const wxChar *cmdLine = ::GetCommandLine();
 299     if ( cmdLine )
 300     {
 301         args = wxCmdLineParser::ConvertStringToArgs(cmdLine);
 302     }
 303
 304 #ifdef __WXWINCE__
 305     // WinCE doesn't insert the program itself, so do it ourselves.
 306     args.Insert(wxGetFullModuleName(), 0);
 307 #endif
 308
 309     int argc = args.GetCount();
 310
 311     // +1 here for the terminating NULL
 312     wxChar **argv = new wxChar *[argc + 1];
 313     for ( int i = 0; i < argc; i++ )
 314     {
 315         argv[i] = wxStrdup(args[i]);
 316     }
 317
 318     // argv[] must be NULL-terminated
 319     argv[argc] = NULL;
 320
 321     return wxEntry(argc, argv);
 322 }
 323
 324 // May wish not to have a DllMain or WinMain, e.g. if we're programming
 325 // a Netscape plugin or if we're writing a console application
 326 #if !defined(NOMAIN)
 327
 328 extern "C"
 329 {
 330
 331 // ----------------------------------------------------------------------------
 332 // WinMain
 333 // ----------------------------------------------------------------------------
 334
 335 // Note that WinMain is also defined in dummy.obj, which is linked to
 336 // an application that is using the DLL version of wxWidgets.
 337
 338 #if defined(_WINDLL)
 339
 340 // DLL entry point
 341
 342 BOOL WINAPI
 343 DllMain(HINSTANCE hModule, DWORD fdwReason, LPVOID WXUNUSED(lpReserved))
 344 {
 345     // Only call wxEntry if the application itself is part of the DLL.
 346     // If only the wxWidgets library is in the DLL, then the
 347     // initialisation will be called when the application implicitly
 348     // calls WinMain.
 349 #ifndef WXMAKINGDLL
 350     switch (fdwReason)
 351     {
 352         case DLL_PROCESS_ATTACH:
 353             return wxEntry(hModule);
 354
 355         case DLL_PROCESS_DETACH:
 356             wxEntryCleanup();
 357             break;
 358     }
 359 #else
 360     (void)hModule;
 361     (void)fdwReason;
 362 #endif // !WXMAKINGDLL
 363
 364     return TRUE;
 365 }
 366
 367 #endif // _WINDLL
 368
 369 } // extern "C"
 370
 371 #endif // !NOMAIN
 372
 373 #endif // wxUSE_GUI
 374
 375 // ----------------------------------------------------------------------------
 376 // global HINSTANCE
 377 // ----------------------------------------------------------------------------
 378
 379 #if wxUSE_BASE
 380
 381 HINSTANCE wxhInstance = 0;
 382
 383 extern "C" HINSTANCE wxGetInstance()
 384 {
 385     return wxhInstance;
 386 }
 387
 388 void wxSetInstance(HINSTANCE hInst)
 389 {
 390     wxhInstance = hInst;
 391 }
 392
 393 #endif // wxUSE_BASE
 394