#include <errno.h>
#include <locale.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"

Include dependency graph for msvcrt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MSVCRT__LDOUBLE

struct	__lc_time_data

struct	threadmbcinfostruct

struct	_frame_info

struct	cxx_frame_info

struct	__thread_data

struct	fpnum

union	_printf_arg

Macros
#define	MSVCRT__NOBUF _IONBF

#define	_NO_CRT_STDIO_INLINE

#define	DBL80_MAX_10_EXP 4932

#define	DBL80_MIN_10_EXP -4951

#define	LOCALE_FREE 0x1

#define	LOCALE_THREAD 0x2

#define	_RT_STACK 0

#define	_RT_NULLPTR 1

#define	_RT_FLOAT 2

#define	_RT_INTDIV 3

#define	_RT_EXECMEM 5

#define	_RT_EXECFORM 6

#define	_RT_EXECENV 7

#define	_RT_SPACEARG 8

#define	_RT_SPACEENV 9

#define	_RT_ABORT 10

#define	_RT_NPTR 12

#define	_RT_FPTR 13

#define	_RT_BREAK 14

#define	_RT_INT 15

#define	_RT_THREAD 16

#define	_RT_LOCK 17

#define	_RT_HEAP 18

#define	_RT_OPENCON 19

#define	_RT_QWIN 20

#define	_RT_NOMAIN 21

#define	_RT_NONCONT 22

#define	_RT_INVALDISP 23

#define	_RT_ONEXIT 24

#define	_RT_PUREVIRT 25

#define	_RT_STDIOINIT 26

#define	_RT_LOWIOINIT 27

#define	_RT_HEAPINIT 28

#define	_RT_DOMAIN 120

#define	_RT_SING 121

#define	_RT_TLOSS 122

#define	_RT_CRNL 252

#define	_RT_BANNER 255

#define	MSVCRT_NO_CONSOLE_FD (-2)

#define	MSVCRT_NO_CONSOLE ((HANDLE)MSVCRT_NO_CONSOLE_FD)

#define	__acrt_iob_func(idx) (MSVCRT__iob+(idx))

#define	MSVCRT__USERBUF 0x0100

#define	MSVCRT__IOCOMMIT 0x4000

#define	_MAX__TIME64_T (((__time64_t)0x00000007 << 32) \| 0x93406FFF)

#define	MSVCRT_INVALID_PMT(x, err) (*_errno() = (err), _invalid_parameter(NULL, NULL, NULL, 0, 0))

#define	MSVCRT_CHECK_PMT_ERR(x, err) ((x) \|\| (MSVCRT_INVALID_PMT( 0, (err) ), FALSE))

#define	MSVCRT_CHECK_PMT(x) MSVCRT_CHECK_PMT_ERR((x), EINVAL)

#define	UCRTBASE_PRINTF_MASK

#define	MSVCRT_PRINTF_POSITIONAL_PARAMS (0x0100)

#define	MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER (0x0200)

#define	UCRTBASE_SCANF_MASK

#define	COOPERATIVE_TIMEOUT_INFINITE ((unsigned int)-1)

#define	COOPERATIVE_WAIT_TIMEOUT ~0

#define	INHERIT_THREAD_PRIORITY 0xF000

Typedefs
typedef void(__cdecl *	terminate_function) (void)

typedef void(__cdecl *	unexpected_function) (void)

typedef void(__cdecl *	_se_translator_function) (unsigned int code, struct _EXCEPTION_POINTERS *info)

typedef void(__cdecl *	MSVCRT_security_error_handler) (int, void *)

typedef struct __lc_time_data	__lc_time_data

typedef struct threadmbcinfostruct	threadmbcinfo

typedef struct _frame_info	frame_info

typedef struct __thread_data	thread_data_t

typedef void (__cdecl	malloc_func_t) (size_t)

typedef void(__cdecl *	free_func_t) (void *)

typedef int(*	puts_clbk_a) (void , int, const char )

typedef int(*	puts_clbk_w) (void , int, const wchar_t )

typedef union _printf_arg	printf_arg

typedef printf_arg(*	args_clbk) (void , int, int, va_list )

Enumerations
enum	fpmod { FP_ROUND_ZERO , FP_ROUND_DOWN , FP_ROUND_EVEN , FP_ROUND_UP , FP_VAL_INFINITY , FP_VAL_NAN , FP_ROUND_ZERO , FP_ROUND_DOWN , FP_ROUND_EVEN , FP_ROUND_UP , FP_VAL_INFINITY , FP_VAL_NAN , FP_ROUND_ZERO , FP_ROUND_DOWN , FP_ROUND_EVEN , FP_ROUND_UP , FP_VAL_INFINITY , FP_VAL_NAN }

Functions
void __cdecl	terminate (void)

frame_info *__cdecl	_CreateFrameInfo (frame_info fi, void obj)

BOOL __cdecl	__CxxRegisterExceptionObject (EXCEPTION_POINTERS , cxx_frame_info )

void __cdecl	__CxxUnregisterExceptionObject (cxx_frame_info *, BOOL)

void CDECL	__DestructExceptionObject (EXCEPTION_RECORD *)

void **__cdecl	__current_exception (void)

int *__cdecl	__processing_throw (void)

thread_data_t *CDECL	msvcrt_get_thread_data (void)

BOOL	locale_to_sname (const char , unsigned short , BOOL , WCHAR )

void	msvcrt_set_errno (int)

void __cdecl	_purecall (void)

void __cdecl	_amsg_exit (int errnum)

int	env_init (BOOL, BOOL)

wchar_t *	msvcrt_wstrdupa (const char *)

void *__cdecl	operator_new (size_t)

void __cdecl	operator_delete (void *)

int __cdecl	_set_new_mode (int mode)

void	msvcrt_init_mt_locks (void)

void	msvcrt_free_locks (void)

void	msvcrt_init_exception (void *)

BOOL	msvcrt_init_locale (void)

void	msvcrt_init_math (void *)

void	msvcrt_init_io (void)

void	msvcrt_free_io (void)

void	msvcrt_free_console (void)

void	msvcrt_init_args (void)

void	msvcrt_free_args (void)

void	msvcrt_init_signals (void)

void	msvcrt_free_signals (void)

void	msvcrt_free_popen_data (void)

BOOL	msvcrt_init_heap (void)

void	msvcrt_destroy_heap (void)

void	msvcrt_init_clock (void)

BOOL	msvcrt_create_io_inherit_block (WORD , BYTE *)

_locale_t CDECL	get_current_locale_noalloc (_locale_t locale)

void CDECL	free_locale_noalloc (_locale_t locale)

pthreadlocinfo CDECL	get_locinfo (void)

pthreadmbcinfo CDECL	get_mbcinfo (void)

threadmbcinfo *	create_mbcinfo (int, LCID, threadmbcinfo *)

void	free_locinfo (pthreadlocinfo)

void	free_mbcinfo (pthreadmbcinfo)

int __cdecl	__crtLCMapStringA (LCID, DWORD, const char , int, char , int, unsigned int, int)

struct fpnum	fpnum_parse (wchar_t()(void ), void()(void ), void *, pthreadlocinfo, BOOL)

int	fpnum_double (struct fpnum , double )

int	pf_printf_a (puts_clbk_a, void , const char , _locale_t, DWORD, args_clbk, void , va_list )

int	pf_printf_w (puts_clbk_w, void , const wchar_t , _locale_t, DWORD, args_clbk, void , va_list )

int	create_positional_ctx_a (void , const char , va_list)

int	create_positional_ctx_w (void , const wchar_t , va_list)

printf_arg	arg_clbk_valist (void , int, int, va_list )

printf_arg	arg_clbk_positional (void , int, int, va_list )

char *__cdecl	__unDName (char , const char , int, malloc_func_t, free_func_t, unsigned short int)

static UINT	get_aw_cp (void)

static int	convert_acp_utf8_to_wcs (const char str, wchar_t wstr, int len)

static int	convert_wcs_to_acp_utf8 (const wchar_t wstr, char str, int len)

static wchar_t *	wstrdupa_utf8 (const char *str)

static char *	astrdupw_utf8 (const wchar_t *wstr)

Macro Definition Documentation

◆ __acrt_iob_func

#define __acrt_iob_func ( idx ) (MSVCRT__iob+(idx))

Definition at line 332 of file msvcrt.h.

◆ _MAX__TIME64_T

#define _MAX__TIME64_T (((__time64_t)0x00000007 << 32) | 0x93406FFF)

Definition at line 339 of file msvcrt.h.

◆ _NO_CRT_STDIO_INLINE

#define _NO_CRT_STDIO_INLINE

Definition at line 59 of file msvcrt.h.

◆ _RT_ABORT

#define _RT_ABORT 10

Definition at line 303 of file msvcrt.h.

◆ _RT_BANNER

#define _RT_BANNER 255

Definition at line 325 of file msvcrt.h.

◆ _RT_BREAK

#define _RT_BREAK 14

Definition at line 306 of file msvcrt.h.

◆ _RT_CRNL

#define _RT_CRNL 252

Definition at line 324 of file msvcrt.h.

◆ _RT_DOMAIN

#define _RT_DOMAIN 120

Definition at line 321 of file msvcrt.h.

◆ _RT_EXECENV

#define _RT_EXECENV 7

Definition at line 300 of file msvcrt.h.

◆ _RT_EXECFORM

#define _RT_EXECFORM 6

Definition at line 299 of file msvcrt.h.

◆ _RT_EXECMEM

#define _RT_EXECMEM 5

Definition at line 298 of file msvcrt.h.

◆ _RT_FLOAT

#define _RT_FLOAT 2

Definition at line 296 of file msvcrt.h.

◆ _RT_FPTR

#define _RT_FPTR 13

Definition at line 305 of file msvcrt.h.

