dlls/msvcrt/data.c

   1 /*
   2  * msvcrt.dll dll data items
   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
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <math.h>
  25 #include "msvcrt.h"
  26 #include "wine/library.h"
  27 #include "wine/unicode.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  31
  32 int MSVCRT___argc = 0;
  33 static int wargc_expand;
  34 unsigned int MSVCRT__commode = 0;
  35 int MSVCRT__fmode = 0;
  36 unsigned int MSVCRT__osver = 0;
  37 unsigned int MSVCRT__osplatform = 0;
  38 unsigned int MSVCRT__winmajor = 0;
  39 unsigned int MSVCRT__winminor = 0;
  40 unsigned int MSVCRT__winver = 0;
  41 #ifdef _CRTDLL
  42 unsigned int CRTDLL__basemajor_dll = 0;
  43 unsigned int CRTDLL__baseminor_dll = 0;
  44 unsigned int CRTDLL__baseversion_dll = 0;
  45 unsigned int CRTDLL__cpumode_dll = 1;
  46 unsigned int CRTDLL__osmode_dll = 1;
  47 #endif
  48 unsigned int MSVCRT___setlc_active = 0;
  49 unsigned int MSVCRT___unguarded_readlc_active = 0;
  50 double MSVCRT__HUGE = 0;
  51 char **MSVCRT___argv = NULL;
  52 MSVCRT_wchar_t **MSVCRT___wargv = NULL;
  53 static MSVCRT_wchar_t **wargv_expand;
  54 char *MSVCRT__acmdln = NULL;
  55 MSVCRT_wchar_t *MSVCRT__wcmdln = NULL;
  56 char **MSVCRT__environ = NULL;
  57 MSVCRT_wchar_t **MSVCRT__wenviron = NULL;
  58 char **MSVCRT___initenv = NULL;
  59 MSVCRT_wchar_t **MSVCRT___winitenv = NULL;
  60 int MSVCRT_app_type = 0;
  61 char* MSVCRT__pgmptr = NULL;
  62 WCHAR* MSVCRT__wpgmptr = NULL;
  63
  64 /* Get a snapshot of the current environment
  65  * and construct the __p__environ array
  66  *
  67  * The pointer returned from GetEnvironmentStrings may get invalid when
  68  * some other module cause a reallocation of the env-variable block
  69  *
  70  * blk is an array of pointers to environment strings, ending with a NULL
  71  * and after that the actual copy of the environment strings, ending in a \0
  72  */
  73 char ** msvcrt_SnapshotOfEnvironmentA(char **blk)
  74 {
  75   char* environ_strings = GetEnvironmentStringsA();
  76   int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
  77   char *ptr;
  78
  79   for (ptr = environ_strings; *ptr; ptr += strlen(ptr) + 1)
  80   {
  81     /* Don't count environment variables starting with '=' which are command shell specific */
  82     if (*ptr != '=') count++;
  83     len += strlen(ptr) + 1;
  84   }
  85   if (blk)
  86       blk = HeapReAlloc( GetProcessHeap(), 0, blk, count* sizeof(char*) + len );
  87   else
  88     blk = HeapAlloc(GetProcessHeap(), 0, count* sizeof(char*) + len );
  89
  90   if (blk)
  91     {
  92       if (count)
  93         {
  94           memcpy(&blk[count],environ_strings,len);
  95           for (ptr = (char*) &blk[count]; *ptr; ptr += strlen(ptr) + 1)
  96             {
  97               /* Skip special environment strings set by the command shell */
  98               if (*ptr != '=') blk[i++] = ptr;
  99             }
 100         }
 101       blk[i] = NULL;
 102     }
 103   FreeEnvironmentStringsA(environ_strings);
 104   return blk;
 105 }
 106
 107 MSVCRT_wchar_t ** msvcrt_SnapshotOfEnvironmentW(MSVCRT_wchar_t **wblk)
 108 {
 109   MSVCRT_wchar_t* wenviron_strings = GetEnvironmentStringsW();
 110   int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
 111   MSVCRT_wchar_t *wptr;
 112
 113   for (wptr = wenviron_strings; *wptr; wptr += strlenW(wptr) + 1)
 114   {
 115     /* Don't count environment variables starting with '=' which are command shell specific */
 116     if (*wptr != '=') count++;
 117     len += strlenW(wptr) + 1;
 118   }
 119   if (wblk)
 120       wblk = HeapReAlloc( GetProcessHeap(), 0, wblk, count* sizeof(MSVCRT_wchar_t*) + len * sizeof(MSVCRT_wchar_t));
 121   else
 122     wblk = HeapAlloc(GetProcessHeap(), 0, count* sizeof(MSVCRT_wchar_t*) + len * sizeof(MSVCRT_wchar_t));
 123   if (wblk)
 124     {
 125       if (count)
 126         {
 127           memcpy(&wblk[count],wenviron_strings,len * sizeof(MSVCRT_wchar_t));
 128           for (wptr = (MSVCRT_wchar_t*)&wblk[count]; *wptr; wptr += strlenW(wptr) + 1)
 129             {
 130               /* Skip special environment strings set by the command shell */
 131               if (*wptr != '=') wblk[i++] = wptr;
 132             }
 133         }
 134       wblk[i] = NULL;
 135     }
 136   FreeEnvironmentStringsW(wenviron_strings);
 137   return wblk;
 138 }
 139
 140 static char **build_argv( WCHAR **wargv )
 141 {
 142     int argc;
 143     char *p, **argv;
 144     DWORD total = 0;
 145
 146     for (argc = 0; wargv[argc]; argc++)
 147         total += WideCharToMultiByte( CP_ACP, 0, wargv[argc], -1, NULL, 0, NULL, NULL );
 148
 149     argv = HeapAlloc( GetProcessHeap(), 0, total + (argc + 1) * sizeof(*argv) );
 150     p = (char *)(argv + argc + 1);
 151     for (argc = 0; wargv[argc]; argc++)
 152     {
 153         DWORD reslen = WideCharToMultiByte( CP_ACP, 0, wargv[argc], -1, p, total, NULL, NULL );
 154         argv[argc] = p;
 155         p += reslen;
 156         total -= reslen;
 157     }
 158     argv[argc] = NULL;
 159     return argv;
 160 }
 161
 162 typedef void (CDECL *_INITTERMFUN)(void);
 163 typedef int (CDECL *_INITTERM_E_FN)(void);
 164
 165 /***********************************************************************
 166  *              __p___argc (MSVCRT.@)
 167  */
 168 int* CDECL MSVCRT___p___argc(void) { return &MSVCRT___argc; }
 169
 170 /***********************************************************************
 171  *              __p__commode (MSVCRT.@)
 172  */
 173 unsigned int* CDECL __p__commode(void) { return &MSVCRT__commode; }
 174
 175
 176 /***********************************************************************
 177  *              __p__pgmptr (MSVCRT.@)
 178  */
 179 char** CDECL MSVCRT___p__pgmptr(void) { return &MSVCRT__pgmptr; }
 180
 181 /***********************************************************************
 182  *              __p__wpgmptr (MSVCRT.@)
 183  */
 184 WCHAR** CDECL MSVCRT___p__wpgmptr(void) { return &MSVCRT__wpgmptr; }
 185
 186 /***********************************************************************
 187  *              _get_pgmptr (MSVCRT.@)
 188  */
 189 int CDECL _get_pgmptr(char** p)
 190 {
 191   if (!MSVCRT_CHECK_PMT(p)) return MSVCRT_EINVAL;
 192
 193   *p = MSVCRT__pgmptr;
 194   return 0;
 195 }
 196
 197 /***********************************************************************
 198  *              _get_wpgmptr (MSVCRT.@)
 199  */
 200 int CDECL _get_wpgmptr(WCHAR** p)
 201 {
 202   if (!MSVCRT_CHECK_PMT(p)) return MSVCRT_EINVAL;
 203   *p = MSVCRT__wpgmptr;
 204   return 0;
 205 }
 206
 207 /***********************************************************************
 208  *              __p__fmode (MSVCRT.@)
 209  */
 210 int* CDECL MSVCRT___p__fmode(void) { return &MSVCRT__fmode; }
 211
 212 /***********************************************************************
 213  *              _set_fmode (MSVCRT.@)
 214  */
 215 int CDECL MSVCRT__set_fmode(int mode)
 216 {
 217     /* TODO: support _O_WTEXT */
 218     if(!MSVCRT_CHECK_PMT(mode==MSVCRT__O_TEXT || mode==MSVCRT__O_BINARY))
 219         return MSVCRT_EINVAL;
 220
 221     MSVCRT__fmode = mode;
 222     return 0;
 223 }
 224
 225 /***********************************************************************
 226  *              _get_fmode (MSVCRT.@)
 227  */
 228 int CDECL MSVCRT__get_fmode(int *mode)
 229 {
 230     if(!MSVCRT_CHECK_PMT(mode))
 231         return MSVCRT_EINVAL;
 232
 233     *mode = MSVCRT__fmode;
 234     return 0;
 235 }
 236
 237 /***********************************************************************
 238  *              __p__osver (MSVCRT.@)
 239  */
 240 unsigned int* CDECL __p__osver(void) { return &MSVCRT__osver; }
 241
 242 /***********************************************************************
 243  *              __p__winmajor (MSVCRT.@)
 244  */
 245 unsigned int* CDECL __p__winmajor(void) { return &MSVCRT__winmajor; }
 246
 247 /***********************************************************************
 248  *              __p__winminor (MSVCRT.@)
 249  */
 250 unsigned int* CDECL __p__winminor(void) { return &MSVCRT__winminor; }
 251
 252 /***********************************************************************
 253  *              __p__winver (MSVCRT.@)
 254  */
 255 unsigned int* CDECL __p__winver(void) { return &MSVCRT__winver; }
 256
 257 /*********************************************************************
 258  *              __p__acmdln (MSVCRT.@)
 259  */
 260 char** CDECL MSVCRT___p__acmdln(void) { return &MSVCRT__acmdln; }
 261
 262 /*********************************************************************
 263  *              __p__wcmdln (MSVCRT.@)
 264  */
 265 MSVCRT_wchar_t** CDECL MSVCRT___p__wcmdln(void) { return &MSVCRT__wcmdln; }
 266
 267 /*********************************************************************
 268  *              __p___argv (MSVCRT.@)
 269  */
 270 char*** CDECL MSVCRT___p___argv(void) { return &MSVCRT___argv; }
 271
 272 /*********************************************************************
 273  *              __p___wargv (MSVCRT.@)
 274  */
 275 MSVCRT_wchar_t*** CDECL MSVCRT___p___wargv(void) { return &MSVCRT___wargv; }
 276
 277 /*********************************************************************
 278  *              __p__environ (MSVCRT.@)
 279  */
 280 char*** CDECL MSVCRT___p__environ(void)
 281 {
 282   return &MSVCRT__environ;
 283 }
 284
 285 /*********************************************************************
 286  *              __p__wenviron (MSVCRT.@)
 287  */
 288 MSVCRT_wchar_t*** CDECL MSVCRT___p__wenviron(void)
 289 {
 290   return &MSVCRT__wenviron;
 291 }
 292
 293 /*********************************************************************
 294  *              __p___initenv (MSVCRT.@)
 295  */
 296 char*** CDECL __p___initenv(void) { return &MSVCRT___initenv; }
 297
 298 /*********************************************************************
 299  *              __p___winitenv (MSVCRT.@)
 300  */
 301 MSVCRT_wchar_t*** CDECL __p___winitenv(void) { return &MSVCRT___winitenv; }
 302
 303 /*********************************************************************
 304  *              _get_osplatform (MSVCRT.@)
 305  */
 306 int CDECL MSVCRT__get_osplatform(int *pValue)
 307 {
 308     if (!MSVCRT_CHECK_PMT(pValue != NULL)) return MSVCRT_EINVAL;
 309     *pValue = MSVCRT__osplatform;
 310     return 0;
 311 }
 312
 313 /* INTERNAL: Create a wide string from an ascii string */
 314 MSVCRT_wchar_t *msvcrt_wstrdupa(const char *str)
 315 {
 316   const unsigned int len = strlen(str) + 1 ;
 317   MSVCRT_wchar_t *wstr = MSVCRT_malloc(len* sizeof (MSVCRT_wchar_t));
 318   if (!wstr)
 319     return NULL;
 320    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,str,len,wstr,len);
 321   return wstr;
 322 }
 323
 324 /*********************************************************************
 325  *              ___unguarded_readlc_active_add_func (MSVCRT.@)
 326  */
 327 unsigned int * CDECL MSVCRT____unguarded_readlc_active_add_func(void)
 328 {
 329   return &MSVCRT___unguarded_readlc_active;
 330 }
 331
 332 /*********************************************************************
 333  *              ___setlc_active_func (MSVCRT.@)
 334  */
 335 unsigned int CDECL MSVCRT____setlc_active_func(void)
 336 {
 337   return MSVCRT___setlc_active;
 338 }
 339
 340 /* INTERNAL: Since we can't rely on Winelib startup code calling w/getmainargs,
 341  * we initialise data values during DLL loading. When called by a native
 342  * program we simply return the data we've already initialised. This also means
 343  * you can call multiple times without leaking
 344  */
 345 void msvcrt_init_args(void)
 346 {
 347   OSVERSIONINFOW osvi;
 348
 349   MSVCRT__acmdln = MSVCRT__strdup( GetCommandLineA() );
 350   MSVCRT__wcmdln = MSVCRT__wcsdup( GetCommandLineW() );
 351   MSVCRT___argc = __wine_main_argc;
 352   MSVCRT___wargv = __wine_main_wargv;
 353   MSVCRT___argv = build_argv( MSVCRT___wargv );
 354
 355   TRACE("got %s, wide = %s argc=%d\n", debugstr_a(MSVCRT__acmdln),
 356         debugstr_w(MSVCRT__wcmdln),MSVCRT___argc);
 357
 358   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
 359   GetVersionExW( &osvi );
 360   MSVCRT__winver     = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
 361   MSVCRT__winmajor   = osvi.dwMajorVersion;
 362   MSVCRT__winminor   = osvi.dwMinorVersion;
 363   MSVCRT__osver      = osvi.dwBuildNumber;
 364   MSVCRT__osplatform = osvi.dwPlatformId;
 365   TRACE( "winver %08x winmajor %08x winminor %08x osver %08x\n",
 366           MSVCRT__winver, MSVCRT__winmajor, MSVCRT__winminor, MSVCRT__osver);
 367 #ifdef _CRTDLL
 368   CRTDLL__baseversion_dll = (GetVersion() >> 16);
 369   CRTDLL__basemajor_dll   = CRTDLL__baseversion_dll >> 8;
 370   CRTDLL__baseminor_dll   = CRTDLL__baseversion_dll & 0xff;
 371 #endif
 372
 373   MSVCRT__HUGE = HUGE_VAL;
 374   MSVCRT___setlc_active = 0;
 375   MSVCRT___unguarded_readlc_active = 0;
 376   MSVCRT__fmode = MSVCRT__O_TEXT;
 377
 378   MSVCRT__environ = msvcrt_SnapshotOfEnvironmentA(NULL);
 379   MSVCRT___initenv = msvcrt_SnapshotOfEnvironmentA(NULL);
 380   MSVCRT___winitenv = msvcrt_SnapshotOfEnvironmentW(NULL);
 381
 382   MSVCRT__pgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
 383   if (MSVCRT__pgmptr)
 384   {
 385     if (!GetModuleFileNameA(0, MSVCRT__pgmptr, MAX_PATH))
 386       MSVCRT__pgmptr[0] = '\0';
 387     else
 388       MSVCRT__pgmptr[MAX_PATH - 1] = '\0';
 389   }
 390
 391   MSVCRT__wpgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
 392   if (MSVCRT__wpgmptr)
 393   {
 394     if (!GetModuleFileNameW(0, MSVCRT__wpgmptr, MAX_PATH))
 395       MSVCRT__wpgmptr[0] = '\0';
 396     else
 397       MSVCRT__wpgmptr[MAX_PATH - 1] = '\0';
 398   }
 399 }
 400
 401 /* INTERNAL: free memory used by args */
 402 void msvcrt_free_args(void)
 403 {
 404   /* FIXME: more things to free */
 405   HeapFree(GetProcessHeap(), 0, MSVCRT___argv);
 406   HeapFree(GetProcessHeap(), 0, MSVCRT___initenv);
 407   HeapFree(GetProcessHeap(), 0, MSVCRT___winitenv);
 408   HeapFree(GetProcessHeap(), 0, MSVCRT__environ);
 409   HeapFree(GetProcessHeap(), 0, MSVCRT__wenviron);
 410   HeapFree(GetProcessHeap(), 0, MSVCRT__pgmptr);
 411   HeapFree(GetProcessHeap(), 0, MSVCRT__wpgmptr);
 412   HeapFree(GetProcessHeap(), 0, wargv_expand);
 413 }
 414
 415 static int build_expanded_wargv(int *argc, MSVCRT_wchar_t **argv)
 416 {
 417     int i, size=0, args_no=0, path_len;
 418     BOOL is_expandable;
 419     HANDLE h;
 420
 421     args_no = 0;
 422     for(i=0; i<__wine_main_argc; i++) {
 423         WIN32_FIND_DATAW data;
 424         int len = 0;
 425
 426         is_expandable = FALSE;
 427         for(path_len = strlenW(__wine_main_wargv[i])-1; path_len>=0; path_len--) {
 428             if(__wine_main_wargv[i][path_len]=='*' || __wine_main_wargv[i][path_len]=='?')
 429                 is_expandable = TRUE;
 430             else if(__wine_main_wargv[i][path_len]=='\\' || __wine_main_wargv[i][path_len]=='/')
 431                 break;
 432         }
 433         path_len++;
 434
 435         if(is_expandable)
 436             h = FindFirstFileW(__wine_main_wargv[i], &data);
 437         else
 438             h = INVALID_HANDLE_VALUE;
 439
 440         if(h != INVALID_HANDLE_VALUE) {
 441             do {
 442                 if(data.cFileName[0]=='.' && (data.cFileName[1]=='\0' ||
 443                             (data.cFileName[1]=='.' && data.cFileName[2]=='\0')))
 444                     continue;
 445
 446                 len = strlenW(data.cFileName)+1;
 447                 if(argv) {
 448                     argv[args_no] = (MSVCRT_wchar_t*)(argv+*argc+1)+size;
 449                     memcpy(argv[args_no], __wine_main_wargv[i], path_len*sizeof(MSVCRT_wchar_t));
 450                     memcpy(argv[args_no]+path_len, data.cFileName, len*sizeof(MSVCRT_wchar_t));
 451                 }
 452                 args_no++;
 453                 size += len+path_len;
 454             }while(FindNextFileW(h, &data));
 455             FindClose(h);
 456         }
 457
 458         if(!len) {
 459             len = strlenW(__wine_main_wargv[i])+1;
 460             if(argv) {
 461                 argv[args_no] = (MSVCRT_wchar_t*)(argv+*argc+1)+size;
 462                 memcpy(argv[args_no], __wine_main_wargv[i], len*sizeof(MSVCRT_wchar_t));
 463             }
 464             args_no++;
 465             size += len;
 466         }
 467     }
 468
 469     if(argv)
 470         argv[args_no] = NULL;
 471     size *= sizeof(MSVCRT_wchar_t);
 472     size += (args_no+1)*sizeof(MSVCRT_wchar_t*);
 473     *argc = args_no;
 474     return size;
 475 }
 476
 477 /*********************************************************************
 478  *              __wgetmainargs (MSVCRT.@)
 479  */
 480 int CDECL __wgetmainargs(int *argc, MSVCRT_wchar_t** *wargv, MSVCRT_wchar_t** *wenvp,
 481                           int expand_wildcards, int *new_mode)
 482 {
 483     TRACE("(%p,%p,%p,%d,%p).\n", argc, wargv, wenvp, expand_wildcards, new_mode);
 484
 485     if (expand_wildcards) {
 486         HeapFree(GetProcessHeap(), 0, wargv_expand);
 487         wargv_expand = HeapAlloc(GetProcessHeap(), 0,
 488                 build_expanded_wargv(&wargc_expand, NULL));
 489         if (wargv_expand) {
 490             build_expanded_wargv(&wargc_expand, wargv_expand);
 491
 492             MSVCRT___argc = wargc_expand;
 493             MSVCRT___wargv = wargv_expand;
 494         }else {
 495             expand_wildcards = 0;
 496         }
 497     }
 498     if (!expand_wildcards) {
 499         MSVCRT___argc = __wine_main_argc;
 500         MSVCRT___wargv = __wine_main_wargv;
 501     }
 502
 503     /* Initialize the _wenviron array if it's not already created. */
 504     if (!MSVCRT__wenviron)
 505         MSVCRT__wenviron = msvcrt_SnapshotOfEnvironmentW(NULL);
 506     *argc = MSVCRT___argc;
 507     *wargv = MSVCRT___wargv;
 508     *wenvp = MSVCRT___winitenv;
 509     if (new_mode)
 510         MSVCRT__set_new_mode( *new_mode );
 511     return 0;
 512 }
 513
 514 /*********************************************************************
 515  *              __getmainargs (MSVCRT.@)
 516  */
 517 int CDECL __getmainargs(int *argc, char** *argv, char** *envp,
 518                          int expand_wildcards, int *new_mode)
 519 {
 520     TRACE("(%p,%p,%p,%d,%p).\n", argc, argv, envp, expand_wildcards, new_mode);
 521
 522     if (expand_wildcards) {
 523         HeapFree(GetProcessHeap(), 0, wargv_expand);
 524         wargv_expand = HeapAlloc(GetProcessHeap(), 0,
 525                 build_expanded_wargv(&wargc_expand, NULL));
 526         if (wargv_expand) {
 527             build_expanded_wargv(&wargc_expand, wargv_expand);
 528
 529             MSVCRT___argc = wargc_expand;
 530             MSVCRT___argv = build_argv( wargv_expand );
 531         }else {
 532             expand_wildcards = 0;
 533         }
 534     }
 535     if (!expand_wildcards) {
 536         MSVCRT___argc = __wine_main_argc;
 537         MSVCRT___argv = build_argv( __wine_main_wargv );
 538     }
 539
 540     *argc = MSVCRT___argc;
 541     *argv = MSVCRT___argv;
 542     *envp = MSVCRT___initenv;
 543
 544     if (new_mode)
 545         MSVCRT__set_new_mode( *new_mode );
 546     return 0;
 547 }
 548
 549 #ifdef _CRTDLL
 550 /*********************************************************************
 551  *                  __GetMainArgs  (CRTDLL.@)
 552  */
 553 void CDECL __GetMainArgs( int *argc, char ***argv, char ***envp, int expand_wildcards )
 554 {
 555     int new_mode = 0;
 556     __getmainargs( argc, argv, envp, expand_wildcards, &new_mode );
 557 }
 558 #endif
 559
 560 /*********************************************************************
 561  *              _initterm (MSVCRT.@)
 562  */
 563 void CDECL _initterm(_INITTERMFUN *start,_INITTERMFUN *end)
 564 {
 565   _INITTERMFUN* current = start;
 566
 567   TRACE("(%p,%p)\n",start,end);
 568   while (current<end)
 569   {
 570     if (*current)
 571     {
 572       TRACE("Call init function %p\n",*current);
 573       (**current)();
 574       TRACE("returned\n");
 575     }
 576     current++;
 577   }
 578 }
 579
 580 /*********************************************************************
 581  *  _initterm_e (MSVCRT.@)
 582  *
 583  * call an array of application initialization functions and report the return value
 584  */
 585 int CDECL _initterm_e(_INITTERM_E_FN *table, _INITTERM_E_FN *end)
 586 {
 587     int res = 0;
 588
 589     TRACE("(%p, %p)\n", table, end);
 590
 591     while (!res && table < end) {
 592         if (*table) {
 593             TRACE("calling %p\n", **table);
 594             res = (**table)();
 595             if (res)
 596                 TRACE("function %p failed: 0x%x\n", *table, res);
 597
 598         }
 599         table++;
 600     }
 601     return res;
 602 }
 603
 604 /*********************************************************************
 605  *              __set_app_type (MSVCRT.@)
 606  */
 607 void CDECL MSVCRT___set_app_type(int app_type)
 608 {
 609   TRACE("(%d) %s application\n", app_type, app_type == 2 ? "Gui" : "Console");
 610   MSVCRT_app_type = app_type;
 611 }
 612
 613 #if _MSVCR_VER>=140
 614
 615 /*********************************************************************
 616  *              _get_initial_narrow_environment (UCRTBASE.@)
 617  */
 618 char** CDECL _get_initial_narrow_environment(void)
 619 {
 620   return MSVCRT___initenv;
 621 }
 622
 623 /*********************************************************************
 624  *              _configure_narrow_argv (UCRTBASE.@)
 625  */
 626 int CDECL _configure_narrow_argv(int mode)
 627 {
 628   TRACE("(%d)\n", mode);
 629   return 0;
 630 }
 631
 632 /*********************************************************************
 633  *              _initialize_narrow_environment (UCRTBASE.@)
 634  */
 635 int CDECL _initialize_narrow_environment(void)
 636 {
 637   TRACE("\n");
 638   return 0;
 639 }
 640
 641 /*********************************************************************
 642  *              _get_initial_wide_environment (UCRTBASE.@)
 643  */
 644 MSVCRT_wchar_t** CDECL _get_initial_wide_environment(void)
 645 {
 646   return MSVCRT___winitenv;
 647 }
 648
 649 /*********************************************************************
 650  *              _configure_wide_argv (UCRTBASE.@)
 651  */
 652 int CDECL _configure_wide_argv(int mode)
 653 {
 654   FIXME("(%d) stub\n", mode);
 655   return 0;
 656 }
 657
 658 /*********************************************************************
 659  *              _initialize_wide_environment (UCRTBASE.@)
 660  */
 661 int CDECL _initialize_wide_environment(void)
 662 {
 663   FIXME("stub\n");
 664   return 0;
 665 }
 666
 667 /*********************************************************************
 668  *              _get_narrow_winmain_command_line (UCRTBASE.@)
 669  */
 670 char* CDECL _get_narrow_winmain_command_line(void)
 671 {
 672   static char *narrow_command_line;
 673   char *s;
 674
 675   if (narrow_command_line)
 676       return narrow_command_line;
 677
 678   s = GetCommandLineA();
 679   while (*s && *s != ' ' && *s != '\t')
 680   {
 681       if (*s++ == '"')
 682       {
 683           while (*s && *s++ != '"')
 684               ;
 685       }
 686   }
 687
 688   while (*s == ' ' || *s == '\t')
 689       s++;
 690
 691   return narrow_command_line = s;
 692 }
 693
 694 /*********************************************************************
 695  *              _get_wide_winmain_command_line (UCRTBASE.@)
 696  */
 697 MSVCRT_wchar_t* CDECL _get_wide_winmain_command_line(void)
 698 {
 699   static MSVCRT_wchar_t *wide_command_line;
 700   MSVCRT_wchar_t *s;
 701
 702   if (wide_command_line)
 703       return wide_command_line;
 704
 705   s = GetCommandLineW();
 706   while (*s && *s != ' ' && *s != '\t')
 707   {
 708       if (*s++ == '"')
 709       {
 710           while (*s && *s++ != '"')
 711               ;
 712       }
 713   }
 714
 715   while (*s == ' ' || *s == '\t')
 716       s++;
 717
 718   return wide_command_line = s;
 719 }
 720
 721 #endif /* _MSVCR_VER>=140 */
 722
 723 /*********************************************************************
 724  *    _get_winmajor (MSVCRT.@)
 725  */
 726 int CDECL MSVCRT__get_winmajor(int* value)
 727 {
 728     if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
 729     *value = MSVCRT__winmajor;
 730     return 0;
 731 }
 732
 733 /*********************************************************************
 734  *    _get_winminor (MSVCRT.@)
 735  */
 736 int CDECL MSVCRT__get_winminor(int* value)
 737 {
 738     if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
 739     *value = MSVCRT__winminor;
 740     return 0;
 741 }
 742
 743 /*********************************************************************
 744  *    _get_osver (MSVCRT.@)
 745  */
 746 int CDECL MSVCRT__get_osver(int* value)
 747 {
 748     if (!MSVCRT_CHECK_PMT(value != NULL)) return MSVCRT_EINVAL;
 749     *value = MSVCRT__osver;
 750     return 0;
 751 }