text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```objective-c
// parameters for wchar_t character type
#define CTYPE wchar_t
#define CNAME(fun) _W##fun
``` | /content/code_sandbox/src/14.26.28801/stl/xxwctype.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 27 |
```objective-c
// parameters for long double floating-point type
#include <yvals.h>
#include <float.h>
#define FTYPE long double
#define FBITS LDBL_MANT_DIG
#define FMAXEXP LDBL_MAX_EXP
#define FFUN(fun) fun##l
#define FNAME(fun) _L##fun
#define FCONST(obj) _L##obj._Long_double
#define FLIT(lit) lit##L
#... | /content/code_sandbox/src/14.26.28801/stl/xxlftype.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 152 |
```c++
// _Dunscale function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _Dunscale(short* pex, double* px) { // separate *px to 1/2 <= |frac| < 1 and 2^*pex
_Dval* ps = (_Dval*) (char*) px;
short xchar = (ps->_Sh[_D0] & _DMASK) >> _DOFF;
if (xchar == _DMAX) { // NaN or INF
... | /content/code_sandbox/src/14.26.28801/stl/xdunscal.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 314 |
```c++
// _FExp function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
static const float p[] = {1.0F, 60.09114349F};
static const float q[] = {12.01517514F, 120.18228722F};
static const float c1 = (22713.0F / 32768.0F);
static const float c2 = 1.4286068203094172321214581765680755e-6F;
static const float h... | /content/code_sandbox/src/14.26.28801/stl/xfexp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 483 |
```c++
#include "awint.h"
#include <internal_shared.h>
#include <locale.h>
// int __cdecl __crtLCMapStringA - Get type information about an ANSI string.
//
// Purpose:
// Internal support function. Assumes info in ANSI string format. Tries
// to use NLS API call LCMapStringA if available and uses LCMapS... | /content/code_sandbox/src/14.26.28801/stl/StlLCMapStringA.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,192 |
```c++
// implements multiprecision math for random number generators
#include <limits>
#include <random>
_STD_BEGIN
constexpr int shift = _STD numeric_limits<unsigned long long>::digits / 2;
constexpr unsigned long long mask = ~(~0ULL << shift);
constexpr unsigned long long maxVal = mask + 1;
_NO... | /content/code_sandbox/src/14.26.28801/stl/multprec.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,625 |
```objective-c
#ifndef _XMATH
#define _XMATH
#include <errno.h>
#include <math.h>
#include <stddef.h>
#include <ymath.h>
// FLOAT PROPERTIES
#define _D0 3 // little-endian, small long doubles
#define _D1 2
#define _D2 1
#define _D3 0
// IEEE 754 double properties
#define HUGE_EXP (int) (_DMAX * 900L / 1000)
// IEEE... | /content/code_sandbox/src/14.26.28801/stl/xmath.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,396 |
```c++
// _WStoflt function
#include "xmath.h"
#include <locale.h>
#include <wchar.h>
#include <wctype.h>
_EXTERN_C_UNLESS_PURE
constexpr int _Base = 10; // decimal
constexpr int _Ndig = 9; // decimal digits per long element
constexpr int _Maxsig = 5 * _Ndig; // maximum significant digits to keep
int _WStoflt(... | /content/code_sandbox/src/14.26.28801/stl/xwstoflt.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,036 |
```c++
// initialize standard wide error stream (unsigned short version)
#ifdef _NATIVE_WCHAR_T_DEFINED
#include <fstream>
#ifndef wistream
#define wistream ushistream
#define wostream ushostream
#define wfilebuf ushfilebuf
#define _Init_wcerr _Init_ushcerr
#define _Init_wcout _Init_ushcout
#define _Init_wc... | /content/code_sandbox/src/14.26.28801/stl/ushcout.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 167 |
```c++
// initialize standard wide error stream
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static wfilebuf wferr(_cpp_stderr);
#if defined(_M_CEE_PURE)
__PURE_APPDOMAI... | /content/code_sandbox/src/14.26.28801/stl/wcerr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 199 |
```c++
// Compare two wchar_t strings using the locale LC_COLLATE information.
#include "awint.h"
#include <errno.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec, _Wcscoll
_EXTERN_C_UNLESS_PURE
// int _Wcscoll() - Collate wide-character locale strings
//
// Purpo... | /content/code_sandbox/src/14.26.28801/stl/xwcscoll.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 752 |
```c++
#include "awint.h"
#if _STL_WIN32_WINNT < _WIN32_WINNT_VISTA
#include <algorithm>
#include <ctype.h>
#include <stdlib.h>
#include <string_view>
namespace {
struct LCIDTOLOCALENAME {
LCID lcid;
const wchar_t* localeName;
};
struct LOCALENAMEINDEX {
const wchar_t* name;
... | /content/code_sandbox/src/14.26.28801/stl/winapinls.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 8,317 |
```objective-c
// parameters for float floating-point type
#include <yvals.h>
#include <float.h>
#define FTYPE float
#define FBITS FLT_MANT_DIG
#define FMAXEXP FLT_MAX_EXP
#define FFUN(fun) fun##f
#define FNAME(fun) _F##fun
#define FCONST(obj) _F##obj._Float
#define FLIT(lit) lit##F
#define FPMSW(x) (*_F... | /content/code_sandbox/src/14.26.28801/stl/xxfftype.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 145 |
```c++
#include <synchapi.h>
// This must be as small as possible, because its contents are
// injected into the msvcprt.lib and msvcprtd.lib import libraries.
// Do not include or define anything else here.
// In particular, basic_string must not be included here.
// these declarations must be in sync with those in... | /content/code_sandbox/src/14.26.28801/stl/sharedmutex.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 414 |
```c++
// _Dnorm function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _Dnorm(_Dval* ps) { // normalize double fraction
short xchar;
unsigned short sign = (unsigned short) (ps->_Sh[_D0] & _DSIGN);
xchar = 1;
if ((ps->_Sh[_D0] &= _DFRAC) != 0 || ps->_Sh[_D1] || ps->_Sh[_D2] || ... | /content/code_sandbox/src/14.26.28801/stl/xdnorm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 563 |
```c++
// Convert wide character to multibyte character, with locale.
#include <errno.h>
#include <limits.h> // for MB_LEN_MAX
#include <locale.h>
#include <mbctype.h>
#include <stdio.h> // for EOF
#include <stdlib.h>
#include <string.h> // for memcpy
#include <xlocinfo.h> // for _Cvtvec, _Wcrtomb
#include <Windows.... | /content/code_sandbox/src/14.26.28801/stl/xwctomb.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 896 |
```objective-c
// parameters for char character type
#define CTYPE char
#define CNAME(fun) _##fun
``` | /content/code_sandbox/src/14.26.28801/stl/xxcctype.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 24 |
```c++
// thread exit notification functions
#include <stdlib.h>
#include <string.h>
#include <xthreads.h>
#include <Windows.h>
constexpr int _Nitems = 20;
namespace {
struct _At_thread_exit_data { // data for condition-variable slot
_Thrd_t id;
_Mtx_t mtx;
_Cnd_t cnd;
int* res;... | /content/code_sandbox/src/14.26.28801/stl/xnotify.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 962 |
```c++
// force DLL instances
#define __FORCE_INSTANCE
#include <ios>
#include <istream>
#include <locale>
#include <ostream>
#include <streambuf>
#include <xlocale>
#include <xlocmes>
#include <xlocmon>
#include <xlocnum>
#include <xloctime>
_STD_BEGIN
template class _CRTIMP2_PURE_IMPORT _Yarn<char>;
template cla... | /content/code_sandbox/src/14.26.28801/stl/instances.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 113 |
```c++
// _Stolx function
#include <yvals.h>
#include "xmath.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE unsigned long __CLRCALL_PURE_OR_CDECL _Stoulx(const char*, char**, int, int*);
_CRTIMP2_PURE long __CLRCALL_PURE_OR_CDECL _Stolx(
co... | /content/code_sandbox/src/14.26.28801/stl/xstol.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 358 |
```c++
// thread support functions
#include <yvals.h>
#include <stdlib.h>
#include <system_error>
#include <xthreads.h>
_STD_BEGIN
static constexpr const char* msgs[] = {
// error messages
"device or resource busy",
"invalid argument",
"no such process",
"not enough memory",
"operation not ... | /content/code_sandbox/src/14.26.28801/stl/thread0.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 342 |
```c++
// initialize standard input stream
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static filebuf fin(_cpp_stdin);
#if defined(_M_CEE_PURE)
__PURE_APPDOMAIN_GLOBAL... | /content/code_sandbox/src/14.26.28801/stl/cin.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 193 |
```c++
// _FSinh function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
// coefficients
static const float p[] = {0.00020400F, 0.00832983F, 0.16666737F, 0.99999998F};
_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FSinh(float x, float y) { // compute y * sinh(x), |y| <= 1
short neg;
switch (_FDtest(&x)) { // tes... | /content/code_sandbox/src/14.26.28801/stl/xfsinh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 455 |
```c++
// initialize standard wide log stream
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static wfilebuf wflog(_cpp_stderr);
#if defined(_M_CEE_PURE)
__PURE_APPDOMAIN_... | /content/code_sandbox/src/14.26.28801/stl/wclog.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 187 |
```c++
// _FCosh function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _FCosh(float x, float y) { // compute y * cosh(x), |y| <= 1
switch (_FDtest(&x)) { // test for special codes
case _NANCODE:
case _INFCODE:
return x;
case 0:
return y;
de... | /content/code_sandbox/src/14.26.28801/stl/xfcosh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 269 |
```c++
// _UShinit members (unsigned short version)
#ifdef _NATIVE_WCHAR_T_DEFINED
#include <fstream>
#define wistream ushistream
#define wostream ushostream
#define wfilebuf ushfilebuf
#define _Init_wcerr _Init_ushcerr
#define _Init_wcout _Init_ushcout
#define _Init_wclog _Init_ushclog
#define _Init_wcin ... | /content/code_sandbox/src/14.26.28801/stl/ushiostr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 304 |
```c++
// The /clr:pure exception_ptr implementation.
#ifdef CRTDLL
#undef CRTDLL
#endif
#ifdef MRTDLL
#undef MRTDLL
#endif
#ifndef _DLL
#define _DLL
#endif
#include "excptptr.cpp"
``` | /content/code_sandbox/src/14.26.28801/stl/mexcptptr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 51 |
```c++
// _WStod function
#include "xmath.h"
#include "xxdftype.h"
#include "xxwctype.h"
#include <stdlib.h>
#include <wchar.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _WStodx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.h"
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_... | /content/code_sandbox/src/14.26.28801/stl/xwstod.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 172 |
```c++
// _Stoul function
#include "xmath.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
_EXTERN_C_UNLESS_PURE
// macros
constexpr int _Base_max = 36; // largest valid base
// static data
static const char digits[] = // valid digits
"012... | /content/code_sandbox/src/14.26.28801/stl/xstoul.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,100 |
```c++
// _LXp* functions
#include "xmath.h"
#include "xxlftype.h"
#include "xxxprec.h"
``` | /content/code_sandbox/src/14.26.28801/stl/xlprec.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 29 |
```c++
// _Stoflt function
#include "xmath.h"
#include <ctype.h>
#include <locale.h>
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
constexpr int _Base = 10; // decimal
constexpr int _Ndig = 9; // decimal digits per long word
constexpr int _Maxsig = 5 * _Ndig; // maximum significant digits to keep
int _Stoflt(const... | /content/code_sandbox/src/14.26.28801/stl/xstoflt.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,036 |
```c++
// _Feraise function
#include <yvals.h>
#include <errno.h>
#include <ymath.h>
_EXTERN_C_UNLESS_PURE
void __CLRCALL_PURE_OR_CDECL _Feraise(int except) { // report floating-point exception
if ((except & (_FE_DIVBYZERO | _FE_INVALID)) != 0) {
errno = EDOM;
} else if ((except & (_FE_UNDERFLOW | ... | /content/code_sandbox/src/14.26.28801/stl/xferaise.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 121 |
```c++
// This file is built into msvcurt.lib
#if !defined(_M_CEE_PURE)
#error This file must be built with /clr:pure.
#endif
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL extern istream* _Ptr_cin = 0;
__... | /content/code_sandbox/src/14.26.28801/stl/mpiostream.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 231 |
```c++
// system_error message mapping
#include <system_error>
#include <Windows.h>
// TRANSITION, MSBuild
// MSBuild has a hard requirement against including the same file in both a DLL and its import lib, so we include
// the import lib .cpp here to make those functions available for internal use by other parts o... | /content/code_sandbox/src/14.26.28801/stl/syserror.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,749 |
```c++
// ios_base basic members
#include <new>
#include <xiosbase>
_STD_BEGIN
constexpr int _Nstdstr = 8; // cin, wcin, cout, wcout, cerr, wcerr, clog, wclog
// TRANSITION, ABI: _BADOFF is preserved for binary compatibility
#if defined(_M_CEE_PURE)
extern const streamoff _BADOFF;
const streamoff _BADOFF = -1;
#els... | /content/code_sandbox/src/14.26.28801/stl/ios.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 863 |
```c++
// filesys.cpp -- <experimental/filesystem> implementation
// (see filesystem.cpp for C++17 <filesystem> implementation)
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
#include <yvals.h>
#include "awint.h"
#include <direct.h>
#include <experimental/filesystem>
#include <io.h>
#include <string.h... | /content/code_sandbox/src/14.26.28801/stl/filesys.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,709 |
```c++
// condition variable functions
#include "primitives.h"
#include <internal_shared.h>
#include <limits.h>
#include <stdlib.h>
#include <type_traits>
#include <xthreads.h>
#include <xtimec.h>
struct _Cnd_internal_imp_t { // condition variable implementation for ConcRT
std::aligned_storage_t<Concurrency::det... | /content/code_sandbox/src/14.26.28801/stl/cond.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 976 |
```c++
// initialize standard output stream
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static filebuf fout(_cpp_stdout);
#if defined(_M_CEE_PURE)
__PURE_APPDOMAIN_GLO... | /content/code_sandbox/src/14.26.28801/stl/cout.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 257 |
```c++
// class locale wide member functions
#include <istream>
#include <locale>
_STD_BEGIN
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
using _Wtraits = char_traits<wchar_t>;
using _Winiter = istreambuf_iterator<wchar_t, _Wtraits>;
using _Woutiter = ostreambuf_iterator<wchar_t, _Wtraits>;
// fac... | /content/code_sandbox/src/14.26.28801/stl/wlocale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,248 |
```c++
// _Stod function
#include <yvals.h> // include first, for native shared
#include "xmath.h"
#include "xxcctype.h"
#include "xxdftype.h"
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _Stodx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.h"
... | /content/code_sandbox/src/14.26.28801/stl/xstod.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 177 |
```c++
// This must be as small as possible, because its contents are
// injected into the msvcprt.lib and msvcprtd.lib import libraries.
// Do not include or define anything else here.
// In particular, basic_string must not be included here.
#if (defined(_M_IX86) || defined(_M_X64)) && !defined(_M_CEE_PURE)
#includ... | /content/code_sandbox/src/14.26.28801/stl/vector_algorithms.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,236 |
```c++
// _Towlower -- convert wchar_t to lower case
#include "awint.h"
#include <wchar.h>
#include <xlocinfo.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE wchar_t __CLRCALL_PURE_OR_CDECL _Towlower(
wchar_t _Ch, const _Ctypevec* _Ctype) { // convert element to lower case
wchar_t _Res = _Ch;
if (_Ch != WEOF) {
... | /content/code_sandbox/src/14.26.28801/stl/xtowlower.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 295 |
```c++
// filesystem.cpp -- C++17 <filesystem> implementation
// (see filesys.cpp for <experimental/filesystem> implementation)
// This must be as small as possible, because its contents are
// injected into the msvcprt.lib and msvcprtd.lib import libraries.
// Do not include or define anything else here.
// In parti... | /content/code_sandbox/src/14.26.28801/stl/filesystem.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 11,334 |
```objective-c
// common _[FL]Dtento functionality
#include "xmath.h"
#if !defined(MRTDLL)
_EXTERN_C
#endif // defined(MRTDLL)
// macros
#define ACSIZE 4 // size of extended-precision accumulators
#define BIAS (ACSIZE * (FBITS / 2)) // avoid denorms for finite values
#define FRAC_BITS_2 (FRAC_BITS * FRAC_BITS)
... | /content/code_sandbox/src/14.26.28801/stl/xxxdtent.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 844 |
```c++
// _Dtest function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
#if 0
_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Dtest(double* px) { // categorize *px
_Dval* ps = (_Dval*) (char*) px;
if ((ps->_Sh[_D0] & _DMASK) == _DMAX << _DOFF) {
return (short) ((ps->_Sh[_D0] & _DFRAC) !... | /content/code_sandbox/src/14.26.28801/stl/xdtest.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 350 |
```c++
// _Stoll function
#include "xmath.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE unsigned long long __CLRCALL_PURE_OR_CDECL _Stoullx(const char*, char**, int, int*);
_CRTIMP2_PURE long long __CLRCALL_PURE_OR_CDECL _Stollx(
const char... | /content/code_sandbox/src/14.26.28801/stl/xstoll.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 425 |
```c++
// exception handling support functions
#include <functional>
#include <new>
#include <regex>
#include <stdexcept>
_STD_BEGIN
[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xbad_alloc() {
_THROW(bad_alloc{});
}
[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xinvalid_argument(_In_z_ co... | /content/code_sandbox/src/14.26.28801/stl/xthrow.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 382 |
```c++
#include "awint.h"
#include <internal_shared.h>
#include <Windows.h>
#if defined(_CRT_APP)
// free static resource used by causality
extern "C" void __cdecl __crtCleanupCausalityStaticFactories();
#endif
extern "C" BOOL APIENTRY DllMain(HMODULE /* hModule */, DWORD ul_reason_for_call, LPVOID lpReserved) {
... | /content/code_sandbox/src/14.26.28801/stl/dllmain.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 153 |
```c++
// _Stopfx function
#include "xmath.h"
#include <ctype.h>
_EXTERN_C_UNLESS_PURE
int _Stopfx(const char** ps, char** endptr) { // parse prefix of floating-point field
const char* s = *ps;
int code = 0;
while (isspace((unsigned char) *s)) {
++s;
}
if (*s == '-') {
cod... | /content/code_sandbox/src/14.26.28801/stl/xstopfx.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 671 |
```c++
// Machinery for the UTF-8 codecvt facets
#if !defined(_DLL) || defined(_BUILDING_SATELLITE_CODECVT_IDS)
#include <xlocale>
#ifdef _DLL
#define EXPORT __declspec(dllexport)
#else
#define EXPORT
#endif
_STD_BEGIN
EXPORT locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
EXPORT locale::id codecvt<char32_t, ... | /content/code_sandbox/src/14.26.28801/stl/ulocale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 177 |
```c++
// Transform a wide-character string using the locale information as set by LC_COLLATE.
#include "awint.h"
#include <internal_shared.h>
#include <limits.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec, _Wcsxfrm
_EXTERN_C_UNLESS_PURE
// size_t _Wcsxfrm() - ... | /content/code_sandbox/src/14.26.28801/stl/xwcsxfrm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,077 |
```c++
// initialize standard log stream
#include <fstream>
#include <iostream>
#ifndef MRTDLL
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
#endif // MRTDLL
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static filebuf flog(_cpp_stderr);
#if defined(_M_C... | /content/code_sandbox/src/14.26.28801/stl/clog.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 210 |
```c++
// _LPoly function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
long double _LPoly(long double x, const long double* tab, int n) { // compute polynomial
long double y;
for (y = *tab; 0 <= --n;) {
y = y * x + *++tab;
}
return y;
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.26.28801/stl/xlpoly.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 90 |
```c++
#include <crtdbg.h>
#include <crtdefs.h>
#include <pplinterface.h>
#include <ppltasks.h>
#include <Windows.h>
#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
#ifndef UNDOCKED_WINDOWS_UCRT
#pragma warning(push)
#pragma warning(disable : 4265) // non-virtual destructor in base class
#endif
#include <wrl... | /content/code_sandbox/src/14.26.28801/stl/ppltasks.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,222 |
```c++
// Compare two strings using the locale LC_COLLATE information.
#include "awint.h"
#include <crtdbg.h>
#include <errno.h>
#include <locale.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec, _Strcoll
_EXTERN_C_UNLESS_PURE
// int _Strcoll() - Collate locale st... | /content/code_sandbox/src/14.26.28801/stl/xstrcoll.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 719 |
```c++
// Convert multibyte char to wide char.
#include <crtdbg.h>
#include <ctype.h>
#include <errno.h>
#include <internal_shared.h>
#include <limits.h> // for INT_MAX
#include <locale.h>
#include <stdio.h> // for EOF
#include <stdlib.h>
#include <xlocinfo.h> // for _Cvtvec, _Mbrtowc
_EXTERN_C_UNLESS_PURE
static i... | /content/code_sandbox/src/14.26.28801/stl/xmbtowc.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,404 |
```c++
// This must be as small as possible, because its contents are
// injected into the msvcprt.lib and msvcprtd.lib import libraries.
// Do not include or define anything else here.
// In particular, basic_string must not be included here.
// TRANSITION, the code in this file should be moved back to filesystem.cp... | /content/code_sandbox/src/14.26.28801/stl/filesystem_space.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 709 |
```c++
// support for <execution>
#include <corecrt_terminate.h>
#include <internal_shared.h>
#include <intrin0.h>
// This must be as small as possible, because its contents are
// injected into the msvcprt.lib and msvcprtd.lib import libraries.
// Do not include or define anything else here.
// In particular, basic... | /content/code_sandbox/src/14.26.28801/stl/parallel_algorithms.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,794 |
```c++
// moderately accurate lgamma function for random
// TRANSITION, ABI: This should be superseded by the CRT's lgamma().
#include <cmath>
// #include <random>
_STD_BEGIN
_CRTIMP2_PURE float __CLRCALL_PURE_OR_CDECL _XLgamma(float);
_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _XLgamma(double);
_CRTIMP2_PURE lo... | /content/code_sandbox/src/14.26.28801/stl/xlgamma.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 764 |
```c++
// _Xp* functions
#include "xmath.h"
#include "xxdftype.h"
#include "xxxprec.h"
``` | /content/code_sandbox/src/14.26.28801/stl/xprec.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 28 |
```c++
// _LDint function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _LDint(long double* px, short xexp) { // test and drop (scaled) fraction bits -- 64-bit
return _Dint((double*) px, xexp);
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.26.28801/stl/xldint.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 76 |
```c++
// _LDtento function -- IEEE 754 version
#include "xxlftype.h"
#include "xxxdtent.h"
``` | /content/code_sandbox/src/14.26.28801/stl/xldtento.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 28 |
```objective-c
#pragma once
#pragma warning(push)
#pragma warning(disable : 4201) // nonstandard extension used: nameless struct/union
#pragma warning(disable : 4324) // structure was padded due to alignment specifier
#include "awint.h"
#include <crtdefs.h>
#include <exception>
#include <new>
#include <stdlib.h>
#in... | /content/code_sandbox/src/14.26.28801/stl/primitives.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,889 |
```c++
#define STDCPP_IMPLIB 1
#include "locale.cpp"
``` | /content/code_sandbox/src/14.26.28801/stl/locale_implib_pure.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 16 |
```c++
// TRANSITION, ABI: The functions in this file are preserved for binary compatibility
#include "awint.h"
#include <stdexcept>
#include <Windows.h>
namespace stdext {
namespace threads {
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_new(void*& _Ptr) {
_Ptr = new CRITICAL_SECTION;
... | /content/code_sandbox/src/14.26.28801/stl/xalloc.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 254 |
```c++
#include <cerrno>
#include <cmath>
#include <limits>
#include <type_traits>
#include <utility>
#pragma warning(push)
#pragma warning(disable : 4619) // #pragma warning: there is no warning number '%d'
#pragma warning(disable : 4643) // Forward declaring '%s' in namespace std is not permitted by the C++ Standar... | /content/code_sandbox/src/14.26.28801/stl/special_math.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,742 |
```c++
// implement random_device
#include <stdexcept> // for out_of_range
// #include <random>
_STD_BEGIN
_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device();
_CRTIMP2_PURE unsigned int __CLRCALL_PURE_OR_CDECL _Random_device() { // return a random value
unsigned int ans;
if (_CSTD rand_s(&... | /content/code_sandbox/src/14.26.28801/stl/xrngdev.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 114 |
```c++
// _FDnorm function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _FDnorm(_Fval* ps) { // normalize float fraction
short xchar;
unsigned short sign = (unsigned short) (ps->_Sh[_F0] & _FSIGN);
xchar = 1;
if ((ps->_Sh[_F0] &= _FFRAC) != 0 || ps->_Sh[_F1]) { // nonzero, sca... | /content/code_sandbox/src/14.26.28801/stl/xfdnorm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 365 |
```c++
// _Winit members
#include <iostream>
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL int _Winit::_Init_cnt = -1;
_CRTIMP2_PURE __thiscall _Winit::_Winit() { // initialize standard wide streams first time
if (0 <= _Init_cnt) {
++_Init_cnt;
} else {
_Init_cnt = 1;
}
}
_C... | /content/code_sandbox/src/14.26.28801/stl/wiostrea.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 208 |
```c++
// convert character to lower case
#include <yvals.h>
#include "awint.h"
#include <ctype.h>
#include <internal_shared.h>
#include <locale.h>
#include <stddef.h>
#include <stdlib.h>
#include <xlocinfo.h>
// remove macro definitions of _tolower() and tolower()
#undef _tolower
#undef tolower
_EXTERN_C_UNLESS_P... | /content/code_sandbox/src/14.26.28801/stl/_tolower.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 910 |
```c++
// _Exp function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
// coefficients
static const double p[] = {1.0, 420.30235984910635, 15132.70094680474802};
static const double q[] = {30.01511290683317, 3362.72154416553028, 30265.40189360949691};
static const double c1 = 22713.0 / 32768.0;
static const dou... | /content/code_sandbox/src/14.26.28801/stl/xexp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 508 |
```c++
// Transform a string using the locale information as set by LC_COLLATE.
#include "awint.h"
#include <limits.h>
#include <locale.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec
#include <Windows.h>
_EXTERN_C_UNLESS_PURE
// size_t _Strxfrm() - Transform a ... | /content/code_sandbox/src/14.26.28801/stl/xstrxfrm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 836 |
```c++
// values used by math functions -- IEEE 754 long version
#if defined(_M_CEE_PURE)
#if defined(MRTDLL)
#undef MRTDLL
#endif
#endif
#include "xmath.h"
// macros -- 64-bit
#define NBITS (48 + _DOFF)
#define INIT(w0) \
{ 0, 0, 0, w0 }
#define INIT2(w0, w1) \
{ w1, 0, 0, w0 }
// static data
extern /* co... | /content/code_sandbox/src/14.26.28801/stl/xlvalues.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 294 |
```c++
// _Sinh function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
// coefficients
static const double p[] = {0.0000000001632881, 0.0000000250483893, 0.0000027557344615, 0.0001984126975233,
0.0083333333334816, 0.1666666666666574, 1.0000000000000001};
static constexpr size_t NP = sizeof(p) / sizeof(p[0]) - 1;
_... | /content/code_sandbox/src/14.26.28801/stl/xsinh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 495 |
```c++
// _WStoxflt function
#include "xmath.h"
#include <ctype.h>
#include <locale.h>
#include <wchar.h>
#include <wctype.h>
_EXTERN_C_UNLESS_PURE
constexpr int _Base = 16; // hexadecimal
constexpr int _Ndig = 7; // hexadecimal digits per long element
constexpr int _Maxsig = 5 * _Ndig; // maximum significant d... | /content/code_sandbox/src/14.26.28801/stl/xwstoxfl.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,267 |
```c++
#include <eh.h>
#include <exception>
_STD_BEGIN
_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL uncaught_exceptions() noexcept { // report number of throws being handled
return __uncaught_exceptions();
}
_STD_END
``` | /content/code_sandbox/src/14.26.28801/stl/uncaught_exceptions.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 55 |
```c++
// _FDtest function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
#if 0
_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FDtest(float* px) { // categorize *px
_Fval* ps = (_Fval*) (char*) px;
if ((ps->_Sh[_F0] & _FMASK) == _FMAX << _FOFF) {
return (short) ((ps->_Sh[_F0] & _FFRAC) ... | /content/code_sandbox/src/14.26.28801/stl/xfdtest.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 303 |
```c++
#include "awint.h"
#include <crtdbg.h>
#include <internal_shared.h>
#include <string.h>
#include <Windows.h>
// int __cdecl __crtCompareStringW - Get type information about a wide string.
//
// Purpose:
// Internal support function. Assumes info in wide string format.
//
// Entry:
// LPCWSTR LocaleName ... | /content/code_sandbox/src/14.26.28801/stl/StlCompareStringW.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 448 |
```c++
// _Stof function
#include <yvals.h> // include first, for native shared
#include "xmath.h"
#include "xxcctype.h"
#include "xxfftype.h"
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _Stofx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.h"
... | /content/code_sandbox/src/14.26.28801/stl/xstof.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 177 |
```c++
// class locale member functions
#if !defined(STDCPP_IMPLIB)
#define STDCPP_IMPLIB 0
#endif
#include <cstdlib>
#include <internal_shared.h>
#include <istream>
#include <xlocale>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
_STD_BEGIN
using _Traits = char_traits<char>;
using _Initer = istrea... | /content/code_sandbox/src/14.26.28801/stl/locale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,734 |
```c++
#if defined(_DLL)
#ifdef CRTDLL2
#undef CRTDLL2
#endif
#ifdef MRTDLL
#undef MRTDLL
#endif
#define STDCPP_IMPLIB 1
// When building for msvcmrt.lib, inject a dependency to the msvcp DLL.
#if defined _M_CEE && !defined _M_CEE_PURE
#ifdef _CRTBLD
#define _CRTBLD_WAS_DEFINED
#undef _CRTBLD
#endif
#include <use_a... | /content/code_sandbox/src/14.26.28801/stl/locale0_implib.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 146 |
```c++
// values used by math functions -- IEEE 754 float version
#if defined(_M_CEE_PURE)
#if defined(MRTDLL)
#undef MRTDLL
#endif
#endif
#include "xmath.h"
// macros
#define NBITS (16 + _FOFF)
#define INIT(w0) \
{ 0, w0 }
#define INIT2(w0, w1) \
{ w1, w0 }
_EXTERN_C_UNLESS_PURE
// static data
extern /* ... | /content/code_sandbox/src/14.26.28801/stl/xfvalues.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 293 |
```c++
// _LDscale function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _LDscale(long double* px, long lexp) { // scale *px by 2^lexp with checking -- 64-bit
return _Dscale((double*) px, lexp);
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.26.28801/stl/xldscale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 79 |
```c++
// _Fiopen(const char */const wchar_t *, ios_base::openmode)
#include <fstream>
#include <Windows.h>
_STD_BEGIN
FILE* _Xfsopen(_In_z_ const char* filename, _In_ int mode, _In_ int prot) {
static const char* const mods[] = {// fopen mode strings corresponding to valid[i]
"r", "w", "w", "a", "rb",... | /content/code_sandbox/src/14.26.28801/stl/fiopen.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,072 |
```c++
// _LSinh function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
// coefficients
static const long double p[] = {0.0000000000000028486835L, 0.0000000000007646464279L, 0.0000000001605905091647L,
0.0000000250521083436962L, 0.0000027557319224130455L, 0.0001984126984126956009L, 0.0083333333333333336073L,
0.16... | /content/code_sandbox/src/14.26.28801/stl/xlsinh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 561 |
```c++
#include <cstdlib>
#include <exception>
#include <future>
_STD_BEGIN
[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Throw_future_error(const error_code& _Code) {
_THROW(future_error(_Code));
}
[[noreturn]] _CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Rethrow_future_exception(exception_ptr _Ptr) ... | /content/code_sandbox/src/14.26.28801/stl/future.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 105 |
```c++
// look up date ordering
#include "awint.h"
#include <locale>
_EXTERN_C_UNLESS_PURE
int __CLRCALL_PURE_OR_CDECL _Getdateorder() { // return date order for current locale
wchar_t buf[2] = {0};
//__crtGetLocaleInfoEx(___lc_locale_name_func()[LC_TIME], LOCALE_ILDATE, buf, sizeof(buf) / sizeof(buf[0]));
... | /content/code_sandbox/src/14.26.28801/stl/xdateord.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 203 |
```c++
// instantiations of iomanip
#include <iomanip>
_STD_BEGIN
// FUNCTION resetiosflags
static void __cdecl rsfun(ios_base& iostr, ios_base::fmtflags mask) { // reset specified format flags
iostr.setf(ios_base::_Fmtzero, mask);
}
// FUNCTION setiosflags
static void __cdecl sifun(ios_base& iostr, ios_base::fm... | /content/code_sandbox/src/14.26.28801/stl/iomanip.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 500 |
```objective-c
#pragma once
#ifndef _XMTX
#define _XMTX
#include <yvals.h>
#include <stdlib.h>
#include <Windows.h>
#pragma pack(push, _CRT_PACKING)
#pragma warning(push, 3)
#pragma push_macro("new")
#undef new
_EXTERN_C_UNLESS_PURE
using _Rmtx = CRITICAL_SECTION;
#ifdef _M_CEE_PURE
void __clrcall _Mtxinit(_Rmtx... | /content/code_sandbox/src/14.26.28801/stl/xmtx.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 257 |
```c++
// _LExp function
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
// coefficients
static const long double p[] = {42.038913947607355L, 10096.353102778762831L, 333228.767219512631062L};
static const long double q[] = {1.0L, 841.167880526530790L, 75730.834075476293976L, 666457.534439025262146L};
static const long do... | /content/code_sandbox/src/14.26.28801/stl/xlexp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 555 |
```c++
// xtime functions
#include "awint.h"
#include <stdlib.h>
#include <time.h>
#include <xtimec.h>
constexpr long _Nsec_per_sec = 1000000000L;
constexpr long _Nsec_per_msec = 1000000L;
constexpr int _Msec_per_sec = 1000;
static void xtime_normalize(xtime* xt) { // adjust so that 0 <= nsec < 1 000 000 000
... | /content/code_sandbox/src/14.26.28801/stl/xtime.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 970 |
```c++
// _FDunscale function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _FDunscale(short* pex, float* px) { // separate *px to 1/2 <= |frac| < 1 and 2^*pex
_Fval* ps = (_Fval*) (char*) px;
short xchar = (ps->_Sh[_F0] & _FMASK) >> _FOFF;
if (xchar == _FMAX) { // NaN or INF
... | /content/code_sandbox/src/14.26.28801/stl/xfdunsca.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 291 |
```c++
// set_new_handler
#include <new>
using new_hand = int(__cdecl*)(size_t);
extern "C" new_hand __cdecl _set_new_handler(new_hand);
_STD_BEGIN
static new_handler _New_handler;
int __cdecl _New_handler_interface(size_t) { // interface to existing Microsoft _callnewh mechanism
_New_handler();
return 1;... | /content/code_sandbox/src/14.26.28801/stl/stdhndlr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 216 |
```c++
// initialize standard wide output stream
#include <fstream>
#include <iostream>
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL static wfilebuf wfout(_cpp_stdout);
#if defined(_M_CEE_PURE)
__PURE_APPDOMA... | /content/code_sandbox/src/14.26.28801/stl/wcout.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 253 |
```c++
#include <ppltasks.h>
#if defined(_CRT_APP) || defined(UNDOCKED_WINDOWS_UCRT)
#include <RestrictedErrorInfo.h>
#include <ehdata.h>
#include <exception>
#include <roerrorapi.h>
#include <trnsctrl.h>
extern "C" void* __GetPlatformExceptionInfo(int*);
namespace Concurrency {
namespace details {
_C... | /content/code_sandbox/src/14.26.28801/stl/pplerror.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 374 |
```c++
// _Dint function -- IEEE 754 version
#include "xmath.h"
_EXTERN_C_UNLESS_PURE
short _Dint(double* px, short xexp) { // test and drop (scaled) fraction bits
_Dval* ps = (_Dval*) (char*) px;
unsigned short frac;
short xchar = (ps->_Sh[_D0] & _DMASK) >> _DOFF;
if (xchar == _DMAX) {
ret... | /content/code_sandbox/src/14.26.28801/stl/xdint.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 671 |
```c++
// _Stold function
#include <yvals.h> // include first, for native shared
#include "xmath.h"
#include "xxcctype.h"
#include "xxlftype.h"
#include <stdlib.h>
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _Stoldx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.h"
... | /content/code_sandbox/src/14.26.28801/stl/xstold.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 177 |
```c++
// initialize standard wide error stream (unsigned short version)
#ifdef _NATIVE_WCHAR_T_DEFINED
#include <fstream>
#ifndef wistream
#define wistream ushistream
#define wostream ushostream
#define wfilebuf ushfilebuf
#define _Init_wcerr _Init_ushcerr
#define _Init_wcout _Init_ushcout
#define _Init_wc... | /content/code_sandbox/src/14.26.28801/stl/ushclog.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 167 |
```c++
// _Execute_once function
#include "awint.h"
#include <mutex>
_STD_BEGIN
_CRTIMP2_PURE int __CLRCALL_PURE_OR_CDECL _Execute_once(
once_flag& _Flag, _Execute_once_fp_t _Callback, void* _Pv) noexcept { // wrap Win32 InitOnceExecuteOnce()
static_assert(sizeof(_Flag._Opaque) == sizeof(INIT_ONCE), "invalid... | /content/code_sandbox/src/14.26.28801/stl/xonce.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 196 |
```c++
// This implementation communicates with the EH runtime though vcruntime's per-thread-data structure; see
// _pCurrentException in <trnsctrl.h>.
//
// As a result, normal EH runtime services (such as noexcept functions) are safe to use in this file.
#ifndef _VCRT_ALLOW_INTERNALS
#define _VCRT_ALLOW_INTERNALS
#... | /content/code_sandbox/src/14.26.28801/stl/excptptr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 5,465 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.