◆ _RT_HEAP

#define _RT_HEAP 18

Definition at line 310 of file msvcrt.h.

◆ _RT_HEAPINIT

#define _RT_HEAPINIT 28

Definition at line 320 of file msvcrt.h.

◆ _RT_INT

#define _RT_INT 15

Definition at line 307 of file msvcrt.h.

◆ _RT_INTDIV

#define _RT_INTDIV 3

Definition at line 297 of file msvcrt.h.

◆ _RT_INVALDISP

#define _RT_INVALDISP 23

Definition at line 315 of file msvcrt.h.

◆ _RT_LOCK

#define _RT_LOCK 17

Definition at line 309 of file msvcrt.h.

◆ _RT_LOWIOINIT

#define _RT_LOWIOINIT 27

Definition at line 319 of file msvcrt.h.

◆ _RT_NOMAIN

#define _RT_NOMAIN 21

Definition at line 313 of file msvcrt.h.

◆ _RT_NONCONT

#define _RT_NONCONT 22

Definition at line 314 of file msvcrt.h.

◆ _RT_NPTR

#define _RT_NPTR 12

Definition at line 304 of file msvcrt.h.

◆ _RT_NULLPTR

#define _RT_NULLPTR 1

Definition at line 295 of file msvcrt.h.

◆ _RT_ONEXIT

#define _RT_ONEXIT 24

Definition at line 316 of file msvcrt.h.

◆ _RT_OPENCON

#define _RT_OPENCON 19

Definition at line 311 of file msvcrt.h.

◆ _RT_PUREVIRT

#define _RT_PUREVIRT 25

Definition at line 317 of file msvcrt.h.

◆ _RT_QWIN

#define _RT_QWIN 20

Definition at line 312 of file msvcrt.h.

◆ _RT_SING

#define _RT_SING 121

Definition at line 322 of file msvcrt.h.

◆ _RT_SPACEARG

#define _RT_SPACEARG 8

Definition at line 301 of file msvcrt.h.

◆ _RT_SPACEENV

#define _RT_SPACEENV 9

Definition at line 302 of file msvcrt.h.

◆ _RT_STACK

#define _RT_STACK 0

Definition at line 294 of file msvcrt.h.

◆ _RT_STDIOINIT

#define _RT_STDIOINIT 26

Definition at line 318 of file msvcrt.h.

◆ _RT_THREAD

#define _RT_THREAD 16

Definition at line 308 of file msvcrt.h.

◆ _RT_TLOSS

#define _RT_TLOSS 122

Definition at line 323 of file msvcrt.h.

◆ COOPERATIVE_TIMEOUT_INFINITE

#define COOPERATIVE_TIMEOUT_INFINITE ((unsigned int)-1)

Definition at line 417 of file msvcrt.h.

◆ COOPERATIVE_WAIT_TIMEOUT

#define COOPERATIVE_WAIT_TIMEOUT ~0

Definition at line 418 of file msvcrt.h.

◆ DBL80_MAX_10_EXP

#define DBL80_MAX_10_EXP 4932

Definition at line 72 of file msvcrt.h.

◆ DBL80_MIN_10_EXP

#define DBL80_MIN_10_EXP -4951

Definition at line 73 of file msvcrt.h.

◆ INHERIT_THREAD_PRIORITY

#define INHERIT_THREAD_PRIORITY 0xF000

Definition at line 420 of file msvcrt.h.

◆ LOCALE_FREE

#define LOCALE_FREE 0x1

Definition at line 172 of file msvcrt.h.

◆ LOCALE_THREAD

#define LOCALE_THREAD 0x2

Definition at line 173 of file msvcrt.h.

◆ MSVCRT__IOCOMMIT

#define MSVCRT__IOCOMMIT 0x4000

Definition at line 337 of file msvcrt.h.

◆ MSVCRT__NOBUF

#define MSVCRT__NOBUF _IONBF

Definition at line 51 of file msvcrt.h.

◆ MSVCRT__USERBUF

#define MSVCRT__USERBUF 0x0100

Definition at line 336 of file msvcrt.h.

◆ MSVCRT_CHECK_PMT

#define MSVCRT_CHECK_PMT ( x ) MSVCRT_CHECK_PMT_ERR((x), EINVAL)

Definition at line 378 of file msvcrt.h.

◆ MSVCRT_CHECK_PMT_ERR

#define MSVCRT_CHECK_PMT_ERR	(	x,
		err
	)	((x) \|\| (MSVCRT_INVALID_PMT( 0, (err) ), FALSE))

Definition at line 377 of file msvcrt.h.

◆ MSVCRT_INVALID_PMT

#define MSVCRT_INVALID_PMT	(	x,
		err
	)	(*_errno() = (err), _invalid_parameter(NULL, NULL, NULL, 0, 0))

Definition at line 376 of file msvcrt.h.

◆ MSVCRT_NO_CONSOLE

#define MSVCRT_NO_CONSOLE ((HANDLE)MSVCRT_NO_CONSOLE_FD)

Definition at line 328 of file msvcrt.h.

◆ MSVCRT_NO_CONSOLE_FD

#define MSVCRT_NO_CONSOLE_FD (-2)

Definition at line 327 of file msvcrt.h.

◆ MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER

#define MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER (0x0200)

Definition at line 410 of file msvcrt.h.

◆ MSVCRT_PRINTF_POSITIONAL_PARAMS

#define MSVCRT_PRINTF_POSITIONAL_PARAMS (0x0100)

Definition at line 409 of file msvcrt.h.

◆ UCRTBASE_PRINTF_MASK

#define UCRTBASE_PRINTF_MASK

Value:

        ( \
        _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION | \
        _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR | \
        _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS | \
        _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY | \
        _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS | \
        _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING )

Definition at line 401 of file msvcrt.h.

◆ UCRTBASE_SCANF_MASK

#define UCRTBASE_SCANF_MASK

Value:

        ( \
        _CRT_INTERNAL_SCANF_SECURECRT | \
        _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS | \
        _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY )

Definition at line 412 of file msvcrt.h.

Typedef Documentation

◆ __lc_time_data

typedef struct __lc_time_data __lc_time_data

◆ _se_translator_function

typedef void(__cdecl * _se_translator_function) (unsigned int code, struct _EXCEPTION_POINTERS *info)

Definition at line 77 of file msvcrt.h.

◆ args_clbk

typedef printf_arg(* args_clbk) (void *, int, int, va_list *)

Definition at line 389 of file msvcrt.h.

◆ frame_info

typedef struct _frame_info frame_info

◆ free_func_t

typedef void(__cdecl * free_func_t) (void *)

Definition at line 264 of file msvcrt.h.

◆ malloc_func_t

typedef void *(__cdecl * malloc_func_t) (size_t)

Definition at line 263 of file msvcrt.h.

◆ MSVCRT_security_error_handler

typedef void(__cdecl * MSVCRT_security_error_handler) (int, void *)

Definition at line 80 of file msvcrt.h.

◆ printf_arg

typedef union _printf_arg printf_arg

◆ puts_clbk_a

typedef int(* puts_clbk_a) (void *, int, const char *)

Definition at line 380 of file msvcrt.h.

◆ puts_clbk_w

typedef int(* puts_clbk_w) (void *, int, const wchar_t *)

Definition at line 381 of file msvcrt.h.

◆ terminate_function

typedef void(__cdecl * terminate_function) (void)

Definition at line 75 of file msvcrt.h.

◆ thread_data_t

typedef struct __thread_data thread_data_t

Definition at line 224 of file msvcrt.h.

◆ threadmbcinfo

typedef struct threadmbcinfostruct threadmbcinfo

◆ unexpected_function

typedef void(__cdecl * unexpected_function) (void)

Definition at line 76 of file msvcrt.h.

Enumeration Type Documentation

◆ fpmod

enum fpmod

Enumerator
FP_ROUND_ZERO
FP_ROUND_DOWN
FP_ROUND_EVEN
FP_ROUND_UP
FP_VAL_INFINITY
FP_VAL_NAN
FP_ROUND_ZERO
FP_ROUND_DOWN
FP_ROUND_EVEN
FP_ROUND_UP
FP_VAL_INFINITY
FP_VAL_NAN
FP_ROUND_ZERO
FP_ROUND_DOWN
FP_ROUND_EVEN
FP_ROUND_UP
FP_VAL_INFINITY
FP_VAL_NAN

Definition at line 350 of file msvcrt.h.

           {
    FP_ROUND_ZERO, /* only used when dropped part contains only zeros */
    FP_ROUND_DOWN,
    FP_ROUND_EVEN,
    FP_ROUND_UP,
    FP_VAL_INFINITY,
    FP_VAL_NAN
};

Function Documentation

◆ __crtLCMapStringA()

int __cdecl __crtLCMapStringA	(	LCID	lcid,
		DWORD	mapflags,
		const char *	src,
		int	srclen,
		char *	dst,
		int	dstlen,
		unsigned int	codepage,
		int	xflag
	)

Definition at line 877 of file locale.c.

  {
    WCHAR buf_in[32], *in = buf_in;
    WCHAR buf_out[32], *out = buf_out;
    int in_len, out_len, r;
 
    TRACE("(lcid %lx, flags %lx, %s(%d), %p(%d), %x, %d), partial stub!\n",
            lcid, mapflags, src, srclen, dst, dstlen, codepage, xflag);
 
    in_len = MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, src, srclen, NULL, 0);
    if (!in_len) return 0;
    if (in_len > ARRAY_SIZE(buf_in))
    {
        in = malloc(in_len * sizeof(WCHAR));
        if (!in) return 0;
    }
 
    r = MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, src, srclen, in, in_len);
    if (!r) goto done;
 
    if (mapflags & LCMAP_SORTKEY)
    {
        r = LCMapStringW(lcid, mapflags, in, in_len, (WCHAR*)dst, dstlen);
        goto done;
    }
 
    r = LCMapStringW(lcid, mapflags, in, in_len, NULL, 0);
    if (!r) goto done;
    out_len = r;
    if (r > ARRAY_SIZE(buf_out))
    {
        out = malloc(r * sizeof(WCHAR));
        if (!out)
        {
            r = 0;
            goto done;
        }
    }
 
    r = LCMapStringW(lcid, mapflags, in, in_len, out, out_len);
    if (!r) goto done;
 
    r = WideCharToMultiByte(codepage, 0, out, out_len, dst, dstlen, NULL, NULL);
 
