2 * msvcrt.dll dll data items
4 * Copyright 2000 Jon Griffiths
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.
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.
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
24 #include "wine/debug.h"
26 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt
);
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;
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;
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
;
62 /* Get a snapshot of the current environment
63 * and construct the __p__environ array
65 * The pointer returned from GetEnvironmentStrings may get invalid when
66 * some other module cause a reallocation of the env-variable block
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
71 char ** msvcrt_SnapshotOfEnvironmentA(char **blk
)
73 char* environ_strings
= GetEnvironmentStringsA();
74 int count
= 1, len
= 1, i
= 0; /* keep space for the trailing NULLS */
77 for (ptr
= environ_strings
; *ptr
; ptr
+= strlen(ptr
) + 1)
79 /* Don't count environment variables starting with '=' which are command shell specific */
80 if (*ptr
!= '=') count
++;
81 len
+= strlen(ptr
) + 1;
84 blk
= HeapReAlloc( GetProcessHeap(), 0, blk
, count
* sizeof(char*) + len
);
86 blk
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(char*) + len
);
92 memcpy(&blk
[count
],environ_strings
,len
);
93 for (ptr
= (char*) &blk
[count
]; *ptr
; ptr
+= strlen(ptr
) + 1)
95 /* Skip special environment strings set by the command shell */
96 if (*ptr
!= '=') blk
[i
++] = ptr
;
101 FreeEnvironmentStringsA(environ_strings
);
105 wchar_t ** msvcrt_SnapshotOfEnvironmentW(wchar_t **wblk
)
107 wchar_t* wenviron_strings
= GetEnvironmentStringsW();
108 int count
= 1, len
= 1, i
= 0; /* keep space for the trailing NULLS */
111 for (wptr
= wenviron_strings
; *wptr
; wptr
+= MSVCRT_wcslen(wptr
) + 1)
113 /* Don't count environment variables starting with '=' which are command shell specific */
114 if (*wptr
!= '=') count
++;
115 len
+= MSVCRT_wcslen(wptr
) + 1;
118 wblk
= HeapReAlloc( GetProcessHeap(), 0, wblk
, count
* sizeof(wchar_t*) + len
* sizeof(wchar_t));
120 wblk
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(wchar_t*) + len
* sizeof(wchar_t));
125 memcpy(&wblk
[count
],wenviron_strings
,len
* sizeof(wchar_t));
126 for (wptr
= (wchar_t*)&wblk
[count
]; *wptr
; wptr
+= MSVCRT_wcslen(wptr
) + 1)
128 /* Skip special environment strings set by the command shell */
129 if (*wptr
!= '=') wblk
[i
++] = wptr
;
134 FreeEnvironmentStringsW(wenviron_strings
);
138 static char **build_argv( WCHAR
**wargv
)
144 for (argc
= 0; wargv
[argc
]; argc
++)
145 total
+= WideCharToMultiByte( CP_ACP
, 0, wargv
[argc
], -1, NULL
, 0, NULL
, NULL
);
147 argv
= HeapAlloc( GetProcessHeap(), 0, total
+ (argc
+ 1) * sizeof(*argv
) );
148 p
= (char *)(argv
+ argc
+ 1);
149 for (argc
= 0; wargv
[argc
]; argc
++)
151 DWORD reslen
= WideCharToMultiByte( CP_ACP
, 0, wargv
[argc
], -1, p
, total
, NULL
, NULL
);
160 static WCHAR
**cmdline_to_argv( const WCHAR
*src
, int *ret_argc
)
162 WCHAR
**argv
, *arg
, *dst
;
163 int argc
, in_quotes
= 0, bcount
= 0, len
= MSVCRT_wcslen(src
) + 1;
166 argv
= HeapAlloc( GetProcessHeap(), 0, argc
* sizeof(*argv
) + len
* sizeof(WCHAR
) );
167 arg
= dst
= (WCHAR
*)(argv
+ argc
);
171 if ((*src
== ' ' || *src
== '\t') && !in_quotes
)
173 /* skip the remaining spaces */
174 while (*src
== ' ' || *src
== '\t') src
++;
176 /* close the argument and copy it */
179 /* start with a new argument */
183 else if (*src
== '\\')
188 else if (*src
== '"')
190 if ((bcount
& 1) == 0)
192 /* Preceded by an even number of '\', this is half that
193 * number of '\', plus a '"' which we discard.
197 if (in_quotes
&& *src
== '"') *dst
++ = *src
++;
198 else in_quotes
= !in_quotes
;
202 /* Preceded by an odd number of '\', this is half that
203 * number of '\' followed by a '"'
205 dst
-= bcount
/ 2 + 1;
210 else /* a regular character */
223 typedef void (CDECL
*_INITTERMFUN
)(void);
224 typedef int (CDECL
*_INITTERM_E_FN
)(void);
226 /***********************************************************************
227 * __p___argc (MSVCRT.@)
229 int* CDECL
MSVCRT___p___argc(void) { return &MSVCRT___argc
; }
231 /***********************************************************************
232 * __p__commode (MSVCRT.@)
234 unsigned int* CDECL
__p__commode(void) { return &MSVCRT__commode
; }
237 /***********************************************************************
238 * __p__pgmptr (MSVCRT.@)
240 char** CDECL
MSVCRT___p__pgmptr(void) { return &MSVCRT__pgmptr
; }
242 /***********************************************************************
243 * __p__wpgmptr (MSVCRT.@)
245 WCHAR
** CDECL
MSVCRT___p__wpgmptr(void) { return &MSVCRT__wpgmptr
; }
247 /***********************************************************************
248 * _get_pgmptr (MSVCRT.@)
250 int CDECL
_get_pgmptr(char** p
)
252 if (!MSVCRT_CHECK_PMT(p
)) return MSVCRT_EINVAL
;
258 /***********************************************************************
259 * _get_wpgmptr (MSVCRT.@)
261 int CDECL
_get_wpgmptr(WCHAR
** p
)
263 if (!MSVCRT_CHECK_PMT(p
)) return MSVCRT_EINVAL
;
264 *p
= MSVCRT__wpgmptr
;
268 /***********************************************************************
269 * __p__fmode (MSVCRT.@)
271 int* CDECL
MSVCRT___p__fmode(void) { return &MSVCRT__fmode
; }
273 /***********************************************************************
274 * _set_fmode (MSVCRT.@)
276 int CDECL
MSVCRT__set_fmode(int mode
)
278 /* TODO: support _O_WTEXT */
279 if(!MSVCRT_CHECK_PMT(mode
==MSVCRT__O_TEXT
|| mode
==MSVCRT__O_BINARY
))
280 return MSVCRT_EINVAL
;
282 MSVCRT__fmode
= mode
;
286 /***********************************************************************
287 * _get_fmode (MSVCRT.@)
289 int CDECL
MSVCRT__get_fmode(int *mode
)
291 if(!MSVCRT_CHECK_PMT(mode
))
292 return MSVCRT_EINVAL
;
294 *mode
= MSVCRT__fmode
;
298 /***********************************************************************
299 * __p__osver (MSVCRT.@)
301 unsigned int* CDECL
__p__osver(void) { return &MSVCRT__osver
; }
303 /***********************************************************************
304 * __p__winmajor (MSVCRT.@)
306 unsigned int* CDECL
__p__winmajor(void) { return &MSVCRT__winmajor
; }
308 /***********************************************************************
309 * __p__winminor (MSVCRT.@)
311 unsigned int* CDECL
__p__winminor(void) { return &MSVCRT__winminor
; }
313 /***********************************************************************
314 * __p__winver (MSVCRT.@)
316 unsigned int* CDECL
__p__winver(void) { return &MSVCRT__winver
; }
318 /*********************************************************************
319 * __p__acmdln (MSVCRT.@)
321 char** CDECL
MSVCRT___p__acmdln(void) { return &MSVCRT__acmdln
; }
323 /*********************************************************************
324 * __p__wcmdln (MSVCRT.@)
326 wchar_t** CDECL
MSVCRT___p__wcmdln(void) { return &MSVCRT__wcmdln
; }
328 /*********************************************************************
329 * __p___argv (MSVCRT.@)
331 char*** CDECL
MSVCRT___p___argv(void) { return &MSVCRT___argv
; }
333 /*********************************************************************
334 * __p___wargv (MSVCRT.@)
336 wchar_t*** CDECL
MSVCRT___p___wargv(void) { return &MSVCRT___wargv
; }
338 /*********************************************************************
339 * __p__environ (MSVCRT.@)
341 char*** CDECL
MSVCRT___p__environ(void)
343 return &MSVCRT__environ
;
346 /*********************************************************************
347 * __p__wenviron (MSVCRT.@)
349 wchar_t*** CDECL
MSVCRT___p__wenviron(void)
351 return &MSVCRT__wenviron
;
354 /*********************************************************************
355 * __p___initenv (MSVCRT.@)
357 char*** CDECL
__p___initenv(void) { return &MSVCRT___initenv
; }
359 /*********************************************************************
360 * __p___winitenv (MSVCRT.@)
362 wchar_t*** CDECL
__p___winitenv(void) { return &MSVCRT___winitenv
; }
364 /*********************************************************************
365 * _get_osplatform (MSVCRT.@)
367 int CDECL
MSVCRT__get_osplatform(int *pValue
)
369 if (!MSVCRT_CHECK_PMT(pValue
!= NULL
)) return MSVCRT_EINVAL
;
370 *pValue
= MSVCRT__osplatform
;
374 /* INTERNAL: Create a wide string from an ascii string */
375 wchar_t *msvcrt_wstrdupa(const char *str
)
377 const unsigned int len
= strlen(str
) + 1 ;
378 wchar_t *wstr
= MSVCRT_malloc(len
* sizeof (wchar_t));
381 MultiByteToWideChar(CP_ACP
, MB_PRECOMPOSED
,str
,len
,wstr
,len
);
385 /*********************************************************************
386 * ___unguarded_readlc_active_add_func (MSVCRT.@)
388 unsigned int * CDECL
MSVCRT____unguarded_readlc_active_add_func(void)
390 return &MSVCRT___unguarded_readlc_active
;
393 /*********************************************************************
394 * ___setlc_active_func (MSVCRT.@)
396 unsigned int CDECL
MSVCRT____setlc_active_func(void)
398 return MSVCRT___setlc_active
;
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
406 void msvcrt_init_args(void)
410 MSVCRT__acmdln
= MSVCRT__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
);
417 TRACE("got %s, wide = %s argc=%d\n", debugstr_a(MSVCRT__acmdln
),
418 debugstr_w(MSVCRT__wcmdln
),MSVCRT___argc
);
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
);
430 CRTDLL__baseversion_dll
= (GetVersion() >> 16);
431 CRTDLL__basemajor_dll
= CRTDLL__baseversion_dll
>> 8;
432 CRTDLL__baseminor_dll
= CRTDLL__baseversion_dll
& 0xff;
435 MSVCRT__HUGE
= HUGE_VAL
;
436 MSVCRT___setlc_active
= 0;
437 MSVCRT___unguarded_readlc_active
= 0;
438 MSVCRT__fmode
= MSVCRT__O_TEXT
;
440 MSVCRT__environ
= msvcrt_SnapshotOfEnvironmentA(NULL
);
441 MSVCRT___initenv
= msvcrt_SnapshotOfEnvironmentA(NULL
);
442 MSVCRT___winitenv
= msvcrt_SnapshotOfEnvironmentW(NULL
);
444 MSVCRT__pgmptr
= HeapAlloc(GetProcessHeap(), 0, MAX_PATH
);
447 if (!GetModuleFileNameA(0, MSVCRT__pgmptr
, MAX_PATH
))
448 MSVCRT__pgmptr
[0] = '\0';
450 MSVCRT__pgmptr
[MAX_PATH
- 1] = '\0';
453 MSVCRT__wpgmptr
= HeapAlloc(GetProcessHeap(), 0, MAX_PATH
* sizeof(WCHAR
));
456 if (!GetModuleFileNameW(0, MSVCRT__wpgmptr
, MAX_PATH
))
457 MSVCRT__wpgmptr
[0] = '\0';
459 MSVCRT__wpgmptr
[MAX_PATH
- 1] = '\0';
463 /* INTERNAL: free memory used by args */
464 void msvcrt_free_args(void)
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
);
477 static int build_expanded_wargv(int *argc
, wchar_t **argv
)
479 int i
, size
=0, args_no
=0, path_len
;
484 for(i
=0; i
< initial_argc
; i
++) {
485 WIN32_FIND_DATAW data
;
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
]=='/')
498 h
= FindFirstFileW(initial_wargv
[i
], &data
);
500 h
= INVALID_HANDLE_VALUE
;
502 if(h
!= INVALID_HANDLE_VALUE
) {
504 if(data
.cFileName
[0]=='.' && (data
.cFileName
[1]=='\0' ||
505 (data
.cFileName
[1]=='.' && data
.cFileName
[2]=='\0')))
508 len
= MSVCRT_wcslen(data
.cFileName
)+1;
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));
515 size
+= len
+path_len
;
516 }while(FindNextFileW(h
, &data
));
521 len
= MSVCRT_wcslen(initial_wargv
[i
])+1;
523 argv
[args_no
] = (wchar_t*)(argv
+*argc
+1)+size
;
524 memcpy(argv
[args_no
], initial_wargv
[i
], len
*sizeof(wchar_t));
532 argv
[args_no
] = NULL
;
533 size
*= sizeof(wchar_t);
534 size
+= (args_no
+1)*sizeof(wchar_t*);
539 /*********************************************************************
540 * __wgetmainargs (MSVCRT.@)
542 int CDECL
__wgetmainargs(int *argc
, wchar_t** *wargv
, wchar_t** *wenvp
,
543 int expand_wildcards
, int *new_mode
)
545 TRACE("(%p,%p,%p,%d,%p).\n", argc
, wargv
, wenvp
, expand_wildcards
, new_mode
);
547 if (expand_wildcards
) {
548 HeapFree(GetProcessHeap(), 0, wargv_expand
);
549 wargv_expand
= HeapAlloc(GetProcessHeap(), 0,
550 build_expanded_wargv(&wargc_expand
, NULL
));
552 build_expanded_wargv(&wargc_expand
, wargv_expand
);
554 MSVCRT___argc
= wargc_expand
;
555 MSVCRT___wargv
= wargv_expand
;
557 expand_wildcards
= 0;
560 if (!expand_wildcards
) {
561 MSVCRT___argc
= initial_argc
;
562 MSVCRT___wargv
= initial_wargv
;
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
;
572 MSVCRT__set_new_mode( *new_mode
);
576 /*********************************************************************
577 * __getmainargs (MSVCRT.@)
579 int CDECL
__getmainargs(int *argc
, char** *argv
, char** *envp
,
580 int expand_wildcards
, int *new_mode
)
582 TRACE("(%p,%p,%p,%d,%p).\n", argc
, argv
, envp
, expand_wildcards
, new_mode
);
584 if (expand_wildcards
) {
585 HeapFree(GetProcessHeap(), 0, wargv_expand
);
586 wargv_expand
= HeapAlloc(GetProcessHeap(), 0,
587 build_expanded_wargv(&wargc_expand
, NULL
));
589 build_expanded_wargv(&wargc_expand
, wargv_expand
);
591 MSVCRT___argc
= wargc_expand
;
592 MSVCRT___argv
= build_argv( wargv_expand
);
594 expand_wildcards
= 0;
597 if (!expand_wildcards
) {
598 MSVCRT___argc
= initial_argc
;
599 MSVCRT___argv
= build_argv( initial_wargv
);
602 *argc
= MSVCRT___argc
;
603 *argv
= MSVCRT___argv
;
604 *envp
= MSVCRT___initenv
;
607 MSVCRT__set_new_mode( *new_mode
);
612 /*********************************************************************
613 * __GetMainArgs (CRTDLL.@)
615 void CDECL
__GetMainArgs( int *argc
, char ***argv
, char ***envp
, int expand_wildcards
)
618 __getmainargs( argc
, argv
, envp
, expand_wildcards
, &new_mode
);
622 /*********************************************************************
623 * _initterm (MSVCRT.@)
625 void CDECL
_initterm(_INITTERMFUN
*start
,_INITTERMFUN
*end
)
627 _INITTERMFUN
* current
= start
;
629 TRACE("(%p,%p)\n",start
,end
);
634 TRACE("Call init function %p\n",*current
);
642 /*********************************************************************
643 * _initterm_e (MSVCRT.@)
645 * call an array of application initialization functions and report the return value
647 int CDECL
_initterm_e(_INITTERM_E_FN
*table
, _INITTERM_E_FN
*end
)
651 TRACE("(%p, %p)\n", table
, end
);
653 while (!res
&& table
< end
) {
655 TRACE("calling %p\n", **table
);
658 TRACE("function %p failed: 0x%x\n", *table
, res
);
666 /*********************************************************************
667 * __set_app_type (MSVCRT.@)
669 void CDECL
MSVCRT___set_app_type(int app_type
)
671 TRACE("(%d) %s application\n", app_type
, app_type
== 2 ? "Gui" : "Console");
672 MSVCRT_app_type
= app_type
;
677 /*********************************************************************
678 * _get_initial_narrow_environment (UCRTBASE.@)
680 char** CDECL
_get_initial_narrow_environment(void)
682 return MSVCRT___initenv
;
685 /*********************************************************************
686 * _configure_narrow_argv (UCRTBASE.@)
688 int CDECL
_configure_narrow_argv(int mode
)
690 TRACE("(%d)\n", mode
);
694 /*********************************************************************
695 * _initialize_narrow_environment (UCRTBASE.@)
697 int CDECL
_initialize_narrow_environment(void)
703 /*********************************************************************
704 * _get_initial_wide_environment (UCRTBASE.@)
706 wchar_t** CDECL
_get_initial_wide_environment(void)
708 return MSVCRT___winitenv
;
711 /*********************************************************************
712 * _configure_wide_argv (UCRTBASE.@)
714 int CDECL
_configure_wide_argv(int mode
)
716 WARN("(%d) stub\n", mode
);
720 /*********************************************************************
721 * _initialize_wide_environment (UCRTBASE.@)
723 int CDECL
_initialize_wide_environment(void)
729 /*********************************************************************
730 * _get_narrow_winmain_command_line (UCRTBASE.@)
732 char* CDECL
_get_narrow_winmain_command_line(void)
734 static char *narrow_command_line
;
737 if (narrow_command_line
)
738 return narrow_command_line
;
740 s
= GetCommandLineA();
741 while (*s
&& *s
!= ' ' && *s
!= '\t')
745 while (*s
&& *s
++ != '"')
750 while (*s
== ' ' || *s
== '\t')
753 return narrow_command_line
= s
;
756 /*********************************************************************
757 * _get_wide_winmain_command_line (UCRTBASE.@)
759 wchar_t* CDECL
_get_wide_winmain_command_line(void)
761 static wchar_t *wide_command_line
;
764 if (wide_command_line
)
765 return wide_command_line
;
767 s
= GetCommandLineW();
768 while (*s
&& *s
!= ' ' && *s
!= '\t')
772 while (*s
&& *s
++ != '"')
777 while (*s
== ' ' || *s
== '\t')
780 return wide_command_line
= s
;
783 #endif /* _MSVCR_VER>=140 */
785 /*********************************************************************
786 * _get_winmajor (MSVCRT.@)
788 int CDECL
MSVCRT__get_winmajor(int* value
)
790 if (!MSVCRT_CHECK_PMT(value
!= NULL
)) return MSVCRT_EINVAL
;
791 *value
= MSVCRT__winmajor
;
795 /*********************************************************************
796 * _get_winminor (MSVCRT.@)
798 int CDECL
MSVCRT__get_winminor(int* value
)
800 if (!MSVCRT_CHECK_PMT(value
!= NULL
)) return MSVCRT_EINVAL
;
801 *value
= MSVCRT__winminor
;
805 /*********************************************************************
806 * _get_osver (MSVCRT.@)
808 int CDECL
MSVCRT__get_osver(int* value
)
810 if (!MSVCRT_CHECK_PMT(value
!= NULL
)) return MSVCRT_EINVAL
;
811 *value
= MSVCRT__osver
;