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