done:
    if (in != buf_in) free(in);
    if (out != buf_out) free(out);
    return r;
}

◆ __current_exception()

void **__cdecl __current_exception ( void )

◆ __CxxRegisterExceptionObject()

BOOL __cdecl __CxxRegisterExceptionObject	(	EXCEPTION_POINTERS *	ep,
		cxx_frame_info *	frame_info
	)

Definition at line 968 of file except.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
 
    TRACE("(%p, %p)\n", ep, frame_info);
 
    if (!ep || !ep->ExceptionRecord)
    {
        frame_info->rec = (void*)-1;
        frame_info->context = (void*)-1;
        return TRUE;
    }
 
    frame_info->rec = data->exc_record;
    frame_info->context = data->ctx_record;
    data->exc_record = ep->ExceptionRecord;
    data->ctx_record = ep->ContextRecord;
    _CreateFrameInfo(&frame_info->frame_info, (void*)ep->ExceptionRecord->ExceptionInformation[1]);
    return TRUE;
}

◆ __CxxUnregisterExceptionObject()

void __cdecl __CxxUnregisterExceptionObject	(	cxx_frame_info *	frame_info,
		BOOL	in_use
	)

Definition at line 992 of file except.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
 
    TRACE("(%p)\n", frame_info);
 
    if(frame_info->rec == (void*)-1)
        return;
 
    _FindAndUnlinkFrame(&frame_info->frame_info);
    if(data->exc_record->ExceptionCode == CXX_EXCEPTION && !in_use
            && _IsExceptionObjectToBeDestroyed((void*)data->exc_record->ExceptionInformation[1]))
        __DestructExceptionObject(data->exc_record);
    data->exc_record = frame_info->rec;
    data->ctx_record = frame_info->context;
}

◆ __DestructExceptionObject()

void CDECL __DestructExceptionObject ( EXCEPTION_RECORD * rec )

Definition at line 950 of file except.c.

{
    cxx_exception_type *info = (cxx_exception_type*) rec->ExceptionInformation[2];
    void *object = (void*)rec->ExceptionInformation[1];
 
    TRACE("(%p)\n", rec);
 
    if (!is_cxx_exception( rec )) return;
 
    if (!info || !info->destructor)
        return;
 
    call_dtor( rtti_rva( info->destructor, rec->ExceptionInformation[3] ), object );
}

◆ __processing_throw()

int *__cdecl __processing_throw ( void )

◆ __unDName()

char *__cdecl __unDName	(	char *	buffer,
		const char *	mangled,
		int	buflen,
		malloc_func_t	memget,
		free_func_t	memfree,
		unsigned short int	flags
	)

Definition at line 1783 of file undname.c.

{
    return __unDNameEx(buffer, mangled, buflen, memget, memfree, NULL, flags);
}

Referenced by type_info_name().

◆ _amsg_exit()

void __cdecl _amsg_exit ( int errnum )

Definition at line 233 of file exit.c.

{
  TRACE("(%d)\n", errnum);
 
  if ((MSVCRT_error_mode == _OUT_TO_MSGBOX) ||
     ((MSVCRT_error_mode == _OUT_TO_DEFAULT) && (MSVCRT_app_type == 2)))
  {
    char text[32];
    sprintf(text, "Error: R60%d",errnum);
    DoMessageBox("Runtime error!", text);
  }
  else
    _cprintf("\nruntime error R60%d\n",errnum);
  _aexit_rtn(255);
}

◆ _CreateFrameInfo()

frame_info *__cdecl _CreateFrameInfo	(	frame_info *	fi,
		void *	obj
	)

Definition at line 889 of file except.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
 
    TRACE("(%p, %p)\n", fi, obj);
 
    fi->next = data->frame_info_head;
    data->frame_info_head = fi;
    fi->object = obj;
    return fi;
}

◆ _purecall()

void __cdecl _purecall ( void )

Definition at line 494 of file exit.c.

{
  TRACE("(void)\n");
 
  if(purecall_handler)
      purecall_handler();
  _amsg_exit( 25 );
}

◆ _set_new_mode()

int __cdecl _set_new_mode ( int mode )

Definition at line 227 of file heap.c.

{
  if(!MSVCRT_CHECK_PMT(mode == 0 || mode == 1)) return -1;
  return InterlockedExchange(&MSVCRT_new_mode, mode);
}

◆ arg_clbk_positional()

printf_arg arg_clbk_positional	(	void *	ctx,
		int	pos,
		int	type,
		va_list *	valist
	)

Definition at line 870 of file wcs.c.

{
    printf_arg *args = ctx;
    return args[pos];
}

Referenced by vfprintf_helper(), and vfwprintf_helper().

◆ arg_clbk_valist()

printf_arg arg_clbk_valist	(	void *	ctx,
		int	arg_pos,
		int	type,
		va_list *	valist
	)

Definition at line 847 of file wcs.c.

{
    printf_arg ret;
 
    if(type == VT_I8)
        ret.get_longlong = va_arg(*valist, LONGLONG);
    else if(type == VT_INT)
        ret.get_int = va_arg(*valist, int);
    else if(type == VT_R8)
        ret.get_double = va_arg(*valist, double);
    else if(type == VT_PTR)
        ret.get_ptr = va_arg(*valist, void*);
    else {
        ERR("Incorrect type\n");
        ret.get_int = 0;
    }
 
    return ret;
}

Referenced by _vcprintf(), _vcprintf_l(), _vcwprintf(), _vcwprintf_l(), vfprintf_helper(), and vfwprintf_helper().

◆ astrdupw_utf8()

static char * astrdupw_utf8 ( const wchar_t * wstr )

inlinestatic

Definition at line 452 of file msvcrt.h.

{
    int len = convert_wcs_to_acp_utf8(wstr, NULL, 0);
    char *str;
 
    if (!len) return NULL;
    str = malloc(len * sizeof(char));
    if (!str) return NULL;
    convert_wcs_to_acp_utf8(wstr, str, len);
    return str;
}

Referenced by _fullpath(), _getcwd(), _getdcwd(), and _tempnam().

◆ convert_acp_utf8_to_wcs()

static int convert_acp_utf8_to_wcs	(	const char *	str,
		wchar_t *	wstr,
		int	len
	)

inlinestatic

Definition at line 430 of file msvcrt.h.

{
    return MultiByteToWideChar(get_aw_cp(), MB_PRECOMPOSED, str, -1, wstr, len);
}

Referenced by msvcrt_valisttos_aw(), and wstrdupa_utf8().

◆ convert_wcs_to_acp_utf8()

static int convert_wcs_to_acp_utf8	(	const wchar_t *	wstr,
		char *	str,
		int	len
	)

inlinestatic

Definition at line 435 of file msvcrt.h.

{
    return WideCharToMultiByte(get_aw_cp(), 0, wstr, -1, str, len, NULL, NULL);
}

Referenced by _fullpath(), _getcwd(), _getdcwd(), astrdupw_utf8(), finddata32_wtoa(), finddata64_wtoa(), and finddata64i32_wtoa().

◆ create_mbcinfo()

threadmbcinfo * create_mbcinfo	(	int	cp,
		LCID	lcid,
		threadmbcinfo *	old_mbcinfo
	)

Definition at line 219 of file mbcs.c.

