static void free_environment(Character** const environment) throw() { if (!environment) return; for (Character** it = environment; *it; ++it) _free_crt(*it); _free_crt(environment); }
int __cdecl rename( const char *oldname, const char *newname ) { /* We want to use MoveFileExW but not MoveFileExA (or MoveFile). So convert the strings to Unicode representation and call _wrename. Note that minwin does not support OEM CP for conversion via the FileAPIs APIs. So we unconditionally use the ACP for conversion */ int oldnamelen; int newnamelen; wchar_t *widenamesbuffer = NULL; wchar_t *oldnamew = NULL; wchar_t *newnamew = NULL; int retval; UINT codePage = CP_ACP; #if !(defined (_CORESYS) || defined (_CRT_APP) || defined (_KERNELX)) if (!__crtIsPackagedApp() && !AreFileApisANSI()) codePage = CP_OEMCP; #endif /* !(defined (_CORESYS) || defined (_CRT_APP) || defined (_KERNELX)) */ if ( ( (oldnamelen = MultiByteToWideChar(codePage, 0, oldname, -1, 0, 0) ) == 0 ) || ( (newnamelen = MultiByteToWideChar(codePage, 0, newname, -1, 0, 0) ) == 0 ) ) { _dosmaperr(GetLastError()); return -1; } /* allocate enough space for both */ if ( (widenamesbuffer = (wchar_t*)_malloc_crt( (oldnamelen+newnamelen) * sizeof(wchar_t) ) ) == NULL ) { /* errno is set by _malloc */ return -1; } /* now do the conversion */ oldnamew = widenamesbuffer; newnamew = widenamesbuffer + oldnamelen; if ( ( MultiByteToWideChar(codePage, 0, oldname, -1, oldnamew, oldnamelen) == 0 ) || ( MultiByteToWideChar(codePage, 0, newname, -1, newnamew, newnamelen) == 0 ) ) { _free_crt(widenamesbuffer); _dosmaperr(GetLastError()); return -1; } /* and event call the wide-character variant */ retval = _wrename(oldnamew,newnamew); _free_crt(widenamesbuffer); /* _free_crt leaves errno alone if everything completes as expected */ return retval; }
extern "C" void __cdecl __acrt_stdio_free_tmpfile_name_buffers_nolock() { for (char*& p : narrow_tmpfile_buffer_pointers) { _free_crt(p); p = nullptr; } for (wchar_t*& p : wide_tmpfile_buffer_pointers) { _free_crt(p); p = nullptr; } }
int __cdecl __init_monetary ( void ) { struct lconv *lc; if (__lc_handle[LC_MONETARY] != _CLOCALEHANDLE) { /* Allocate structure filled with NULL pointers */ if ((lc = (struct lconv *) _calloc_crt (1, sizeof(struct lconv))) == NULL) return 1; if (_get_lc_lconv (lc)) { _free_lc_lconv (lc); _free_crt (lc); return 1; } /* Copy numeric locale fields */ lc->decimal_point = __lconv->decimal_point; lc->thousands_sep = __lconv->thousands_sep; lc->grouping = __lconv->grouping; __lconv = lc; /* point to new one */ _free_lc_lconv (__lconv_intl); /* free the old one */ _free_crt (__lconv_intl); __lconv_intl = lc; return 0; } else { /* * Copy numeric locale fields (not necessarily C locale) * to static structure. Note that __lconv_c numeric locale * fields may contain non-C locale information, but * monetary locale fields always contain C locale info. */ __lconv_c.decimal_point = __lconv->decimal_point; __lconv_c.thousands_sep = __lconv->thousands_sep; __lconv_c.grouping = __lconv->grouping; __lconv = &__lconv_c; /* point to new one */ _free_lc_lconv (__lconv_intl); /* free the old one */ _free_crt (__lconv_intl); __lconv_intl = NULL; return 0; } }
extern "C" float _CRTIMP __cdecl _wcstof_l ( const wchar_t *nptr, wchar_t **endptr, _locale_t plocinfo ) { int len; char * str = NULL; /* get the buffer size needed for conversion */ if ( (len = WideCharToMultiByte(CP_ACP, 0 /* Use default flags */, nptr, -1, 0, 0, NULL, NULL) ) == 0 ) { _dosmaperr(GetLastError()); return 0; } /* allocate enough space for conversion */ if ( (str = (char*)_malloc_crt( len * sizeof(char) ) ) == NULL ) { /* malloc should set the errno */ return 0; } /* now do the conversion */ if ( WideCharToMultiByte(CP_ACP, 0 /* Use default flags */, nptr, -1, str, len, NULL, NULL) == 0 ) { _dosmaperr(GetLastError()); _free_crt(str); return 0; } _CRT_FLOAT ret; char *local_end_ptr = NULL; __crt_atoflt_l(&ret, str, plocinfo, &local_end_ptr); if (endptr != NULL) { if (local_end_ptr != NULL) { *endptr = (wchar_t*)(nptr + (local_end_ptr - str)); } else { *endptr = NULL; } } _free_crt(str); return ret.f; }
extern "C" int __cdecl _fclose_nolock(FILE* const public_stream) { __crt_stdio_stream const stream(public_stream); _VALIDATE_RETURN(stream.valid(), EINVAL, EOF); int result = EOF; if (stream.is_in_use()) { result = __acrt_stdio_flush_nolock(stream.public_stream()); __acrt_stdio_free_buffer_nolock(stream.public_stream()); if (_close(_fileno(stream.public_stream())) < 0) { result = EOF; } else if (stream->_tmpfname != nullptr) { _free_crt(stream->_tmpfname); stream->_tmpfname = nullptr; } } __acrt_stdio_free_stream(stream); return result; }
void __cdecl _ioterm ( void ) { int i; #if defined(_MT) && !defined(DLL_FOR_WIN32S) ioinfo *pio; #endif for ( i = 0 ; i < IOINFO_ARRAYS ; i++ ) { if ( __pioinfo[i] != NULL ) { #if defined(_MT) && !defined(DLL_FOR_WIN32S) /* * Delete any initialized critical sections. */ for ( pio = __pioinfo[i] ; pio < __pioinfo[i] + IOINFO_ARRAY_ELTS ; pio++ ) { if ( pio->lockinitflag ) DeleteCriticalSection( &(pio->lock) ); } #endif /* * Free the memory which held the ioinfo array. */ _free_crt( __pioinfo[i] ); __pioinfo[i] == NULL; } } }
int __cdecl __init_time ( pthreadlocinfo ploci ) { /* Temporary date/time strings */ struct __lc_time_data *lc_time; if ( ploci->lc_handle[LC_TIME] != _CLOCALEHANDLE ) { /* Allocate structure filled with NULL pointers */ if ( (lc_time = (struct __lc_time_data *) _calloc_crt(1, sizeof(struct __lc_time_data))) == NULL ) return 1; if (_get_lc_time(lc_time, ploci)) { __free_lc_time (lc_time); _free_crt (lc_time); return 1; } lc_time->refcount = 1; } else { lc_time = &__lc_time_c; /* point to new one */ } if (ploci->lc_time_curr != &__lc_time_c && InterlockedDecrement(&(ploci->lc_time_curr->refcount)) == 0) { _ASSERTE(ploci->lc_time_curr->refcount > 0); } ploci->lc_time_curr = lc_time; /* point to new one */ return 0; }
void __cdecl _wperror ( const wchar_t *wmessage ) { int fh = 2; size_t size = 0; char *amessage; const char *sysmessage; /* convert WCS string into ASCII string */ if ( wmessage && *wmessage ) { _ERRCHECK_EINVAL_ERANGE(wcstombs_s( &size, NULL, 0, wmessage, INT_MAX)); if ( size==0 || (amessage = (char *)_calloc_crt(size, sizeof(char))) == NULL ) return; if ( _ERRCHECK_EINVAL_ERANGE(wcstombs_s(NULL, amessage, size, wmessage, _TRUNCATE)) != 0) { _free_crt(amessage); return; } } else amessage = NULL; _lock_fh( fh ); /* acquire file handle lock */ __try { if ( amessage ) { _write_nolock(fh,(char *)amessage,(unsigned)strlen(amessage)); _write_nolock(fh,": ",2); } _free_crt(amessage); /* note: freeing NULL is legal and benign */ sysmessage = _get_sys_err_msg( errno ); _write_nolock(fh, sysmessage,(unsigned)strlen(sysmessage)); _write_nolock(fh,"\n",1); } __finally { _unlock_fh( fh ); /* release file handle lock */ } }
int __cdecl __wtomb_environ ( void ) { char *envp=NULL; wchar_t **wenvp = _wenviron; /* * For every environment variable in the multibyte environment, * convert it and add it to the wide environment. */ while (*wenvp) { int size; /* find out how much space is needed */ if ((size = WideCharToMultiByte(CP_ACP, 0, *wenvp, -1, NULL, 0, NULL, NULL)) == 0) return -1; /* allocate space for variable */ if ((envp = (char *) _calloc_crt(size, sizeof(char))) == NULL) return -1; /* convert it */ if (WideCharToMultiByte(CP_ACP, 0, *wenvp, -1, envp, size, NULL, NULL) == 0) { _free_crt(envp); return -1; } /* set it - this is not primary call, so set primary == 0 */ if(__crtsetenv(&envp, 0)<0) { if(envp) { _free_crt(envp); envp=NULL; } } wenvp++; } return 0; }
/* * Free the lconv monetary strings. * Numeric values do not need to be freed. */ void __cdecl __free_lconv_mon( struct lconv *l ) { if (l == NULL) return; if ( l->int_curr_symbol != __lconv_c.int_curr_symbol ) _free_crt(l->int_curr_symbol); if ( l->currency_symbol != __lconv_c.currency_symbol ) _free_crt(l->currency_symbol); if ( l->mon_decimal_point != __lconv_c.mon_decimal_point ) _free_crt(l->mon_decimal_point); if ( l->mon_thousands_sep != __lconv_c.mon_thousands_sep ) _free_crt(l->mon_thousands_sep); if ( l->mon_grouping != __lconv_c.mon_grouping ) _free_crt(l->mon_grouping); if ( l->positive_sign != __lconv_c.positive_sign ) _free_crt(l->positive_sign); if ( l->negative_sign != __lconv_c.negative_sign ) _free_crt(l->negative_sign); }
intptr_t __cdecl _tspawnle ( int modeflag, const _TSCHAR *pathname, const _TSCHAR *arglist, ... ) { #ifdef _M_IX86 REG1 const _TSCHAR **argp; /* validation section */ _VALIDATE_RETURN(pathname != NULL, EINVAL, -1); _VALIDATE_RETURN(*pathname != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); /* walk the arglist until the terminating NULL pointer is found. The * next location holds the environment table pointer. */ argp = &arglist; while (*argp++) ; return(_tspawnve(modeflag,pathname,&arglist,(_TSCHAR **)*argp)); #else /* _M_IX86 */ va_list vargs; _TSCHAR * argbuf[64]; _TSCHAR ** argv; _TSCHAR ** envp; intptr_t result; /* validation section */ _VALIDATE_RETURN(pathname != NULL, EINVAL, -1); _VALIDATE_RETURN(*pathname != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); va_start(vargs, arglist); #ifdef WPRFLAG argv = _wcapture_argv(&vargs, arglist, argbuf, 64); #else /* WPRFLAG */ argv = _capture_argv(&vargs, arglist, argbuf, 64); #endif /* WPRFLAG */ envp = va_arg(vargs, _TSCHAR **); va_end(vargs); result = _tspawnve(modeflag,pathname,argv,envp); if (argv && argv != argbuf) _free_crt(argv); return result; #endif /* _M_IX86 */ }
void _Mtx_destroy(_Mtx_t mtx) { /* destroy mutex */ if (mtx) { /* something to do, do it */ _Mtx_destroy_in_situ(mtx); _free_crt(mtx); } }
// This function is called by the operating system when a thread is being // destroyed, to allow us the opportunity to clean up. static void WINAPI destroy_fls(void* const pfd) throw() { if (!pfd) { return; } destroy_ptd_array(static_cast<__acrt_ptd*>(pfd)); _free_crt(pfd); }
void __cdecl __endstdio(void) { /* flush all streams */ _flushall(); /* if in callable exit, close all streams */ if (_exitflag) { _fcloseall(); } _free_crt(__piob); }
int __cdecl _fcloseall ( void ) { REG2 int count = 0; #ifdef _WIN32 REG1 i; _mlock(_IOB_SCAN_LOCK); for ( i = 3 ; i < _nstream ; i++ ) { if ( __piob[i] != NULL ) { /* * if the stream is in use, close it */ if ( inuse( (FILE *)__piob[i] ) && (fclose( __piob[i] ) != EOF) ) count++; /* * if stream is part of a _FILEX we allocated, free it. */ if ( i >= _IOB_ENTRIES ) { #if defined (_MT) DeleteCriticalSection( &(((_FILEX *)__piob[i])->lock) ); #endif /* defined (_MT) */ _free_crt( __piob[i] ); __piob[i] = NULL; } } } _munlock(_IOB_SCAN_LOCK); #else /* _WIN32 */ #if defined (_M_MPPC) || defined (_M_M68K) REG1 FILE *stream = &_iob[3]; for (; stream <= _lastiob; stream++) if (fclose(stream) != EOF) count++; #endif /* defined (_M_MPPC) || defined (_M_M68K) */ #endif /* _WIN32 */ return(count); }
intptr_t __cdecl _texeclpe ( const _TSCHAR *filename, const _TSCHAR *arglist, ... ) { #ifdef _M_IX86 const _TSCHAR **argp; /* validation section */ _VALIDATE_RETURN(filename != NULL, EINVAL, -1); _VALIDATE_RETURN(*filename != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); argp = &arglist; while (*argp++) ; return(_texecvpe(filename,&arglist,(_TSCHAR **)*argp)); #else /* _M_IX86 */ va_list vargs; _TSCHAR * argbuf[64]; _TSCHAR ** argv; _TSCHAR ** envp; intptr_t result; /* validation section */ _VALIDATE_RETURN(filename != NULL, EINVAL, -1); _VALIDATE_RETURN(*filename != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); va_start(vargs, arglist); #ifdef WPRFLAG argv = _wcapture_argv(&vargs, arglist, argbuf, 64); #else /* WPRFLAG */ argv = _capture_argv(&vargs, arglist, argbuf, 64); #endif /* WPRFLAG */ envp = va_arg(vargs, _TSCHAR **); va_end(vargs); result = _texecvpe(filename,argv,envp); if (argv && argv != argbuf) _free_crt(argv); return result; #endif /* _M_IX86 */ }
int __cdecl _tspawnlpe ( int modeflag, const _TSCHAR *filename, const _TSCHAR *arglist, ... ) { #ifdef _M_IX86 REG1 const _TSCHAR **argp; _ASSERTE(filename != NULL); _ASSERTE(*filename != _T('\0')); _ASSERTE(arglist != NULL); _ASSERTE(*arglist != _T('\0')); argp = &arglist; while (*argp++) ; return(_tspawnvpe(modeflag,filename,&arglist,(_TSCHAR **)*argp)); #else /* _M_IX86 */ va_list vargs; _TSCHAR * argbuf[64]; _TSCHAR ** argv; _TSCHAR ** envp; int result; _ASSERTE(filename != NULL); _ASSERTE(*filename != _T('\0')); _ASSERTE(arglist != NULL); _ASSERTE(*arglist != _T('\0')); va_start(vargs, arglist); #ifdef WPRFLAG argv = _wcapture_argv(&vargs, arglist, argbuf, 64); #else /* WPRFLAG */ argv = _capture_argv(&vargs, arglist, argbuf, 64); #endif /* WPRFLAG */ envp = va_arg(vargs, _TSCHAR **); va_end(vargs); result = _tspawnvpe(modeflag,filename,argv,envp); if (argv && argv != argbuf) _free_crt(argv); return result; #endif /* _M_IX86 */ }
void __cdecl _wperror ( REG1 const wchar_t *wmessage ) { REG2 int fh = 2; int size; char *amessage; /* convert WCS string into ASCII string */ size = wcslen(wmessage) + 1; if (NULL == (amessage = (char *)_malloc_crt(size * sizeof(char)))) return; if (0 == (wcstombs(amessage, wmessage, size))) { _free_crt (amessage); return; } _lock_fh(fh); /* acquire file handle lock */ if (amessage && *amessage) { _write_lk(fh,(char *)amessage,strlen(amessage)); _write_lk(fh,": ",2); } _free_crt(amessage); amessage = _sys_err_msg( errno ); _write_lk(fh,(char *)amessage,strlen(amessage)); _write_lk(fh,"\n",1); _unlock_fh(fh); /* release file handle lock */ }
void __cdecl _freebuf ( REG1 FILE *stream ) { _ASSERTE(stream != NULL); if (inuse(stream) && mbuf(stream)) { _free_crt(stream->_base); stream->_flag &= ~(_IOMYBUF | _IOSETVBUF); stream->_base = stream->_ptr = NULL; stream->_cnt = 0; } }
_ptiddata __cdecl _getptd_noexit ( void ) { _ptiddata ptd; DWORD TL_LastError; TL_LastError = GetLastError(); /* * Initialize FlsGetValue function pointer in TLS */ __set_flsgetvalue(); if ( (ptd = FLS_GETVALUE(__flsindex)) == NULL ) { /* * no per-thread data structure for this thread. try to create * one. */ if ((ptd = _calloc_crt(1, sizeof(struct _tiddata))) != NULL) { if (FLS_SETVALUE(__flsindex, (LPVOID)ptd) ) { /* * Initialize of per-thread data */ _initptd(ptd,NULL); ptd->_tid = GetCurrentThreadId(); ptd->_thandle = (uintptr_t)(-1); } else { /* * Return NULL to indicate failure */ _free_crt(ptd); ptd = NULL; } } } SetLastError(TL_LastError); return(ptd); }
void __cdecl _free_locale( _locale_t plocinfo ) { if (plocinfo != nullptr) { __acrt_lock(__acrt_multibyte_cp_lock); __try { if (plocinfo->mbcinfo != nullptr && InterlockedDecrement(&(plocinfo->mbcinfo->refcount)) == 0 && plocinfo->mbcinfo != &__acrt_initial_multibyte_data ) { _free_crt(plocinfo->mbcinfo); } } __finally { __acrt_unlock(__acrt_multibyte_cp_lock); } if (plocinfo->locinfo != nullptr) { /* * this portion has to be in locale lock as there may be case when * not this thread but some other thread is still holding to this * locale and is also trying to free this locale. In this case * we may end up leaking memory. */ __acrt_lock(__acrt_locale_lock); __try { __acrt_release_locale_ref(plocinfo->locinfo); if ( (plocinfo->locinfo != nullptr) && (plocinfo->locinfo->refcount == 0) && (plocinfo->locinfo != &__acrt_initial_locale_data) ) __acrt_free_locale(plocinfo->locinfo); } __finally { __acrt_unlock(__acrt_locale_lock); } }
int __cdecl _texeclp ( const _TSCHAR *filename, const _TSCHAR *arglist, ... ) { #ifdef _M_IX86 _ASSERTE(filename != NULL); _ASSERTE(*filename != _T('\0')); _ASSERTE(arglist != NULL); _ASSERTE(*arglist != _T('\0')); return(_texecvp(filename,&arglist)); #else /* _M_IX86 */ va_list vargs; _TSCHAR * argbuf[64]; _TSCHAR ** argv; int result; _ASSERTE(filename != NULL); _ASSERTE(*filename != _T('\0')); _ASSERTE(arglist != NULL); _ASSERTE(*arglist != _T('\0')); va_start(vargs, arglist); #ifdef WPRFLAG argv = _wcapture_argv(&vargs, arglist, argbuf, 64); #else /* WPRFLAG */ argv = _capture_argv(&vargs, arglist, argbuf, 64); #endif /* WPRFLAG */ va_end(vargs); result = _texecvp(filename,argbuf); if (argv && argv != argbuf) _free_crt(argv); return result; #endif /* _M_IX86 */ }
static void WINAPI __dyn_tls_dtor( HANDLE, DWORD const dwReason, LPVOID ) { if (dwReason != DLL_THREAD_DETACH && dwReason != DLL_PROCESS_DETACH) { return; } CRT_WARNING_DISABLE_PUSH(22019, "Silence prefast about overflow/underflow"); TlsDtorNode* pnext = nullptr; for (TlsDtorNode* pnode = dtor_list; pnode != nullptr; pnode = pnext) { for (int i = pnode->count - 1; i >= 0; --i) { if (pnode->funcs[i]) pnode->funcs[i](); } /* * Free every TlsDtorNode except the original one, which is statically * allocated. */ pnext = pnode->next; if (pnext) { _free_crt(pnode); } /* * Update the dtor_list to ensure completed destructors do not remain * on the list. If a destructor exits with an exception the process * will terminate. Windows will still invoke the TLS callback on * process teardown, but we do not want to re-run destructors that have * already run. */ dtor_list = pnext; } CRT_WARNING_POP; }
void __cdecl _mtdeletelocks( void ) { int locknum; for ( locknum = 0 ; locknum < _TOTAL_LOCKS ; locknum++ ) { /* * If the 'lock' has been created, delete it */ /* * Delete the lock if it had been created */ if ( _locktable[locknum] != NULL ) { if ( (locknum != _LOCKTAB_LOCK) && (locknum != _EXIT_LOCK1) && (locknum != _HEAP_LOCK) && (locknum != _SIGNAL_LOCK) ) { /* * Free the memory for the CritSect after deleting * it. It is okay to call free() if the heap lock * is kept valid until after all calls to the heap. */ DeleteCriticalSection(_locktable[locknum]); _free_crt(_locktable[locknum]); } } } /* * Finally, clean up the special locks */ DeleteCriticalSection( _locktable[_HEAP_LOCK] ); DeleteCriticalSection( _locktable[_EXIT_LOCK1] ); DeleteCriticalSection( _locktable[_LOCKTAB_LOCK] ); DeleteCriticalSection( _locktable[_SIGNAL_LOCK] ); }
/* * Free the lconv strings. * Numeric values do not need to be freed. */ static void __cdecl _free_lc_lconv ( struct lconv *l ) { if (l == NULL) return; if (l->int_curr_symbol != __lconv_static_null) { _free_crt (l->int_curr_symbol); _free_crt (l->currency_symbol); _free_crt (l->mon_decimal_point); _free_crt (l->mon_thousands_sep); _free_crt (l->mon_grouping); _free_crt (l->positive_sign); _free_crt (l->negative_sign); } /* Don't need to make these pointers NULL */ }
extern "C" __crt_multibyte_data* __cdecl __acrt_update_thread_multibyte_data(void) { __crt_multibyte_data* ptmbci = nullptr; __acrt_ptd* const ptd = __acrt_getptd(); if ((ptd->_own_locale & __globallocalestatus) == 0 || ptd->_locale_info == nullptr) { __acrt_lock(__acrt_multibyte_cp_lock); __try { ptmbci = ptd->_multibyte_info; if (ptmbci != __acrt_current_multibyte_data) { /* * Decrement the reference count in the old mbc info structure * and free it, if necessary */ if (ptmbci != nullptr && InterlockedDecrement(&ptmbci->refcount) == 0 && ptmbci != &__acrt_initial_multibyte_data) { /* * Free it */ _free_crt(ptmbci); } /* * Point to the current mbc info structure and increment its * reference count. */ ptmbci = ptd->_multibyte_info = __acrt_current_multibyte_data; InterlockedIncrement(&ptmbci->refcount); } } __finally { __acrt_unlock(__acrt_multibyte_cp_lock); } }
intptr_t __cdecl _tspawnl( int modeflag, const _TSCHAR* pathname, const _TSCHAR* arglist, ... ) { #ifdef _M_IX86 /* validation section */ _VALIDATE_RETURN(pathname != NULL, EINVAL, -1); _VALIDATE_RETURN(*pathname != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); return (_tspawnve(modeflag, pathname, &arglist, NULL)); #else /* _M_IX86 */ va_list vargs; _TSCHAR* argbuf[64]; _TSCHAR** argv; intptr_t result; /* validation section */ _VALIDATE_RETURN(pathname != NULL, EINVAL, -1); _VALIDATE_RETURN(*pathname != _T('\0'), EINVAL, -1); _VALIDATE_RETURN(arglist != NULL, EINVAL, -1); _VALIDATE_RETURN(*arglist != _T('\0'), EINVAL, -1); va_start(vargs, arglist); #ifdef WPRFLAG argv = _wcapture_argv(&vargs, arglist, argbuf, 64); #else /* WPRFLAG */ argv = _capture_argv(&vargs, arglist, argbuf, 64); #endif /* WPRFLAG */ va_end(vargs); result = _tspawnve(modeflag, pathname, argv, NULL); if (argv && argv != argbuf) { _free_crt(argv); } return result; #endif /* _M_IX86 */ }
void __cdecl _lock ( int locknum ) { PCRITICAL_SECTION pcs; /* * Create/open the lock, if necessary */ if ( _locktable[locknum] == NULL ) { if ( (pcs = _malloc_crt(sizeof(CRITICAL_SECTION))) == NULL ) _amsg_exit(_RT_LOCK); _mlock(_LOCKTAB_LOCK); /*** WARNING: Recursive lock call ***/ if ( _locktable[locknum] == NULL ) { InitializeCriticalSection(pcs); _locktable[locknum] = pcs; } else { _free_crt(pcs); } _munlock(_LOCKTAB_LOCK); } /* * Enter the critical section. */ EnterCriticalSection( _locktable[locknum] ); }
LPVOID __cdecl __crtGetEnvironmentStringsW( VOID ) { static int f_use = 0; void *penv = NULL; char *pch; wchar_t *pwch; wchar_t *wbuffer; int total_size = 0; int str_size; /* * Look for unstubbed 'preferred' flavor. Otherwise use available flavor. * Must actually call the function to ensure it's not a stub. */ if ( 0 == f_use ) { if ( NULL != (penv = GetEnvironmentStringsW()) ) f_use = USE_W; else if ( NULL != (penv = GetEnvironmentStringsA()) ) f_use = USE_A; else return NULL; } /* Use "W" version */ if ( USE_W == f_use ) { if ( NULL == penv ) if ( NULL == (penv = GetEnvironmentStringsW()) ) return NULL; /* find out how big a buffer is needed */ pwch = penv; while ( *pwch != L'\0' ) { if ( *++pwch == L'\0' ) pwch++; } total_size = (char *)pwch - (char *)penv + sizeof( wchar_t ); /* allocate the buffer */ if ( NULL == (wbuffer = _malloc_crt( total_size )) ) { FreeEnvironmentStringsW( penv ); return NULL; } /* copy environment strings to buffer */ memcpy( wbuffer, penv, total_size ); FreeEnvironmentStringsW( penv ); return (LPVOID)wbuffer; } /* Use "A" version */ if ( USE_A == f_use ) { /* * Convert strings and return the requested information. */ if ( NULL == penv ) if ( NULL == (penv = GetEnvironmentStringsA()) ) return NULL; pch = penv; /* find out how big a buffer we need */ while ( *pch != '\0' ) { if ( 0 == (str_size = MultiByteToWideChar( __lc_codepage, MB_PRECOMPOSED, pch, -1, NULL, 0 )) ) return 0; total_size += str_size; pch += strlen(pch) + 1; } /* room for final NULL */ total_size++; /* allocate enough space for chars */ if ( NULL == (wbuffer = (wchar_t *) _malloc_crt( total_size * sizeof( wchar_t ) )) ) { FreeEnvironmentStringsA( penv ); return NULL; } /* do the conversion */ pch = penv; pwch = wbuffer; while (*pch != '\0') { if ( 0 == MultiByteToWideChar( __lc_codepage, MB_PRECOMPOSED, pch, -1, pwch, total_size - (pwch - wbuffer) ) ) { _free_crt( wbuffer ); FreeEnvironmentStringsA( penv ); return NULL; } pch += strlen(pch) + 1; pwch += wcslen(pwch) + 1; } *pwch = L'\0'; FreeEnvironmentStringsA( penv ); return (LPVOID)wbuffer; } else /* f_use is neither USE_A nor USE_W */ return NULL; }