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 |
|---|---|---|---|---|---|---|---|---|
```c++
// _FCosh function
#include "xmath.hpp"
_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;
... | /content/code_sandbox/src/14.28.29333/stl/xfcosh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 269 |
```c++
// _WStod function
#include <stdlib.h>
#include <wchar.h>
#include "xmath.hpp"
#include "xxdftype.hpp"
#include "xxwctype.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _WStodx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.hpp"
_CRTIMP2_PURE FTYPE __CLRC... | /content/code_sandbox/src/14.28.29333/stl/xwstod.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 171 |
```c++
// _Stoul function
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
// macros
constexpr int _Base_max = 36; // largest valid base
// static data
static const char digits[] = // valid digits
"... | /content/code_sandbox/src/14.28.29333/stl/xstoul.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 927 |
```c++
// _LXp* functions
#include "xmath.hpp"
#include "xxlftype.hpp"
#include "xxxprec.hpp"
``` | /content/code_sandbox/src/14.28.29333/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 <ctype.h>
#include <locale.h>
#include <stdlib.h>
#include "xmath.hpp"
_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
_In_range_(0, ... | /content/code_sandbox/src/14.28.29333/stl/xstoflt.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,064 |
```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 = nullp... | /content/code_sandbox/src/14.28.29333/stl/mpiostream.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 223 |
```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.28.29333/stl/syserror.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,770 |
```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.28.29333/stl/ios.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 869 |
```c++
// filesys.cpp -- <experimental/filesystem> implementation
// (see filesystem.cpp for C++17 <filesystem> implementation)
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
#include <yvals.h>
#include <direct.h>
#include <experimental/filesystem>
#include <io.h>
#include <string.h>
#include <Window... | /content/code_sandbox/src/14.28.29333/stl/filesys.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,690 |
```c++
// condition variable functions
#include <internal_shared.h>
#include <limits.h>
#include <stdlib.h>
#include <type_traits>
#include <xthreads.h>
#include <xtimec.h>
#include "primitives.hpp"
struct _Cnd_internal_imp_t { // condition variable implementation for ConcRT
std::aligned_storage_t<Concurrency::... | /content/code_sandbox/src/14.28.29333/stl/cond.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 986 |
```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.28.29333/stl/cout.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 254 |
```c++
// common _[FL]Dtento functionality
#include "xmath.hpp"
#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)
#if FB... | /content/code_sandbox/src/14.28.29333/stl/xxxdtent.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 859 |
```c++
// class locale wide member functions
#include <istream>
#include <locale>
_STD_BEGIN
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
// facets associated with C categories
#define ADDFAC(Facet, cat, ptrimp, ptrloc) \
if ((_CATMA... | /content/code_sandbox/src/14.28.29333/stl/wlocale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,074 |
```c++
// parameters for char character type
#define CTYPE char
#define CNAME(fun) _##fun
``` | /content/code_sandbox/src/14.28.29333/stl/xxcctype.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 24 |
```c++
// _Stod function
#include <yvals.h> // include first, for native shared
#include <stdlib.h>
#include "xmath.hpp"
#include "xxcctype.hpp"
#include "xxdftype.hpp"
_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.28.29333/stl/xstod.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 176 |
```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.28.29333/stl/vector_algorithms.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 6,520 |
```c++
// _Towlower -- convert wchar_t to lower case
#include <wchar.h>
#include <xlocinfo.h>
#include "awint.hpp"
_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.28.29333/stl/xtowlower.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 298 |
```c++
// _Stoll function
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include "xmath.hpp"
_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 c... | /content/code_sandbox/src/14.28.29333/stl/xstoll.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 427 |
```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.28.29333/stl/filesystem.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 12,818 |
```c++
// _Dtest function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
#if 0
_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Dtest(double* px) { // categorize *px
const auto ps = reinterpret_cast<_Dval*>(px);
if ((ps->_Sh[_D0] & _DMASK) == _DMAX << _DOFF) {
return static_cast<short>(... | /content/code_sandbox/src/14.28.29333/stl/xdtest.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 347 |
```c++
#include <internal_shared.h>
#include <Windows.h>
#include "awint.hpp"
#ifdef _CRT_APP
// free static resource used by causality
extern "C" void __cdecl __crtCleanupCausalityStaticFactories();
#endif // _CRT_APP
extern "C" BOOL APIENTRY DllMain(HMODULE /* hModule */, DWORD ul_reason_for_call, [[maybe_unused... | /content/code_sandbox/src/14.28.29333/stl/dllmain.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 153 |
```c++
// common extended precision functionality
#include <string.h>
#include "xmath.hpp"
#pragma warning(push)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
#if !defined(MRTDLL)
_EXTERN_C
#endif // defined(MRTDLL)
#define BIG_EXP (2 * FMAXEXP) // very large, as exponents go
#define BITS_WORD (FBITS / 2) /... | /content/code_sandbox/src/14.28.29333/stl/xxxprec.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,223 |
```c++
// _Stopfx function
#include <ctype.h>
#include "xmath.hpp"
_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(static_cast<unsigned char>(*s))) {
++s;
}
if (*s == '-'... | /content/code_sandbox/src/14.28.29333/stl/xstopfx.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 671 |
```c++
// _LPoly function
#include "xmath.hpp"
_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.28.29333/stl/xlpoly.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 90 |
```c++
// Transform a wide-character string using the locale information as set by LC_COLLATE.
#include <internal_shared.h>
#include <limits.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec, _Wcsxfrm
#include "awint.hpp"
_EXTERN_C_UNLESS_PURE
// size_t _Wcsxfrm()... | /content/code_sandbox/src/14.28.29333/stl/xwcsxfrm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,073 |
```c++
// Compare two strings using the locale LC_COLLATE information.
#include <crtdbg.h>
#include <errno.h>
#include <locale.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec, _Strcoll
#include "awint.hpp"
_EXTERN_C_UNLESS_PURE
// int _Strcoll() - Collate locale... | /content/code_sandbox/src/14.28.29333/stl/xstrcoll.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 707 |
```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*) noexc... | /content/code_sandbox/src/14.28.29333/stl/xmtx.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 257 |
```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.28.29333/stl/xmbtowc.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,424 |
```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.28.29333/stl/ppltasks.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,277 |
```c++
// support for <execution>
#include <internal_shared.h>
#include <thread>
#include <xatomic_wait.h>
namespace {
unsigned char _Atomic_load_uchar(const volatile unsigned char* _Ptr) noexcept {
// atomic load of unsigned char, copied from <atomic> except ARM and ARM64 bits
unsigned char _Val... | /content/code_sandbox/src/14.28.29333/stl/parallel_algorithms.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 568 |
```c++
// _Xp* functions
#include "xmath.hpp"
#include "xxdftype.hpp"
#include "xxxprec.hpp"
``` | /content/code_sandbox/src/14.28.29333/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.hpp"
_EXTERN_C_UNLESS_PURE
short _LDint(long double* px, short xexp) { // test and drop (scaled) fraction bits -- 64-bit
return _Dint(reinterpret_cast<double*>(px), xexp);
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.28.29333/stl/xldint.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 77 |
```c++
// _LDtento function -- IEEE 754 version
#include "xxlftype.hpp"
#include "xxxdtent.hpp"
``` | /content/code_sandbox/src/14.28.29333/stl/xldtento.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 28 |
```c++
// TRANSITION, ABI: The functions in this file are preserved for binary compatibility
#include <stdexcept>
#include <Windows.h>
#include "awint.hpp"
namespace stdext {
namespace threads {
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Mtx_new(void*& _Ptr) {
_Ptr = new CRITICAL_SECTION;... | /content/code_sandbox/src/14.28.29333/stl/xalloc.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 254 |
```c++
// convert character to lower case
#include <yvals.h>
#include <ctype.h>
#include <internal_shared.h>
#include <locale.h>
#include <stddef.h>
#include <stdlib.h>
#include <xlocinfo.h>
#include "awint.hpp"
// remove macro definitions of _tolower() and tolower()
#undef _tolower
#undef tolower
_EXTERN_C_UNLES... | /content/code_sandbox/src/14.28.29333/stl/_tolower.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 921 |
```c++
// _FDnorm function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _FDnorm(_Fval* ps) { // normalize float fraction
short xchar;
unsigned short sign = static_cast<unsigned short>(ps->_Sh[_F0] & _FSIGN);
xchar = 1;
if ((ps->_Sh[_F0] &= _FFRAC) != 0 || ps->_Sh[_F1]) { // ... | /content/code_sandbox/src/14.28.29333/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.28.29333/stl/wiostrea.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 205 |
```c++
// _WStoxflt function
#include <ctype.h>
#include <locale.h>
#include <wchar.h>
#include <wctype.h>
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
constexpr int _Base = 16; // hexadecimal
constexpr int _Ndig = 7; // hexadecimal digits per long element
constexpr int _Maxsig = 5 * _Ndig; // maximum significan... | /content/code_sandbox/src/14.28.29333/stl/xwstoxfl.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,284 |
```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.28.29333/stl/special_math.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,786 |
```c++
// _Exp function
#include "xmath.hpp"
_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 d... | /content/code_sandbox/src/14.28.29333/stl/xexp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 511 |
```c++
// values used by math functions -- IEEE 754 long version
#if defined(_M_CEE_PURE)
#if defined(MRTDLL)
#undef MRTDLL
#endif
#endif
#include "xmath.hpp"
// 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 /* ... | /content/code_sandbox/src/14.28.29333/stl/xlvalues.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 292 |
```c++
// _Sinh function
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
// coefficients
static constexpr 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]) -... | /content/code_sandbox/src/14.28.29333/stl/xsinh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 495 |
```c++
// Transform a string using the locale information as set by LC_COLLATE.
#include <limits.h>
#include <locale.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <xlocinfo.h> // for _Collvec
#include <Windows.h>
#include "awint.hpp"
_EXTERN_C_UNLESS_PURE
// size_t _Strxfrm() - Transform... | /content/code_sandbox/src/14.28.29333/stl/xstrxfrm.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 832 |
```c++
// _FDtest function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
#if 0
_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _FDtest(float* px) { // categorize *px
const auto ps = reinterpret_cast<_Fval*>(px);
if ((ps->_Sh[_F0] & _FMASK) == _FMAX << _FOFF) {
return static_cast<short>... | /content/code_sandbox/src/14.28.29333/stl/xfdtest.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 299 |
```c++
#include <crtdbg.h>
#include <internal_shared.h>
#include <string.h>
#include <Windows.h>
#include "awint.hpp"
// int __cdecl __crtCompareStringW - Get type information about a wide string.
//
// Purpose:
// Internal support function. Assumes info in wide string format.
//
// Entry:
// LPCWSTR LocaleNam... | /content/code_sandbox/src/14.28.29333/stl/StlCompareStringW.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 479 |
```c++
// _Stof function
#include <yvals.h> // include first, for native shared
#include <stdlib.h>
#include "xmath.hpp"
#include "xxcctype.hpp"
#include "xxfftype.hpp"
_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.28.29333/stl/xstof.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 176 |
```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
_MRTIMP2_PURE locale __CLRCALL_PURE_OR_CDECL locale::global... | /content/code_sandbox/src/14.28.29333/stl/locale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,738 |
```c++
// values used by math functions -- IEEE 754 float version
#if defined(_M_CEE_PURE)
#if defined(MRTDLL)
#undef MRTDLL
#endif
#endif
#include "xmath.hpp"
// 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.28.29333/stl/xfvalues.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 291 |
```c++
// _LDscale function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _LDscale(long double* px, long lexp) { // scale *px by 2^lexp with checking -- 64-bit
return _Dscale(reinterpret_cast<double*>(px), lexp);
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.28.29333/stl/xldscale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 80 |
```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.28.29333/stl/fiopen.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,063 |
```c++
// _LSinh function
#include "xmath.hpp"
_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.... | /content/code_sandbox/src/14.28.29333/stl/xlsinh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 561 |
```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 static_cast<int>(_DMAX * 900L / 1000)
// IE... | /content/code_sandbox/src/14.28.29333/stl/xmath.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,509 |
```c++
// look up date ordering
#include <locale>
#include "awint.hpp"
_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.28.29333/stl/xdateord.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 203 |
```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
#define F... | /content/code_sandbox/src/14.28.29333/stl/xxlftype.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 152 |
```c++
// _LExp function
#include "xmath.hpp"
_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 ... | /content/code_sandbox/src/14.28.29333/stl/xlexp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 558 |
```c++
// xtime functions
#include <atomic>
#include <stdlib.h>
#include <time.h>
#include <xtimec.h>
#include "awint.hpp"
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 <= nse... | /content/code_sandbox/src/14.28.29333/stl/xtime.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,038 |
```c++
// _FDunscale function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _FDunscale(short* pex, float* px) { // separate *px to 1/2 <= |frac| < 1 and 2^*pex
const auto ps = reinterpret_cast<_Fval*>(px);
short xchar = (ps->_Sh[_F0] & _FMASK) >> _FOFF;
if (xchar == _FMAX) { //... | /content/code_sandbox/src/14.28.29333/stl/xfdunsca.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 288 |
```c++
// parameters for double floating-point type
#include <yvals.h>
#include <float.h>
#define FTYPE double
#define FBITS DBL_MANT_DIG
#define FMAXEXP DBL_MAX_EXP
#define FFUN(fun) fun
#define FNAME(fun) _##fun
#define FCONST(obj) _##obj._Double
#define FLIT(lit) lit
#define FPMSW(x) (*_Pmsw(&(x)))
#d... | /content/code_sandbox/src/14.28.29333/stl/xxdftype.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 141 |
```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.28.29333/stl/stdhndlr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 219 |
```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.28.29333/stl/wcout.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 250 |
```c++
// _Dint function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _Dint(double* px, short xexp) { // test and drop (scaled) fraction bits
const auto ps = reinterpret_cast<_Dval*>(px);
short xchar = (ps->_Sh[_D0] & _DMASK) >> _DOFF;
if (xchar == _DMAX) {
return (ps-... | /content/code_sandbox/src/14.28.29333/stl/xdint.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 666 |
```c++
// _Stold function
#include <yvals.h> // include first, for native shared
#include <stdlib.h>
#include "xmath.hpp"
#include "xxcctype.hpp"
#include "xxlftype.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _Stoldx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod... | /content/code_sandbox/src/14.28.29333/stl/xstold.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 176 |
```c++
// _Execute_once function
#include <mutex>
#include "awint.hpp"
_STD_BEGIN
// TRANSITION, ABI
_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) == sizeo... | /content/code_sandbox/src/14.28.29333/stl/xonce.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 201 |
```c++
// parameters for wchar_t character type
#define CTYPE wchar_t
#define CNAME(fun) _W##fun
``` | /content/code_sandbox/src/14.28.29333/stl/xxwctype.hpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 27 |
```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.28.29333/stl/excptptr.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 6,054 |
```c++
// _Dscale function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _Dscale(double* px, long lexp) { // scale *px by 2^xexp with checking
const auto ps = reinterpret_cast<_Dval*>(px);
short xchar = static_cast<short>((ps->_Sh[_D0] & _DMASK) >> _DOFF);
if (xchar == _DMAX) {... | /content/code_sandbox/src/14.28.29333/stl/xdscale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,015 |
```c++
// clang-format off
// Prevent clang-format from reordering <AppModel.h> before <Windows.h>
#include <Windows.h>
#include <AppModel.h>
#include "awint.hpp"
#include <internal_shared.h>
#include <stdlib.h>
// clang-format on
#pragma warning(push)
#pragma warning(disable : 4265) // non-virtual destructor in base... | /content/code_sandbox/src/14.28.29333/stl/winapisupp.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 6,458 |
```c++
// _Poly function
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
double _Poly(double x, const double* tab, int n) { // compute polynomial
double y;
for (y = *tab; 0 <= --n;) {
y = y * x + *++tab;
}
return y;
}
_END_EXTERN_C_UNLESS_PURE
``` | /content/code_sandbox/src/14.28.29333/stl/xpoly.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 84 |
```c++
// _Getwctype -- return character classification flags for wide character
#include <yvals.h>
#include <wchar.h>
#include <xlocinfo.h>
#include "awint.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Getwctype(wchar_t _Ch,
const _Ctypevec* _Ctype) { // return character classificat... | /content/code_sandbox/src/14.28.29333/stl/xgetwctype.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 428 |
```c++
#include <Windows.h>
// DllMain for 'satellite' DLLs which don't need TLS.
extern "C" BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID) {
if (ul_reason_for_call == DLL_PROCESS_ATTACH) {
if (!DisableThreadLibraryCalls(hModule)) {
return FALSE;
}
}
... | /content/code_sandbox/src/14.28.29333/stl/dllmain_satellite.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 86 |
```c++
// class locale exotic char member functions
#include <istream>
#include <locale>
_STD_BEGIN
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
// facets associated with C categories
#define ADDFAC(Facet, cat, ptrimp, ptrloc) \
if (... | /content/code_sandbox/src/14.28.29333/stl/xlocale.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 448 |
```c++
// _WStof function
#include <wchar.h>
#include "xmath.hpp"
#include "xxfftype.hpp"
#include "xxwctype.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL _WStofx(const CTYPE* s, CTYPE** endptr, long pten, int* perr)
#include "xxstod.hpp"
_CRTIMP2_PURE FTYPE __CLRCALL_PURE_OR_CDECL
... | /content/code_sandbox/src/14.28.29333/stl/xwstof.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 166 |
```c++
// ios::Init members
#include <iostream>
_STD_BEGIN
// OBJECT DECLARATIONS
__PURE_APPDOMAIN_GLOBAL int ios_base::Init::_Init_cnt = -1;
int& ios_base::Init::_Init_cnt_func() {
return ios_base::Init::_Init_cnt;
}
_CRTIMP2_PURE void __cdecl ios_base::Init::_Init_ctor(ios_base::Init*) { // initialize standar... | /content/code_sandbox/src/14.28.29333/stl/iostream.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 235 |
```c++
// _LCosh function
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE long double __CLRCALL_PURE_OR_CDECL _LCosh(
long double x, long double y) { // compute y * cosh(x), |y| <= 1
switch (_LDtest(&x)) { // test for special codes
case _NANCODE:
case _INFCODE:
return x;
case 0:... | /content/code_sandbox/src/14.28.29333/stl/xlcosh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 276 |
```c++
// class locale basic member functions
#include <crtdbg.h>
#include <internal_shared.h>
#include <xfacet>
// 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_s... | /content/code_sandbox/src/14.28.29333/stl/locale0.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,805 |
```c++
// _Cosh function
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
_CRTIMP2_PURE double __CLRCALL_PURE_OR_CDECL _Cosh(double x, double y) { // compute y * cosh(x), |y| <= 1
switch (_Dtest(&x)) { // test for special codes
case _NANCODE:
case _INFCODE:
return x;
case 0:
return y;
... | /content/code_sandbox/src/14.28.29333/stl/xcosh.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 265 |
```c++
// _FDtento function -- IEEE 754 version
#include "xxfftype.hpp"
#include "xxxdtent.hpp"
``` | /content/code_sandbox/src/14.28.29333/stl/xfdtento.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 28 |
```c++
// implement atomic wait / notify_one / notify_all
// clang-format off
#include <atomic>
#include <cstdint>
#include <new>
#include <thread>
#include <Windows.h>
// clang-format on
namespace {
constexpr size_t _Wait_table_size_power = 8;
constexpr size_t _Wait_table_size = 1 << _Wait_table_si... | /content/code_sandbox/src/14.28.29333/stl/atomic_wait.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,114 |
```c++
// _FDint function -- IEEE 754 version
#include "xmath.hpp"
_EXTERN_C_UNLESS_PURE
short _FDint(float* px, short xexp) { // test and drop (scaled) fraction bits
const auto ps = reinterpret_cast<_Fval*>(px);
short xchar = (ps->_Sh[_F0] & _FMASK) >> _FOFF;
if (xchar == _FMAX) {
return (ps... | /content/code_sandbox/src/14.28.29333/stl/xfdint.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 527 |
```c++
// global lock for locales, etc.
#include <yvals.h>
#include <locale.h>
#include <stdlib.h>
#include "xmtx.hpp"
_STD_BEGIN
constexpr int _Max_lock = 8; // must be power of two
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static _Rmtx mtx[_Max_lock];
static long init = -1;
#if !defined(MRTD... | /content/code_sandbox/src/14.28.29333/stl/xlock.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 896 |
```c++
#include <condition_variable>
#include <mutex>
#include <ppltaskscheduler.h>
#include <stddef.h>
#include <Windows.h>
#include "awint.hpp"
#pragma warning(disable : 4074)
#pragma init_seg(compiler)
static std::_Init_locks initlocks;
extern "C" IMAGE_DOS_HEADER __ImageBase;
namespace Concurrency {
name... | /content/code_sandbox/src/14.28.29333/stl/taskscheduler.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,025 |
```objective-c
#define LTL_ProductVersion "14.28.29333.0"
#include "Shared-Resource.h"
``` | /content/code_sandbox/src/14.28.29333/Build/resource.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 24 |
```assembly
;***
;handlers.asm
;
;
;*******************************************************************************
include ksamd64.inc
EXTRN _NLG_Notify:PROC
EXTRN __NLG_Return2:PROC
;;++
;;
;;extern "C" void* _CallSettingFrame(
;; void* handler,
;; EHRegistrationNode *pEstablisher,
;; ... | /content/code_sandbox/src/14.10.25017/x64/handlers.asm | assembly | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 469 |
```c++
//
// legacy_stdio_wide_specifiers.cpp
//
//
// Configures the stdio library to use the legacy %s, %c, and %[] specifiers for
// the wide string printf and scanf functions. The conforming (default) behavior
// is that these format specifiers map to a narrow character buffer; the 'l' length
// modifier must be u... | /content/code_sandbox/src/14.10.25017/linkopts/legacy_stdio_wide_specifiers.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 375 |
```c++
//
// iso_stdio_wide_specifiers.cpp
//
//
// Configures the stdio library to use the confroming %s, %c, and %[] specifiers for
// the wide string printf and scanf functions. The conforming behavior
// is that these format specifiers map to a narrow character buffer; the 'l' length
// modifier must be used when ... | /content/code_sandbox/src/14.10.25017/linkopts/iso_stdio_wide_specifiers.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 359 |
```c++
//
// invalidcontinue.cpp
//
//
// A link option that sets the invalid parameter to an empty function.
//
#include <stdlib.h>
#include <vcruntime.h>
static void empty_invalid_parameter_handler(
wchar_t const* pszExpression,
wchar_t const* pszFunction,
wchar_t const* pszFile,
unsigned int nLi... | /content/code_sandbox/src/14.10.25017/linkopts/invalidcontinue.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 219 |
```c++
//
// notelemetry.cpp
//
//
// A link option that disables the module startup and shutdown telemetry calls.
//
#include <windows.h>
extern "C" void __cdecl __vcrt_initialize_telemetry_provider()
{
}
extern "C" void __cdecl __vcrt_uninitialize_telemetry_provider()
{
}
extern "C" void __cdecl __telemetry_main... | /content/code_sandbox/src/14.10.25017/linkopts/notelemetry.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 102 |
```c
/*++
Module Name:
helpexcept.c
Abstract:
This module contains support routines for generating exceptions
for helper functions.
Author:
Aaron Giles (aarongi) 26-March-2010
--*/
#include <Windows.h>
#include "fpieee.h"
#define CPVFP_FPSCR 10, 7, 1, 0, 0
UINT64
__fphelper_raise... | /content/code_sandbox/src/14.10.25017/arm/helpexcept.c | c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,768 |
```c++
//
// All rights reserved.
//
#include "pch.h"
CPPCLI_FUNC void __stdcall FlushFactoryCache();
CPPCLI_FUNC void EnableFactoryCache();
void DisableFactoryCache();
__abi_Module* __abi_module = nullptr;
#include "crtdefs.h"
#include <corecrt_startup.h>
__declspec(noreturn) __declspec(dllexport) void __stdcall ... | /content/code_sandbox/src/14.10.25017/vccorlib/vccorlib.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 715 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#include <string>
#include <map>
#include <unordered_map>
#include <vector>
#include "activation.h"
#pragma hdrstop
#include <Strsafe.h>
#include <memory>
#include <combaseapi.h>
using namespace Microsoft::WRL;
using namespace std;
struct conditional_deleter
{
... | /content/code_sandbox/src/14.10.25017/vccorlib/vcwinrt.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,353 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#pragma warning( disable: 4073 ) // initializers put in library initialization area
#pragma init_seg( lib )
#include <restrictederrorinfo.h>
#include <roerrorapi.h>
int __abi___threading_model = _VCCORLIB_THREADING_MODEL_DEFAULT;
__abi_Module* __abi_module = nul... | /content/code_sandbox/src/14.10.25017/vccorlib/init.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,235 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#include <wrl\wrappers\corewrappers.h>
#include <wrl\client.h>
#include <agile.h>
#include <memory>
#include <roerrorapi.h>
#pragma hdrstop
namespace Platform { namespace Details {
typedef struct {
SRWLOCK targetsLock;
SRWLOCK addRemoveLock;
} EventLockInte... | /content/code_sandbox/src/14.10.25017/vccorlib/eventsource.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,845 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#pragma hdrstop
#include <windows.h>
#include <windows.foundation.h>
#include <roerrorapi.h>
typedef ABI::Windows::Foundation::IPropertyValue IPropertyValue;
namespace Platform { namespace Details {
// To extract valid IInspectable interface pointer we need t... | /content/code_sandbox/src/14.10.25017/vccorlib/box.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 9,488 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#include <wrl/wrappers/corewrappers.h>
#include <windows.applicationmodel.core.h>
#include <wchar.h>
// 4297 suppressed due to bug 845826
#pragma warning(disable: 4672 4673 4297)
using namespace Microsoft::WRL;
namespace Platform {
namespace Details {
#ifdef ... | /content/code_sandbox/src/14.10.25017/vccorlib/outofprocmodule.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,222 |
```c++
//
// All rights reserved.
//
#include "pch.h"
#pragma hdrstop
#include <memory>
#include <restrictederrorinfo.h>
#include <roerrorapi.h>
#include <string>
#pragma warning(disable:4483)
template <class _E> void *__GetExceptionInfo(_E); // This is a built-in c1xx template function to get the
// ThrowInfo for... | /content/code_sandbox/src/14.10.25017/vccorlib/exceptions.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 4,964 |
```c++
/***
*crtexe.c - Initialization for console EXE using CRT DLL
*
*
*Purpose:
* This is the actual startup routine for apps linking to the CRT DLL.
* It calls the user's main routine [w]main() or [w]WinMain after
* performing C Run-Time Library initialization.
*
* With ifdefs, this source f... | /content/code_sandbox/src/14.10.25017/vcruntime/mcrtexe.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,703 |
```objective-c
/***
*minternal.h - contains declarations of managed internal routines and variables
*
*
*Purpose:
* Declares routines and variables used internally by the C run-time.
*
* [Internal]
*
****/
//
// _CPP_MSTARTUP indicates that the file is included from mstartup.cpp
// _PARTIAL_TRUST_OBJ... | /content/code_sandbox/src/14.10.25017/vcruntime/minternal.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 3,241 |
```c
/***
*gs_support.c - initialize the global buffer overrun security cookie
*
*
*Purpose:
* Define __security_init_cookie, which is called at startup to initialize
* the global buffer overrun security cookie used by the /GS compile flag.
*
*****************************************************************... | /content/code_sandbox/src/14.10.25017/vcruntime/gs_support.c | c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 1,141 |
```c++
//
// winapi_downlevel.cpp
//
//
// Definitions of wrappers for Windows API functions that cannot be called
// directly because they are not available on all supported operating systems.
//
#include <vcruntime_internal.h>
#if defined _VCRT_WINDOWS_BUILD || (!defined _ONECORE && _VCRT_WIN32_WINNT < _WIN32_WINNT_... | /content/code_sandbox/src/14.10.25017/vcruntime/winapi_downlevel.cpp | c++ | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,738 |
```objective-c
//
// vcruntime_internal.h
//
//
// Declarations and definitions of things used internally by the VCRuntime.
//
#pragma once
#if !defined _VCRT_BUILD && !defined _VCRT_ALLOW_INTERNALS
// This is an internal C Runtime header file. It is used when building the
// C Runtime only. It is not to be ... | /content/code_sandbox/src/14.10.25017/vcruntime/vcruntime_internal.h | objective-c | 2016-06-14T03:01:16 | 2024-08-12T19:23:19 | VC-LTL | Chuyu-Team/VC-LTL | 1,052 | 2,534 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.