{
  threadmbcinfo *mbcinfo;
  int newcp;
  CPINFO cpi;
  BYTE *bytes;
  WORD chartypes[256];
  char bufA[256];
  WCHAR bufW[256], lowW[256], upW[256];
  int charcount, maxchar;
  int ret;
  int i;
 
  if(old_mbcinfo && cp==old_mbcinfo->mbcodepage
          && (lcid==-1 || lcid==old_mbcinfo->mblcid)) {
    InterlockedIncrement(&old_mbcinfo->refcount);
    return old_mbcinfo;
  }
 
  mbcinfo = malloc(sizeof(threadmbcinfo));
  if(!mbcinfo)
    return NULL;
  mbcinfo->refcount = 1;
 
  switch (cp)
  {
    case _MB_CP_ANSI:
      newcp = GetACP();
      break;
    case _MB_CP_OEM:
      newcp = GetOEMCP();
      break;
    case _MB_CP_LOCALE:
      newcp = get_locinfo()->lc_codepage;
      if(newcp)
          break;
      /* fall through (C locale) */
    case _MB_CP_SBCS:
      newcp = 20127;   /* ASCII */
      break;
    default:
      newcp = cp;
      break;
  }
 
  if(lcid == -1) {
    WCHAR wbuf[LOCALE_NAME_MAX_LENGTH];
    sprintf(bufA, ".%d", newcp);
    mbcinfo->mblcid = locale_to_sname(bufA, NULL, NULL, wbuf) ? LocaleNameToLCID(wbuf, LOCALE_ALLOW_NEUTRAL_NAMES) : -1;
  } else {
    mbcinfo->mblcid = lcid;
  }
 
  if(mbcinfo->mblcid == -1)
  {
    WARN("Can't assign LCID to codepage (%d)\n", mbcinfo->mblcid);
    mbcinfo->mblcid = 0;
  }
 
  if (!GetCPInfo(newcp, &cpi))
  {
    WARN("Codepage %d not found\n", newcp);
    free(mbcinfo);
    return NULL;
  }
 
  /* setup the _mbctype */
  memset(mbcinfo->mbctype, 0, sizeof(unsigned char[257]));
  memset(mbcinfo->mbcasemap, 0, sizeof(unsigned char[256]));
 
  bytes = cpi.LeadByte;
  while (bytes[0] || bytes[1])
  {
    for (i = bytes[0]; i <= bytes[1]; i++)
      mbcinfo->mbctype[i + 1] |= _M1;
    bytes += 2;
  }
 
  if (cpi.MaxCharSize == 2)
  {
    /* trail bytes not available through kernel32 but stored in a structure in msvcrt */
    struct cp_extra_info_t *cpextra = g_cpextrainfo;
 
    mbcinfo->ismbcodepage = 1;
    while (TRUE)
    {
      if (cpextra->cp == 0 || cpextra->cp == newcp)
      {
        if (cpextra->cp == 0)
          FIXME("trail bytes data not available for DBCS codepage %d - assuming all bytes\n", newcp);
 
        bytes = cpextra->TrailBytes;
        while (bytes[0] || bytes[1])
        {
          for (i = bytes[0]; i <= bytes[1]; i++)
            mbcinfo->mbctype[i + 1] |= _M2;
          bytes += 2;
        }
        break;
      }
      cpextra++;
    }
  }
  else
    mbcinfo->ismbcodepage = 0;
 
  maxchar = (newcp == CP_UTF8) ? 128 : 256;
 
  /* we can't use GetStringTypeA directly because we don't have a locale - only a code page
   */
  charcount = 0;
  for (i = 0; i < maxchar; i++)
    if (!(mbcinfo->mbctype[i + 1] & _M1))
      bufA[charcount++] = i;
 
  ret = MultiByteToWideChar(newcp, 0, bufA, charcount, bufW, charcount);
  if (ret != charcount)
  {
    ERR("MultiByteToWideChar of chars failed for cp %d, ret=%d (exp %d), error=%ld\n",
            newcp, ret, charcount, GetLastError());
  }
 
  GetStringTypeW(CT_CTYPE1, bufW, charcount, chartypes);
  LCMapStringW(mbcinfo->mblcid, LCMAP_LOWERCASE, bufW, charcount, lowW, charcount);
  LCMapStringW(mbcinfo->mblcid, LCMAP_UPPERCASE, bufW, charcount, upW, charcount);
 
  charcount = 0;
  for (i = 0; i < maxchar; i++)
    if (!(mbcinfo->mbctype[i + 1] & _M1))
    {
      if (chartypes[charcount] & C1_UPPER)
      {
        mbcinfo->mbctype[i + 1] |= _SBUP;
        bufW[charcount] = lowW[charcount];
      }
      else if (chartypes[charcount] & C1_LOWER)
      {
    mbcinfo->mbctype[i + 1] |= _SBLOW;
        bufW[charcount] = upW[charcount];
      }
      charcount++;
    }
 
  ret = WideCharToMultiByte(newcp, 0, bufW, charcount, bufA, charcount, NULL, NULL);
  if (ret != charcount)
  {
    ERR("WideCharToMultiByte failed for cp %d, ret=%d (exp %d), error=%ld\n",
            newcp, ret, charcount, GetLastError());
  }
 
  charcount = 0;
  for (i = 0; i < maxchar; i++)
  {
    if(!(mbcinfo->mbctype[i + 1] & _M1))
    {
      if(mbcinfo->mbctype[i + 1] & (_SBUP | _SBLOW))
        mbcinfo->mbcasemap[i] = bufA[charcount];
      charcount++;
    }
  }
 
  if (newcp == 932)   /* CP932 only - set _MP and _MS */
  {
    /* On Windows it's possible to calculate the _MP and _MS from CT_CTYPE1
     * and CT_CTYPE3. But as of Wine 0.9.43 we return wrong values what makes
     * it hard. As this is set only for codepage 932 we hardcode it what gives
     * also faster execution.
     */
    for (i = 161; i <= 165; i++)
      mbcinfo->mbctype[i + 1] |= _MP;
    for (i = 166; i <= 223; i++)
      mbcinfo->mbctype[i + 1] |= _MS;
  }
 
  mbcinfo->mbcodepage = newcp;
  return mbcinfo;
}

◆ create_positional_ctx_a()

int create_positional_ctx_a	(	void *	,
		const char *	,
		va_list
	)

Referenced by _vscprintf_p_l(), vfprintf_helper(), and vsprintf_p_l_opt().

◆ create_positional_ctx_w()

int create_positional_ctx_w	(	void *	,
		const wchar_t *	,
		va_list
	)

Referenced by vfwprintf_helper(), and vswprintf_p_l_opt().

◆ env_init()

int env_init	(	BOOL	unicode,
		BOOL	modif
	)

Definition at line 30 of file environ.c.

{
    if (!unicode && !MSVCRT___initenv)
    {
        char *environ_strings = GetEnvironmentStringsA();
        int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
        char *ptr;
 
        for (ptr = environ_strings; *ptr; ptr += strlen(ptr) + 1)
        {
            /* Don't count environment variables starting with '=' which are command shell specific */
            if (*ptr != '=') count++;
            len += strlen(ptr) + 1;
        }
        MSVCRT___initenv = malloc(count * sizeof(*MSVCRT___initenv) + len);
        if (!MSVCRT___initenv)
        {
            FreeEnvironmentStringsA(environ_strings);
            return -1;
        }
 
        memcpy(&MSVCRT___initenv[count], environ_strings, len);
        for (ptr = (char *)&MSVCRT___initenv[count]; *ptr; ptr += strlen(ptr) + 1)
        {
            /* Skip special environment strings set by the command shell */
            if (*ptr != '=') MSVCRT___initenv[i++] = ptr;
        }
        MSVCRT___initenv[i] = NULL;
        FreeEnvironmentStringsA(environ_strings);
 
        MSVCRT__environ = MSVCRT___initenv;
    }
 
    if (!unicode && modif && MSVCRT__environ == MSVCRT___initenv)
    {
        int i = 0;
 
        while(MSVCRT___initenv[i]) i++;
        MSVCRT__environ = malloc((i + 1) * sizeof(char *));
        if (!MSVCRT__environ) return -1;
        for (i = 0; MSVCRT___initenv[i]; i++)
            MSVCRT__environ[i] = strdup(MSVCRT___initenv[i]);
        MSVCRT__environ[i] = NULL;
    }
 
    if (unicode && !MSVCRT___winitenv)
    {
        wchar_t *wenviron_strings = GetEnvironmentStringsW();
        int count = 1, len = 1, i = 0; /* keep space for the trailing NULLS */
        wchar_t *wptr;
 
        for (wptr = wenviron_strings; *wptr; wptr += wcslen(wptr) + 1)
        {
            /* Don't count environment variables starting with '=' which are command shell specific */
            if (*wptr != '=') count++;
            len += wcslen(wptr) + 1;
        }
        MSVCRT___winitenv = malloc(count * sizeof(*MSVCRT___winitenv) + len * sizeof(wchar_t));
        if (!MSVCRT___winitenv)
        {
            FreeEnvironmentStringsW(wenviron_strings);
            return -1;
        }
 
        memcpy(&MSVCRT___winitenv[count], wenviron_strings, len * sizeof(wchar_t));
        for (wptr = (wchar_t *)&MSVCRT___winitenv[count]; *wptr; wptr += wcslen(wptr) + 1)
        {
            /* Skip special environment strings set by the command shell */
            if (*wptr != '=') MSVCRT___winitenv[i++] = wptr;
        }
        MSVCRT___winitenv[i] = NULL;
        FreeEnvironmentStringsW(wenviron_strings);
 
        MSVCRT__wenviron = MSVCRT___winitenv;
    }
 
    if (unicode && modif && MSVCRT__wenviron == MSVCRT___winitenv)
    {
        int i = 0;
 
        while(MSVCRT___winitenv[i]) i++;
        MSVCRT__wenviron = malloc((i + 1) * sizeof(wchar_t *));
        if (!MSVCRT__wenviron) return -1;
        for (i = 0; MSVCRT___winitenv[i]; i++)
            MSVCRT__wenviron[i] = wcsdup(MSVCRT___winitenv[i]);
        MSVCRT__wenviron[i] = NULL;
    }
 
    return 0;
}

Referenced by __wgetmainargs(), env_set(), msvcrt_init_args(), wgetenv_helper(), and wputenv_helper().

◆ fpnum_double()

int fpnum_double	(	struct fpnum *	fp,
		double *	d
	)

Definition at line 365 of file string.c.

