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