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         // this code is unreachable but put it here to suppress warnings
 223         return -1;
 224     }
 225 }
 226
 227 #else // !wxUSE_ON_FATAL_EXCEPTION
 228
 229 #if defined(__VISUALC__) && !defined(__WXWINCE__)
 230
 231 static void
 232 wxSETranslator(unsigned int WXUNUSED(code), EXCEPTION_POINTERS * WXUNUSED(ep))
 233 {
 234     // see wxSETranslator() version for wxUSE_ON_FATAL_EXCEPTION above
 235     throw;
 236 }
 237
 238 #endif // __VISUALC__
 239
 240 int wxEntry(int& argc, wxChar **argv)
 241 {
 242     DisableAutomaticSETranslator();
 243
 244     return wxEntryReal(argc, argv);
 245 }
 246
 247 #endif // wxUSE_ON_FATAL_EXCEPTION/!wxUSE_ON_FATAL_EXCEPTION
 248
 249 #endif // wxUSE_BASE
 250
 251 #if wxUSE_GUI
 252
 253 // ----------------------------------------------------------------------------
 254 // Windows-specific wxEntry
 255 // ----------------------------------------------------------------------------
 256
 257 WXDLLEXPORT int wxEntry(HINSTANCE hInstance,
 258                         HINSTANCE WXUNUSED(hPrevInstance),
 259                         wxCmdLineArgType WXUNUSED(pCmdLine),
 260                         int nCmdShow)
 261 {
 262     // remember the parameters Windows gave us
 263     wxSetInstance(hInstance);
 264     wxApp::m_nCmdShow = nCmdShow;
 265
 266     // parse the command line: we can't use pCmdLine in Unicode build so it is
 267     // simpler to never use it at all (this also results in a more correct
 268     // argv[0])
 269
 270     // break the command line in words
 271     wxArrayString args;
 272
 273     const wxChar *cmdLine = ::GetCommandLine();
 274     if ( cmdLine )
 275     {
 276         args = wxCmdLineParser::ConvertStringToArgs(cmdLine);
 277     }
 278
 279 #ifdef __WXWINCE__
 280     // WinCE doesn't insert the program itself, so do it ourselves.
 281     args.Insert(wxGetFullModuleName(), 0);
 282 #endif
 283
 284     int argc = args.GetCount();
 285
 286     // +1 here for the terminating NULL
 287     wxChar **argv = new wxChar *[argc + 1];
 288     for ( int i = 0; i < argc; i++ )
 289     {
 290         argv[i] = wxStrdup(args[i]);
 291     }
 292
 293     // argv[] must be NULL-terminated
 294     argv[argc] = NULL;
 295
 296     return wxEntry(argc, argv);
 297 }
 298
 299 // May wish not to have a DllMain or WinMain, e.g. if we're programming
 300 // a Netscape plugin or if we're writing a console application
 301 #if !defined(NOMAIN)
 302
 303 extern "C"
 304 {
 305
 306 // ----------------------------------------------------------------------------
 307 // WinMain
 308 // ----------------------------------------------------------------------------
 309
 310 // Note that WinMain is also defined in dummy.obj, which is linked to
 311 // an application that is using the DLL version of wxWidgets.
 312
 313 #if defined(_WINDLL)
 314
 315 // DLL entry point
 316
 317 BOOL WINAPI
 318 DllMain(HINSTANCE hModule, DWORD fdwReason, LPVOID WXUNUSED(lpReserved))
 319 {
 320     // Only call wxEntry if the application itself is part of the DLL.
 321     // If only the wxWidgets library is in the DLL, then the
 322     // initialisation will be called when the application implicitly
 323     // calls WinMain.
 324 #ifndef WXMAKINGDLL
 325     switch (fdwReason)
 326     {
 327         case DLL_PROCESS_ATTACH:
 328             return wxEntry(hModule);
 329
 330         case DLL_PROCESS_DETACH:
 331             wxEntryCleanup();
 332             break;
 333     }
 334 #else
 335     (void)hModule;
 336     (void)fdwReason;
 337 #endif // !WXMAKINGDLL
 338
 339     return TRUE;
 340 }
 341
 342 #endif // _WINDLL
 343
 344 } // extern "C"
 345
 346 #endif // !NOMAIN
 347
 348 #endif // wxUSE_GUI
 349
 350 // ----------------------------------------------------------------------------
 351 // global HINSTANCE
 352 // ----------------------------------------------------------------------------
 353
 354 #if wxUSE_BASE
 355
 356 HINSTANCE wxhInstance = 0;
 357
 358 extern "C" HINSTANCE wxGetInstance()
 359 {
 360     return wxhInstance;
 361 }
 362
 363 void wxSetInstance(HINSTANCE hInst)
 364 {
 365     wxhInstance = hInst;
 366 }
 367
 368 #endif // wxUSE_BASE
 369