{
    ULONGLONG bits = 0;
 
    if (fp->mod == FP_VAL_INFINITY)
    {
        *d = fp->sign * INFINITY;
        return 0;
    }
 
    if (fp->mod == FP_VAL_NAN)
    {
        bits = ~0;
        if (fp->sign == 1)
            bits &= ~((ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1));
        *d = *(double*)&bits;
        return 0;
    }
 
    TRACE("%c %#I64x *2^%d (round %d)\n", fp->sign == -1 ? '-' : '+',
            fp->m, fp->exp, fp->mod);
    if (!fp->m)
    {
        *d = fp->sign * 0.0;
        return 0;
    }
 
    /* make sure that we don't overflow modifying exponent */
    if (fp->exp > 1<<EXP_BITS)
    {
        *d = fp->sign * INFINITY;
        return ERANGE;
    }
    if (fp->exp < -(1<<EXP_BITS))
    {
        *d = fp->sign * 0.0;
        return ERANGE;
    }
    fp->exp += MANT_BITS - 1;
 
    /* normalize mantissa */
    while(fp->m < (ULONGLONG)1 << (MANT_BITS-1))
    {
        fp->m <<= 1;
        fp->exp--;
    }
    while(fp->m >= (ULONGLONG)1 << MANT_BITS)
    {
        if (fp->m & 1 || fp->mod != FP_ROUND_ZERO)
        {
            if (!(fp->m & 1)) fp->mod = FP_ROUND_DOWN;
            else if(fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
            else fp->mod = FP_ROUND_UP;
        }
        fp->m >>= 1;
        fp->exp++;
    }
    fp->exp += (1 << (EXP_BITS-1)) - 1;
 
    /* handle subnormals */
    if (fp->exp <= 0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
    }
    while(fp->m && fp->exp<0)
    {
        if (fp->m & 1 && fp->mod == FP_ROUND_ZERO) fp->mod = FP_ROUND_EVEN;
        else if (fp->m & 1) fp->mod = FP_ROUND_UP;
        else if (fp->mod != FP_ROUND_ZERO) fp->mod = FP_ROUND_DOWN;
        fp->m >>= 1;
        fp->exp++;
    }
 
    /* round mantissa */
    if (fp->mod == FP_ROUND_UP || (fp->mod == FP_ROUND_EVEN && fp->m & 1))
    {
        fp->m++;
 
        /* handle subnormal that falls into regular range due to rounding */
        if (fp->m == (ULONGLONG)1 << (MANT_BITS - 1))
        {
            fp->exp++;
        }
        else if (fp->m >= (ULONGLONG)1 << MANT_BITS)
        {
            fp->exp++;
            fp->m >>= 1;
        }
    }
 
    if (fp->exp >= (1<<EXP_BITS)-1)
    {
        *d = fp->sign * INFINITY;
        return ERANGE;
    }
    if (!fp->m || fp->exp < 0)
    {
        *d = fp->sign * 0.0;
        return ERANGE;
    }
 
    if (fp->sign == -1)
        bits |= (ULONGLONG)1 << (MANT_BITS + EXP_BITS - 1);
    bits |= (ULONGLONG)fp->exp << (MANT_BITS - 1);
    bits |= fp->m & (((ULONGLONG)1 << (MANT_BITS - 1)) - 1);
 
    TRACE("returning %#I64x\n", bits);
    *d = *(double*)&bits;
    return 0;
}

Referenced by _wcstod_l().

◆ fpnum_parse()

struct fpnum fpnum_parse	(	wchar_t()(void )	,
		void()(void )	,
		void *	,
		pthreadlocinfo	,
		BOOL
	)

Referenced by _wcstod_l().

◆ free_locale_noalloc()

void CDECL free_locale_noalloc ( _locale_t locale )

Definition at line 1162 of file locale.c.

{
    free_locinfo(locale->locinfo);
    free_mbcinfo(locale->mbcinfo);
}

◆ free_locinfo()

void free_locinfo ( pthreadlocinfo locinfo )

Definition at line 1061 of file locale.c.

{
    int i;
 
    if(!locinfo)
        return;
 
    for(i=LC_MIN+1; i<=LC_MAX; i++) {
        if(!locinfo->lc_category[i].refcount
                || !InterlockedDecrement((LONG *)locinfo->lc_category[i].refcount)) {
            free(locinfo->lc_category[i].locale);
            free(locinfo->lc_category[i].refcount);
        }
        if(!locinfo->lc_category[i].wrefcount
                || !InterlockedDecrement((LONG *)locinfo->lc_category[i].wrefcount)) {
#if _MSVCR_VER >= 110
            free(locinfo->lc_name[i]);
#endif
            free(locinfo->lc_category[i].wrefcount);
        }
    }
 
    if(locinfo->lconv_num_refcount
            && !InterlockedDecrement((LONG *)locinfo->lconv_num_refcount)) {
        free(locinfo->lconv->decimal_point);
        free(locinfo->lconv->thousands_sep);
        free(locinfo->lconv->grouping);
#if _MSVCR_VER >= 100
        free(locinfo->lconv->_W_decimal_point);
        free(locinfo->lconv->_W_thousands_sep);
#endif
        free(locinfo->lconv_num_refcount);
    }
    if(locinfo->lconv_mon_refcount
            && !InterlockedDecrement((LONG *)locinfo->lconv_mon_refcount)) {
        free(locinfo->lconv->int_curr_symbol);
        free(locinfo->lconv->currency_symbol);
        free(locinfo->lconv->mon_decimal_point);
        free(locinfo->lconv->mon_thousands_sep);
        free(locinfo->lconv->mon_grouping);
        free(locinfo->lconv->positive_sign);
        free(locinfo->lconv->negative_sign);
#if _MSVCR_VER >= 100
        free(locinfo->lconv->_W_int_curr_symbol);
        free(locinfo->lconv->_W_currency_symbol);
        free(locinfo->lconv->_W_mon_decimal_point);
        free(locinfo->lconv->_W_mon_thousands_sep);
        free(locinfo->lconv->_W_positive_sign);
        free(locinfo->lconv->_W_negative_sign);
#endif
        free(locinfo->lconv_mon_refcount);
    }
    if(locinfo->lconv_intl_refcount
            && !InterlockedDecrement((LONG *)locinfo->lconv_intl_refcount)) {
        free(locinfo->lconv_intl_refcount);
        free(locinfo->lconv);
    }
 
    if(locinfo->ctype1_refcount
            && !InterlockedDecrement((LONG *)locinfo->ctype1_refcount)) {
        free(locinfo->ctype1_refcount);
        free(locinfo->ctype1);
        free((void*)locinfo->pclmap);
        free((void*)locinfo->pcumap);
    }
 
    if(locinfo->lc_time_curr && !InterlockedDecrement(&locinfo->lc_time_curr->refcount)
            && locinfo->lc_time_curr != &cloc_time_data)
        free(locinfo->lc_time_curr);
 
    if(InterlockedDecrement((LONG *)&locinfo->refcount))
        return;
 
    free(locinfo);
}

◆ free_mbcinfo()

void free_mbcinfo ( pthreadmbcinfo mbcinfo )

Definition at line 1138 of file locale.c.

{
    if(!mbcinfo)
        return;
 
    if(InterlockedDecrement(&mbcinfo->refcount))
        return;
 
    free(mbcinfo);
}

◆ get_aw_cp()

static UINT get_aw_cp ( void )

inlinestatic

Definition at line 422 of file msvcrt.h.

{
#if _MSVCR_VER>=140
    if (___lc_codepage_func() == CP_UTF8) return CP_UTF8;
#endif
    return CP_ACP;
}

Referenced by convert_acp_utf8_to_wcs(), convert_wcs_to_acp_utf8(), and msvcrt_argvtos_aw().

◆ get_current_locale_noalloc()

_locale_t CDECL get_current_locale_noalloc ( _locale_t locale )

Definition at line 1149 of file locale.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
 
    update_thread_locale(data);
    locale->locinfo = data->locinfo;
    locale->mbcinfo = data->mbcinfo;
 
    grab_locinfo(locale->locinfo);
    InterlockedIncrement(&locale->mbcinfo->refcount);
    return locale;
}

◆ get_locinfo()

pthreadlocinfo CDECL get_locinfo ( void )

Definition at line 635 of file locale.c.

                                       {
    thread_data_t *data = msvcrt_get_thread_data();
    update_thread_locale(data);
    return data->locinfo;
}

◆ get_mbcinfo()

pthreadmbcinfo CDECL get_mbcinfo ( void )

Definition at line 642 of file locale.c.

                                       {
    thread_data_t *data = msvcrt_get_thread_data();
    update_thread_locale(data);
    return data->mbcinfo;
}

◆ locale_to_sname()

BOOL locale_to_sname	(	const char *	locale,
		unsigned short *	codepage,
		BOOL *	sname_match,
		WCHAR *	sname
	)

