dlls/msvcrt/exit.c

   1 /*
   2  * msvcrt.dll exit functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20 #include <stdio.h>
  21 #include "msvcrt.h"
  22 #include "mtdll.h"
  23 #include "winuser.h"
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  27
  28 /* MT */
  29 #define LOCK_EXIT   _mlock(_EXIT_LOCK1)
  30 #define UNLOCK_EXIT _munlock(_EXIT_LOCK1)
  31
  32 static MSVCRT__onexit_t *MSVCRT_atexit_table = NULL;
  33 static int MSVCRT_atexit_table_size = 0;
  34 static int MSVCRT_atexit_registered = 0; /* Points to free slot */
  35 static MSVCRT_purecall_handler purecall_handler = NULL;
  36
  37 static const char szMsgBoxTitle[] = "Wine C++ Runtime Library";
  38
  39 extern int MSVCRT_app_type;
  40 extern char *MSVCRT__pgmptr;
  41
  42 static unsigned int MSVCRT_abort_behavior =  MSVCRT__WRITE_ABORT_MSG | MSVCRT__CALL_REPORTFAULT;
  43
  44 void (*CDECL _aexit_rtn)(int) = MSVCRT__exit;
  45
  46 /* INTERNAL: call atexit functions */
  47 static void __MSVCRT__call_atexit(void)
  48 {
  49   /* Note: should only be called with the exit lock held */
  50   TRACE("%d atext functions to call\n", MSVCRT_atexit_registered);
  51   /* Last registered gets executed first */
  52   while (MSVCRT_atexit_registered > 0)
  53   {
  54     MSVCRT_atexit_registered--;
  55     TRACE("next is %p\n",MSVCRT_atexit_table[MSVCRT_atexit_registered]);
  56     if (MSVCRT_atexit_table[MSVCRT_atexit_registered])
  57       (*MSVCRT_atexit_table[MSVCRT_atexit_registered])();
  58     TRACE("returned\n");
  59   }
  60 }
  61
  62 /*********************************************************************
  63  *              __dllonexit (MSVCRT.@)
  64  */
  65 MSVCRT__onexit_t CDECL __dllonexit(MSVCRT__onexit_t func, MSVCRT__onexit_t **start, MSVCRT__onexit_t **end)
  66 {
  67   MSVCRT__onexit_t *tmp;
  68   int len;
  69
  70   TRACE("(%p,%p,%p)\n", func, start, end);
  71
  72   if (!start || !*start || !end || !*end)
  73   {
  74    FIXME("bad table\n");
  75    return NULL;
  76   }
  77
  78   len = (*end - *start);
  79
  80   TRACE("table start %p-%p, %d entries\n", *start, *end, len);
  81
  82   if (++len <= 0)
  83     return NULL;
  84
  85   tmp = MSVCRT_realloc(*start, len * sizeof(tmp));
  86   if (!tmp)
  87     return NULL;
  88   *start = tmp;
  89   *end = tmp + len;
  90   tmp[len - 1] = func;
  91   TRACE("new table start %p-%p, %d entries\n", *start, *end, len);
  92   return func;
  93 }
  94
  95 /*********************************************************************
  96  *              _exit (MSVCRT.@)
  97  */
  98 void CDECL MSVCRT__exit(int exitcode)
  99 {
 100   TRACE("(%d)\n", exitcode);
 101   ExitProcess(exitcode);
 102 }
 103
 104 /* Print out an error message with an option to debug */
 105 static void DoMessageBox(LPCSTR lead, LPCSTR message)
 106 {
 107   MSGBOXPARAMSA msgbox;
 108   char text[2048];
 109   INT ret;
 110
 111   snprintf(text,sizeof(text),"%s\n\nProgram: %s\n%s\n\n"
 112                "Press OK to exit the program, or Cancel to start the Wine debugger.\n ",
 113                lead, MSVCRT__pgmptr, message);
 114
 115   msgbox.cbSize = sizeof(msgbox);
 116   msgbox.hwndOwner = GetActiveWindow();
 117   msgbox.hInstance = 0;
 118   msgbox.lpszText = text;
 119   msgbox.lpszCaption = szMsgBoxTitle;
 120   msgbox.dwStyle = MB_OKCANCEL|MB_ICONERROR;
 121   msgbox.lpszIcon = NULL;
 122   msgbox.dwContextHelpId = 0;
 123   msgbox.lpfnMsgBoxCallback = NULL;
 124   msgbox.dwLanguageId = LANG_NEUTRAL;
 125
 126   ret = MessageBoxIndirectA(&msgbox);
 127   if (ret == IDCANCEL)
 128     DebugBreak();
 129 }
 130
 131 /*********************************************************************
 132  *              _amsg_exit (MSVCRT.@)
 133  */
 134 void CDECL _amsg_exit(int errnum)
 135 {
 136   TRACE("(%d)\n", errnum);
 137   /* FIXME: text for the error number. */
 138   if (MSVCRT_app_type == 2)
 139   {
 140     char text[32];
 141     sprintf(text, "Error: R60%d",errnum);
 142     DoMessageBox("Runtime error!", text);
 143   }
 144   else
 145     _cprintf("\nruntime error R60%d\n",errnum);
 146   _aexit_rtn(255);
 147 }
 148
 149 /*********************************************************************
 150  *              abort (MSVCRT.@)
 151  */
 152 void CDECL MSVCRT_abort(void)
 153 {
 154   TRACE("()\n");
 155
 156   if (MSVCRT_abort_behavior & MSVCRT__WRITE_ABORT_MSG)
 157   {
 158     if (MSVCRT_app_type == 2)
 159     {
 160       DoMessageBox("Runtime error!", "abnormal program termination");
 161     }
 162     else
 163       _cputs("\nabnormal program termination\n");
 164   }
 165   MSVCRT_raise(MSVCRT_SIGABRT);
 166   /* in case raise() returns */
 167   MSVCRT__exit(3);
 168 }
 169
 170 /*********************************************************************
 171  *              _set_abort_behavior (MSVCRT.@)
 172  *
 173  * Not exported by native msvcrt, added in msvcr80
 174  */
 175 unsigned int CDECL MSVCRT__set_abort_behavior(unsigned int flags, unsigned int mask)
 176 {
 177   unsigned int old = MSVCRT_abort_behavior;
 178
 179   TRACE("%x, %x\n", flags, mask);
 180   if (mask & MSVCRT__CALL_REPORTFAULT)
 181     FIXME("_WRITE_CALL_REPORTFAULT unhandled\n");
 182
 183   MSVCRT_abort_behavior = (MSVCRT_abort_behavior & ~mask) | (flags & mask);
 184   return old;
 185 }
 186
 187 /*********************************************************************
 188  *              _assert (MSVCRT.@)
 189  */
 190 void CDECL MSVCRT__assert(const char* str, const char* file, unsigned int line)
 191 {
 192   TRACE("(%s,%s,%d)\n",str,file,line);
 193   if (MSVCRT_app_type == 2)
 194   {
 195     char text[2048];
 196     snprintf(text, sizeof(text), "File: %s\nLine: %d\n\nExpression: \"%s\"", file, line, str);
 197     DoMessageBox("Assertion failed!", text);
 198   }
 199   else
 200     _cprintf("Assertion failed: %s, file %s, line %d\n\n",str, file, line);
 201   MSVCRT_raise(MSVCRT_SIGABRT);
 202   /* in case raise() returns */
 203   MSVCRT__exit(3);
 204 }
 205
 206 /*********************************************************************
 207  *              _c_exit (MSVCRT.@)
 208  */
 209 void CDECL MSVCRT__c_exit(void)
 210 {
 211   TRACE("(void)\n");
 212   /* All cleanup is done on DLL detach; Return to caller */
 213 }
 214
 215 /*********************************************************************
 216  *              _cexit (MSVCRT.@)
 217  */
 218 void CDECL MSVCRT__cexit(void)
 219 {
 220   TRACE("(void)\n");
 221   LOCK_EXIT;
 222   __MSVCRT__call_atexit();
 223   UNLOCK_EXIT;
 224 }
 225
 226 /*********************************************************************
 227  *              _onexit (MSVCRT.@)
 228  */
 229 MSVCRT__onexit_t CDECL MSVCRT__onexit(MSVCRT__onexit_t func)
 230 {
 231   TRACE("(%p)\n",func);
 232
 233   if (!func)
 234     return NULL;
 235
 236   LOCK_EXIT;
 237   if (MSVCRT_atexit_registered > MSVCRT_atexit_table_size - 1)
 238   {
 239     MSVCRT__onexit_t *newtable;
 240     TRACE("expanding table\n");
 241     newtable = MSVCRT_calloc(sizeof(void *),MSVCRT_atexit_table_size + 32);
 242     if (!newtable)
 243     {
 244       TRACE("failed!\n");
 245       UNLOCK_EXIT;
 246       return NULL;
 247     }
 248     memcpy (newtable, MSVCRT_atexit_table, MSVCRT_atexit_table_size);
 249     MSVCRT_atexit_table_size += 32;
 250     MSVCRT_free (MSVCRT_atexit_table);
 251     MSVCRT_atexit_table = newtable;
 252   }
 253   MSVCRT_atexit_table[MSVCRT_atexit_registered] = func;
 254   MSVCRT_atexit_registered++;
 255   UNLOCK_EXIT;
 256   return func;
 257 }
 258
 259 /*********************************************************************
 260  *              exit (MSVCRT.@)
 261  */
 262 void CDECL MSVCRT_exit(int exitcode)
 263 {
 264   TRACE("(%d)\n",exitcode);
 265   MSVCRT__cexit();
 266   ExitProcess(exitcode);
 267 }
 268
 269 /*********************************************************************
 270  *              atexit (MSVCRT.@)
 271  */
 272 int CDECL MSVCRT_atexit(void (*func)(void))
 273 {
 274   TRACE("(%p)\n", func);
 275   return MSVCRT__onexit((MSVCRT__onexit_t)func) == (MSVCRT__onexit_t)func ? 0 : -1;
 276 }
 277
 278 /* _set_purecall_handler - not exported in native msvcrt */
 279 MSVCRT_purecall_handler CDECL _set_purecall_handler(MSVCRT_purecall_handler function)
 280 {
 281     MSVCRT_purecall_handler ret = purecall_handler;
 282
 283     TRACE("(%p)\n", function);
 284     purecall_handler = function;
 285     return ret;
 286 }
 287
 288 /*********************************************************************
 289  *              _purecall (MSVCRT.@)
 290  */
 291 void CDECL _purecall(void)
 292 {
 293   TRACE("(void)\n");
 294
 295   if(purecall_handler)
 296       purecall_handler();
 297   _amsg_exit( 25 );
 298 }