Definition at line 335 of file locale.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
    const char *cp, *region;
    BOOL is_sname = FALSE;
    DWORD locale_cp;
 
    if (!strcmp(locale, data->cached_locale)) {
        if (codepage)
            *codepage = data->cached_cp;
        if (sname_match)
            *sname_match = data->cached_sname_match;
        wcscpy(sname, data->cached_sname);
        return TRUE;
    }
 
    cp = strchr(locale, '.');
    region = strchr(locale, '_');
 
    if(!locale[0] || (cp == locale && !region)) {
        GetUserDefaultLocaleName(sname, LOCALE_NAME_MAX_LENGTH);
    } else {
        char search_language_buf[MAX_ELEM_LEN] = { 0 }, search_country_buf[MAX_ELEM_LEN] = { 0 };
        locale_search_t search;
        BOOL remapped = FALSE;
 
        memset(&search, 0, sizeof(locale_search_t));
        lstrcpynA(search_language_buf, locale, MAX_ELEM_LEN);
        if(region) {
            lstrcpynA(search_country_buf, region+1, MAX_ELEM_LEN);
            if(region-locale < MAX_ELEM_LEN)
                search_language_buf[region-locale] = '\0';
        } else
            search_country_buf[0] = '\0';
 
        if(cp) {
            if(region && cp-region-1<MAX_ELEM_LEN)
                search_country_buf[cp-region-1] = '\0';
            if(cp-locale < MAX_ELEM_LEN)
                search_language_buf[cp-locale] = '\0';
        }
 
        if ((remapped = remap_synonym(search_language_buf)))
        {
            search.allow_sname = TRUE;
        }
 
#if _MSVCR_VER >= 110
        if(!cp && !region)
        {
            search.allow_sname = TRUE;
        }
#endif
 
        MultiByteToWideChar(CP_ACP, 0, search_language_buf, -1, search.search_language, MAX_ELEM_LEN);
        if (search.allow_sname && IsValidLocaleName(search.search_language))
        {
            search.match_flags = FOUND_SNAME;
            wcscpy(sname, search.search_language);
        }
        else
        {
            MultiByteToWideChar(CP_ACP, 0, search_country_buf, -1, search.search_country, MAX_ELEM_LEN);
            EnumSystemLocalesEx( find_best_locale_proc, 0, (LPARAM)&search, NULL);
 
            if (!search.match_flags)
                return FALSE;
 
            /* If we were given something that didn't match, fail */
            if (search.search_language[0] && !(search.match_flags & (FOUND_SNAME | FOUND_LANGUAGE)))
                return FALSE;
            if (search.search_country[0] && !(search.match_flags & FOUND_COUNTRY))
                return FALSE;
 
            wcscpy(sname, search.found_lang_sname);
        }
 
        is_sname = !remapped && (search.match_flags & FOUND_SNAME) != 0;
    }
 
    /* Obtain code page */
    if (!cp || !cp[1] || !_strnicmp(cp, ".ACP", 4)) {
        GetLocaleInfoEx(sname, LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
                (WCHAR *)&locale_cp, sizeof(DWORD)/sizeof(WCHAR));
        if (!locale_cp)
            locale_cp = GetACP();
    } else if (!_strnicmp(cp, ".OCP", 4)) {
        GetLocaleInfoEx(sname, LOCALE_IDEFAULTCODEPAGE | LOCALE_RETURN_NUMBER,
                (WCHAR *)&locale_cp, sizeof(DWORD)/sizeof(WCHAR));
#if _MSVCR_VER >= 140
    } else if (!_strnicmp(cp, ".UTF-8", 6)
            || !_strnicmp(cp, ".UTF8", 5)) {
        locale_cp = CP_UTF8;
#endif
    } else {
        locale_cp = atoi(cp + 1);
    }
    if (!IsValidCodePage(locale_cp))
        return FALSE;
 
    if (!locale_cp)
        return FALSE;
 
    if (codepage)
        *codepage = locale_cp;
    if (sname_match)
        *sname_match = is_sname;
 
    if (strlen(locale) < sizeof(data->cached_locale)) {
        strcpy(data->cached_locale, locale);
        data->cached_cp = locale_cp;
        data->cached_sname_match = is_sname;
        wcscpy(data->cached_sname, sname);
    }
 
    return TRUE;
}

Referenced by create_locinfo(), and create_mbcinfo().

◆ msvcrt_create_io_inherit_block()

BOOL msvcrt_create_io_inherit_block	(	WORD *	size,
		BYTE **	block
	)

Definition at line 675 of file file.c.

{
  int         fd, last_fd;
  char*       wxflag_ptr;
  HANDLE*     handle_ptr;
  ioinfo*     fdinfo;
 
  for (last_fd=MSVCRT_MAX_FILES-1; last_fd>=0; last_fd--)
    if (get_ioinfo_nolock(last_fd)->handle != INVALID_HANDLE_VALUE)
      break;
  last_fd++;
 
  *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * last_fd;
  *block = calloc(1, *size);
  if (!*block)
  {
    *size = 0;
    return FALSE;
  }
  wxflag_ptr = (char*)*block + sizeof(unsigned);
  handle_ptr = (HANDLE*)(wxflag_ptr + last_fd);
 
  *(unsigned*)*block = last_fd;
  for (fd = 0; fd < last_fd; fd++)
  {
    /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
    fdinfo = get_ioinfo_nolock(fd);
    if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
    {
      *wxflag_ptr = fdinfo->wxflag;
      *handle_ptr = fdinfo->handle;
    }
    else
    {
      *wxflag_ptr = 0;
      *handle_ptr = INVALID_HANDLE_VALUE;
    }
    wxflag_ptr++; handle_ptr++;
  }
  return TRUE;
}

◆ msvcrt_destroy_heap()

void msvcrt_destroy_heap ( void )

Definition at line 840 of file heap.c.

{
#if _MSVCR_VER <= 100 && !defined(__REACTOS__)
    HeapDestroy(heap);
#endif
    if(sb_heap)
        HeapDestroy(sb_heap);
}

◆ msvcrt_free_args()

void msvcrt_free_args ( void )

Definition at line 462 of file data.c.

{
  /* FIXME: more things to free */
  HeapFree(GetProcessHeap(), 0, MSVCRT___argv);
  HeapFree(GetProcessHeap(), 0, MSVCRT__pgmptr);
  HeapFree(GetProcessHeap(), 0, MSVCRT__wpgmptr);
  HeapFree(GetProcessHeap(), 0, wargv_expand);
}

◆ msvcrt_free_console()

void msvcrt_free_console ( void )

Definition at line 68 of file console.c.

{
  TRACE(":Closing console handles\n");
  CloseHandle(MSVCRT_console_in);
  CloseHandle(MSVCRT_console_out);
}

◆ msvcrt_free_io()

void msvcrt_free_io ( void )

Definition at line 1392 of file file.c.

{
    unsigned int i;
    int j;
 
    _flushall();
    _fcloseall();
 
    for(i=0; i<ARRAY_SIZE(MSVCRT___pioinfo); i++)
    {
        if(!MSVCRT___pioinfo[i])
            continue;
 
        for(j=0; j<MSVCRT_FD_BLOCK_SIZE; j++)
        {
            if(ioinfo_is_crit_init(&MSVCRT___pioinfo[i][j]))
                DeleteCriticalSection(&MSVCRT___pioinfo[i][j].crit);
        }
        free(MSVCRT___pioinfo[i]);
    }
 
    for(j=0; j<MSVCRT_stream_idx; j++)
    {
        FILE *file = msvcrt_get_file(j);
        CRITICAL_SECTION *cs = file_get_cs(file);
 
        if(cs)
        {
            cs->DebugInfo->Spare[0] = 0;
            DeleteCriticalSection(cs);
        }
    }
 
    for(i=0; i<ARRAY_SIZE(MSVCRT_fstream); i++)
        free(MSVCRT_fstream[i]);
}

◆ msvcrt_free_locks()

void msvcrt_free_locks ( void )

Definition at line 149 of file lock.c.

{
  int i;
 
  TRACE( ": uninitializing all mtlocks\n" );
 
  /* Uninitialize the table */
  for( i=0; i < _TOTAL_LOCKS; i++ )
  {
    if( lock_table[ i ].bInit )
    {
      msvcrt_uninitialize_mlock( i );
    }
  }
}

◆ msvcrt_free_popen_data()

void msvcrt_free_popen_data ( void )

Definition at line 1034 of file process.c.

{
    free(popen_handles);
}

Referenced by DllMain().

◆ msvcrt_free_signals()

void msvcrt_free_signals ( void )

Definition at line 640 of file except.c.

{
    SetConsoleCtrlHandler(msvcrt_console_handler, FALSE);
}

◆ msvcrt_get_thread_data()

thread_data_t *CDECL msvcrt_get_thread_data ( void )

Definition at line 45 of file thread.c.

{
    thread_data_t *ptr;
    DWORD err = GetLastError();  /* need to preserve last error */
 
    if (!(ptr = TlsGetValue( msvcrt_tls_index )))
    {
        if (!(ptr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ptr) )))
            _amsg_exit( _RT_THREAD );
        if (!TlsSetValue( msvcrt_tls_index, ptr )) _amsg_exit( _RT_THREAD );
        ptr->tid = GetCurrentThreadId();
        ptr->handle = INVALID_HANDLE_VALUE;
        ptr->random_seed = 1;
        ptr->locinfo = MSVCRT_locale->locinfo;
        ptr->mbcinfo = MSVCRT_locale->mbcinfo;
        ptr->cached_locale[0] = 'C';
        ptr->cached_locale[1] = 0;
#if _MSVCR_VER >= 140
        ptr->module = NULL;
#endif
    }
    SetLastError( err );
    return ptr;
}

Referenced by __CxxDetectRethrow(), __CxxExceptionFilter(), __CxxRegisterExceptionObject(), __CxxUnregisterExceptionObject(), __doserrno(), __fpecode(), __pxcptinfoptrs(), __uncaught_exception(), __wcserror(), _configthreadlocale(), _CreateFrameInfo(), _ecvt(), _errno(), _fcvt(), _FindAndUnlinkFrame(), _get_terminate(), _get_unexpected(), _gmtime64(), _invalid_parameter(), _IsExceptionObjectToBeDestroyed(), _localtime64(), _mbstok(), _mbstok_l(), _set_se_translator(), _setmbcp(), _strerror(), _tasctime(), _wasctime(), _wcserror(), _wtmpnam(), asctime(), call_catch_block(), cxx_frame_handler(), find_catch_block(), get_current_locale_noalloc(), get_locinfo(), get_mbcinfo(), locale_to_sname(), rand(), set_terminate(), set_unexpected(), setlocale(), srand(), strerror(), strtok(), terminate(), tmpnam(), unexpected(), and wcstok().

◆ msvcrt_init_args()

void msvcrt_init_args ( void )

Definition at line 404 of file data.c.

{
  OSVERSIONINFOW osvi;
 
  MSVCRT__acmdln = _strdup( GetCommandLineA() );
  MSVCRT__wcmdln = _wcsdup( GetCommandLineW() );
  initial_wargv  = cmdline_to_argv( GetCommandLineW(), &initial_argc );
  MSVCRT___argc  = initial_argc;
  MSVCRT___wargv = initial_wargv;
  MSVCRT___argv  = build_argv( initial_wargv );
 
  TRACE("got %s, wide = %s argc=%d\n", debugstr_a(MSVCRT__acmdln),
        debugstr_w(MSVCRT__wcmdln),MSVCRT___argc);
 
  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
  GetVersionExW( &osvi );
  MSVCRT__winver     = (osvi.dwMajorVersion << 8) | osvi.dwMinorVersion;
  MSVCRT__winmajor   = osvi.dwMajorVersion;
  MSVCRT__winminor   = osvi.dwMinorVersion;
  MSVCRT__osver      = osvi.dwBuildNumber;
  MSVCRT__osplatform = osvi.dwPlatformId;
  TRACE( "winver %08x winmajor %08x winminor %08x osver %08x\n",
          MSVCRT__winver, MSVCRT__winmajor, MSVCRT__winminor, MSVCRT__osver);
#ifdef _CRTDLL
  CRTDLL__baseversion_dll = (GetVersion() >> 16);
  CRTDLL__basemajor_dll   = CRTDLL__baseversion_dll >> 8;
  CRTDLL__baseminor_dll   = CRTDLL__baseversion_dll & 0xff;
#endif
 
  MSVCRT__HUGE = HUGE_VAL;
  MSVCRT___setlc_active = 0;
  MSVCRT___unguarded_readlc_active = 0;
#ifndef __REACTOS__
  MSVCRT__fmode = _O_TEXT;
#endif
 
  env_init(FALSE, FALSE);
 
  MSVCRT__pgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH);
  if (MSVCRT__pgmptr)
  {
    if (!GetModuleFileNameA(0, MSVCRT__pgmptr, MAX_PATH))
      MSVCRT__pgmptr[0] = '\0';
    else
      MSVCRT__pgmptr[MAX_PATH - 1] = '\0';
  }
 
  MSVCRT__wpgmptr = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
  if (MSVCRT__wpgmptr)
  {
    if (!GetModuleFileNameW(0, MSVCRT__wpgmptr, MAX_PATH))
      MSVCRT__wpgmptr[0] = '\0';
    else
      MSVCRT__wpgmptr[MAX_PATH - 1] = '\0';
  }
}

◆ msvcrt_init_clock()

void msvcrt_init_clock ( void )

Definition at line 49 of file time.c.

{
    LARGE_INTEGER systime;
 
    NtQuerySystemTime(&systime);
    init_time = systime.QuadPart;
}

Referenced by DllMain().

◆ msvcrt_init_exception()

void msvcrt_init_exception ( void * )

Referenced by DllMain().

◆ msvcrt_init_heap()

BOOL msvcrt_init_heap ( void )

Definition at line 830 of file heap.c.

{
#if _MSVCR_VER <= 100 && !defined(__REACTOS__)
    heap = HeapCreate(0, 0, 0);
#else
    heap = GetProcessHeap();
#endif
    return heap != NULL;
}

◆ msvcrt_init_io()

void msvcrt_init_io ( void )

Definition at line 720 of file file.c.

{
  STARTUPINFOA  si;
  int           i;
  ioinfo        *fdinfo;
 
  GetStartupInfoA(&si);
  if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
  {
    BYTE*       wxflag_ptr;
    HANDLE*     handle_ptr;
    unsigned int count;
 
    count = *(unsigned*)si.lpReserved2;
    wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
    handle_ptr = (HANDLE*)(wxflag_ptr + count);
 
    count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
    count = min(count, MSVCRT_MAX_FILES);
    for (i = 0; i < count; i++)
    {
      if ((*wxflag_ptr & WX_OPEN) && GetFileType(*handle_ptr) != FILE_TYPE_UNKNOWN)
      {
        fdinfo = get_ioinfo_alloc_fd(i);
        if(fdinfo != &MSVCRT___badioinfo)
            msvcrt_set_fd(fdinfo, *handle_ptr, *wxflag_ptr);
        release_ioinfo(fdinfo);
      }
 
      wxflag_ptr++; handle_ptr++;
    }
  }
 
  fdinfo = get_ioinfo_alloc_fd(STDIN_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  fdinfo = get_ioinfo_alloc_fd(STDOUT_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  fdinfo = get_ioinfo_alloc_fd(STDERR_FILENO);
  if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
    HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
    DWORD flags = WX_OPEN | WX_TEXT;
    DWORD type = GetFileType(h);
 
    if (type == FILE_TYPE_UNKNOWN) {
        h = MSVCRT_NO_CONSOLE;
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_CHAR) {
        flags |= WX_TTY;
    } else if ((type & 0xf) == FILE_TYPE_PIPE) {
        flags |= WX_PIPE;
    }
 
    msvcrt_set_fd(fdinfo, h, flags);
  }
  release_ioinfo(fdinfo);
 
  TRACE(":handles (%p)(%p)(%p)\n", get_ioinfo_nolock(STDIN_FILENO)->handle,
        get_ioinfo_nolock(STDOUT_FILENO)->handle,
        get_ioinfo_nolock(STDERR_FILENO)->handle);
 
  for (i = 0; i < 3; i++)
  {
    FILE *f = iob_get_file(i);
    CRITICAL_SECTION *cs = file_get_cs(f);
 
    /* FILE structs for stdin/out/err are static and never deleted */
    f->_file = get_ioinfo_nolock(i)->handle == MSVCRT_NO_CONSOLE ?
        MSVCRT_NO_CONSOLE_FD : i;
    f->_tmpfname = NULL;
    f->_flag = (i == 0) ? _IOREAD : _IOWRT;
 
    if (cs)
    {
      InitializeCriticalSectionEx(cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
      cs->DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
    }
  }
  MSVCRT_stream_idx = 3;
}

◆ msvcrt_init_locale()

BOOL msvcrt_init_locale ( void )

Definition at line 2151 of file locale.c.

{
    int i;
 
    _lock_locales();
    MSVCRT_locale = _create_locale(0, "C");
    _unlock_locales();
    if(!MSVCRT_locale)
        return FALSE;
 
    MSVCRT___lc_codepage = MSVCRT_locale->locinfo->lc_codepage;
    MSVCRT___lc_collate_cp = MSVCRT_locale->locinfo->lc_collate_cp;
    MSVCRT___mb_cur_max = MSVCRT_locale->locinfo->mb_cur_max;
    MSVCRT__pctype = MSVCRT_locale->locinfo->pctype;
    for(i=LC_MIN; i<=LC_MAX; i++)
        MSVCRT___lc_handle[i] = MSVCRT_locale->locinfo->lc_handle[i];
    _setmbcp(_MB_CP_ANSI);
    return TRUE;
}

◆ msvcrt_init_math()

void msvcrt_init_math ( void * module )

Definition at line 74 of file math.c.

{
    sse2_supported = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
#if _MSVCR_VER <=71
    sse2_enabled = FALSE;
#else
    sse2_enabled = sse2_supported;
#endif
}

◆ msvcrt_init_mt_locks()

void msvcrt_init_mt_locks ( void )

Definition at line 66 of file lock.c.

{
  int i;
 
  TRACE( "initializing mtlocks\n" );
 
  /* Initialize the table */
  for( i=0; i < _TOTAL_LOCKS; i++ )
  {
    msvcrt_mlock_set_entry_initialized( i, FALSE );
  }
 
  /* Initialize our lock table lock */
  msvcrt_initialize_mlock( _LOCKTAB_LOCK );
}

◆ msvcrt_init_signals()

void msvcrt_init_signals ( void )

Definition at line 635 of file except.c.

{
    SetConsoleCtrlHandler(msvcrt_console_handler, TRUE);
}

◆ msvcrt_set_errno()

void msvcrt_set_errno ( int err )

Definition at line 132 of file errno.c.

{
  int *errno_ptr = _errno();
  __msvcrt_ulong *doserrno = __doserrno();
 
  *doserrno = err;
 
  switch(err)
  {
#define ERR_CASE(oserr) case oserr:
#define ERR_MAPS(oserr, crterr) case oserr: *errno_ptr = crterr; break
    ERR_CASE(ERROR_ACCESS_DENIED)
    ERR_CASE(ERROR_NETWORK_ACCESS_DENIED)
    ERR_CASE(ERROR_CANNOT_MAKE)
    ERR_CASE(ERROR_SEEK_ON_DEVICE)
    ERR_CASE(ERROR_LOCK_FAILED)
    ERR_CASE(ERROR_FAIL_I24)
    ERR_CASE(ERROR_CURRENT_DIRECTORY)
    ERR_CASE(ERROR_DRIVE_LOCKED)
    ERR_CASE(ERROR_NOT_LOCKED)
    ERR_CASE(ERROR_INVALID_ACCESS)
    ERR_CASE(ERROR_SHARING_VIOLATION)
    ERR_MAPS(ERROR_LOCK_VIOLATION,       EACCES);
    ERR_CASE(ERROR_FILE_NOT_FOUND)
    ERR_CASE(ERROR_NO_MORE_FILES)
    ERR_CASE(ERROR_BAD_PATHNAME)
    ERR_CASE(ERROR_BAD_NETPATH)
    ERR_CASE(ERROR_INVALID_DRIVE)
    ERR_CASE(ERROR_BAD_NET_NAME)
    ERR_CASE(ERROR_FILENAME_EXCED_RANGE)
    ERR_MAPS(ERROR_PATH_NOT_FOUND,       ENOENT);
    ERR_MAPS(ERROR_IO_DEVICE,            EIO);
    ERR_MAPS(ERROR_BAD_FORMAT,           ENOEXEC);
    ERR_MAPS(ERROR_INVALID_HANDLE,       EBADF);
    ERR_CASE(ERROR_OUTOFMEMORY)
    ERR_CASE(ERROR_INVALID_BLOCK)
    ERR_CASE(ERROR_NOT_ENOUGH_QUOTA)
    ERR_MAPS(ERROR_ARENA_TRASHED,        ENOMEM);
    ERR_MAPS(ERROR_BUSY,                 EBUSY);
    ERR_CASE(ERROR_ALREADY_EXISTS)
    ERR_MAPS(ERROR_FILE_EXISTS,          EEXIST);
    ERR_MAPS(ERROR_BAD_DEVICE,           ENODEV);
    ERR_MAPS(ERROR_TOO_MANY_OPEN_FILES,  EMFILE);
    ERR_MAPS(ERROR_DISK_FULL,            ENOSPC);
    ERR_MAPS(ERROR_BROKEN_PIPE,          EPIPE);
    ERR_MAPS(ERROR_POSSIBLE_DEADLOCK,    EDEADLK);
    ERR_MAPS(ERROR_DIR_NOT_EMPTY,        ENOTEMPTY);
    ERR_MAPS(ERROR_BAD_ENVIRONMENT,      E2BIG);
    ERR_CASE(ERROR_WAIT_NO_CHILDREN)
    ERR_MAPS(ERROR_CHILD_NOT_COMPLETE,   ECHILD);
    ERR_CASE(ERROR_NO_PROC_SLOTS)
    ERR_CASE(ERROR_MAX_THRDS_REACHED)
    ERR_MAPS(ERROR_NESTING_NOT_ALLOWED,  EAGAIN);
  default:
    /*  Remaining cases map to EINVAL */
    /* FIXME: may be missing some errors above */
    *errno_ptr = EINVAL;
  }
}

◆ msvcrt_wstrdupa()

wchar_t * msvcrt_wstrdupa ( const char * str )

Definition at line 373 of file data.c.

{
  const unsigned int len = strlen(str) + 1 ;
  wchar_t *wstr = malloc(len* sizeof (wchar_t));
  if (!wstr)
    return NULL;
   MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,str,len,wstr,len);
  return wstr;
}

◆ operator_delete()

void __cdecl operator_delete ( void * mem )

Definition at line 177 of file heap.c.

{
  TRACE("(%p)\n", mem);
  msvcrt_heap_free(mem);
}

◆ operator_new()

void *__cdecl operator_new ( size_t size )

Definition at line 143 of file heap.c.

{
  void *retval;
 
  do
  {
    retval = msvcrt_heap_alloc(0, size);
    if(retval)
    {
      TRACE("(%Iu) returning %p\n", size, retval);
      return retval;
    }
  } while(_callnewh(size));
 
  TRACE("(%Iu) out of memory\n", size);
#if _MSVCR_VER >= 80
  throw_bad_alloc();
#endif
  return NULL;
}

◆ pf_printf_a()

int pf_printf_a	(	puts_clbk_a	,
		void *	,
		const char *	,
		_locale_t	,
		DWORD	,
		args_clbk	,
		void *	,
		va_list *
	)

Referenced by _vcprintf(), _vcprintf_l(), _vscprintf_p_l(), _vsnprintf(), _vsnprintf_l(), vfprintf_helper(), vsnprintf_s_l_opt(), and vsprintf_p_l_opt().

◆ pf_printf_w()

int pf_printf_w	(	puts_clbk_w	,
		void *	,
		const wchar_t *	,
		_locale_t	,
		DWORD	,
		args_clbk	,
		void *	,
		va_list *
	)

Referenced by _vcwprintf(), _vcwprintf_l(), _vsnwprintf(), _vsnwprintf_l(), vfwprintf_helper(), vsnwprintf_s_l_opt(), and vswprintf_p_l_opt().

◆ terminate()

void __cdecl terminate ( void )

Definition at line 698 of file cpp.c.

{
    thread_data_t *data = msvcrt_get_thread_data();
    if (data->terminate_handler) data->terminate_handler();
    abort();
}

◆ wstrdupa_utf8()

static wchar_t * wstrdupa_utf8 ( const char * str )

inlinestatic

Definition at line 440 of file msvcrt.h.

{
    int len = convert_acp_utf8_to_wcs(str, NULL, 0);
    wchar_t *wstr;
 
    if (!len) return NULL;
    wstr = malloc(len * sizeof(wchar_t));
    if (!wstr) return NULL;
    convert_acp_utf8_to_wcs(str, wstr, len);
    return wstr;
}

Referenced by _access(), _chdir(), _chmod(), _execl(), _execle(), _execlp(), _execlpe(), _findfirst32(), _findfirst64(), _findfirst64i32(), _fsopen(), _fullpath(), _loaddll(), _mkdir(), _mktemp(), _mktemp_s(), _popen(), _rmdir(), _sopen_dispatch(), _spawnl(), _spawnle(), _spawnlp(), _spawnlpe(), _spawnve(), _spawnvpe(), _stat64(), _tempnam(), _unlink(), freopen(), rename(), and system().

Variable Documentation

◆ cloc_time_data

__lc_time_data cloc_time_data

extern

Definition at line 60 of file locale.c.

Referenced by create_locinfo(), free_locinfo(), and strftime_impl().

◆ initial_locale

BOOL initial_locale

extern

Definition at line 49 of file locale.c.

Referenced by setlocale(), tolower(), and toupper().

◆ MSVCRT___initenv

char** MSVCRT___initenv

extern

Definition at line 57 of file data.c.

Referenced by __p___initenv(), and env_init().

◆ MSVCRT___lc_codepage

unsigned int MSVCRT___lc_codepage

extern

Definition at line 45 of file locale.c.

◆ MSVCRT___lc_collate_cp

int MSVCRT___lc_collate_cp

extern

Definition at line 46 of file locale.c.

◆ MSVCRT___winitenv

wchar_t** MSVCRT___winitenv

extern

Definition at line 58 of file data.c.

Referenced by __p___winitenv(), env_init(), and env_set().

◆ MSVCRT__commode

unsigned int MSVCRT__commode

extern

Definition at line 33 of file data.c.

◆ MSVCRT__ctype

WORD MSVCRT__ctype[257]

extern

Definition at line 34 of file ctype.c.

◆ MSVCRT__environ

char** MSVCRT__environ

extern

Definition at line 55 of file data.c.

◆ MSVCRT__iob

FILE MSVCRT__iob[]

extern

Definition at line 263 of file file.c.

◆ MSVCRT__pwctype

WORD* MSVCRT__pwctype

extern

Definition at line 128 of file ctype.c.

◆ MSVCRT__wenviron

wchar_t** MSVCRT__wenviron

extern

Definition at line 56 of file data.c.

◆ MSVCRT_locale

_locale_t MSVCRT_locale

extern

Definition at line 43 of file locale.c.

◆ msvcrt_tls_index

DWORD msvcrt_tls_index

extern

Definition at line 29 of file main.c.

◆ sse2_supported

BOOL sse2_supported

extern

Definition at line 71 of file math.c.

Referenced by _clearfp(), _control87(), _fpreset(), _set_SSE2_enable(), memmove(), and msvcrt_init_math().

Variables
BOOL	sse2_supported

DWORD	msvcrt_tls_index

_locale_t	MSVCRT_locale

__lc_time_data	cloc_time_data

unsigned int	MSVCRT___lc_codepage

int	MSVCRT___lc_collate_cp

WORD	MSVCRT__ctype [257]

BOOL	initial_locale

WORD *	MSVCRT__pwctype

char **	MSVCRT__environ

wchar_t **	MSVCRT__wenviron

char **	MSVCRT___initenv

wchar_t **	MSVCRT___winitenv

unsigned int	MSVCRT__commode

FILE	MSVCRT__iob []

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ __acrt_iob_func

◆ _MAX__TIME64_T

◆ _NO_CRT_STDIO_INLINE

◆ _RT_ABORT

◆ _RT_BANNER

◆ _RT_BREAK

◆ _RT_CRNL

◆ _RT_DOMAIN

◆ _RT_EXECENV

◆ _RT_EXECFORM

◆ _RT_EXECMEM

◆ _RT_FLOAT

◆ _RT_FPTR

◆ _RT_HEAP

◆ _RT_HEAPINIT

◆ _RT_INT

◆ _RT_INTDIV

◆ _RT_INVALDISP

◆ _RT_LOCK

◆ _RT_LOWIOINIT

◆ _RT_NOMAIN

◆ _RT_NONCONT

◆ _RT_NPTR

◆ _RT_NULLPTR

◆ _RT_ONEXIT

◆ _RT_OPENCON

◆ _RT_PUREVIRT

◆ _RT_QWIN

◆ _RT_SING

◆ _RT_SPACEARG

◆ _RT_SPACEENV

◆ _RT_STACK

◆ _RT_STDIOINIT

◆ _RT_THREAD

◆ _RT_TLOSS

◆ COOPERATIVE_TIMEOUT_INFINITE

◆ COOPERATIVE_WAIT_TIMEOUT

◆ DBL80_MAX_10_EXP

◆ DBL80_MIN_10_EXP

◆ INHERIT_THREAD_PRIORITY

◆ LOCALE_FREE

◆ LOCALE_THREAD

◆ MSVCRT__IOCOMMIT

◆ MSVCRT__NOBUF

◆ MSVCRT__USERBUF

◆ MSVCRT_CHECK_PMT

◆ MSVCRT_CHECK_PMT_ERR

◆ MSVCRT_INVALID_PMT

◆ MSVCRT_NO_CONSOLE

◆ MSVCRT_NO_CONSOLE_FD

◆ MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER

◆ MSVCRT_PRINTF_POSITIONAL_PARAMS

◆ UCRTBASE_PRINTF_MASK

◆ UCRTBASE_SCANF_MASK

Typedef Documentation

◆ __lc_time_data

◆ _se_translator_function

◆ args_clbk

◆ frame_info

◆ free_func_t

◆ malloc_func_t

◆ MSVCRT_security_error_handler

◆ printf_arg

◆ puts_clbk_a

◆ puts_clbk_w

◆ terminate_function

◆ thread_data_t

◆ threadmbcinfo

◆ unexpected_function

Enumeration Type Documentation

◆ fpmod

Function Documentation

◆ __crtLCMapStringA()