Buckets:
| // Macro to use C++ static_cast<> in the Python C API. | |
| // Macro to use the more powerful/dangerous C-style cast even in C++. | |
| // Static inline functions should use _Py_NULL rather than using directly NULL | |
| // to prevent C++ compiler warnings. On C23 and newer and on C++11 and newer, | |
| // _Py_NULL is defined as nullptr. | |
| /* Defines to build Python and its standard library: | |
| * | |
| * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but | |
| * should not be used by third-party modules. | |
| * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. | |
| * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. | |
| * | |
| * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. | |
| * | |
| * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas | |
| * Py_BUILD_CORE_BUILTIN does not. | |
| */ | |
| /************************************************************************** | |
| Symbols and macros to supply platform-independent interfaces to basic | |
| C language & library operations whose spellings vary across platforms. | |
| Please try to make documentation here as clear as possible: by definition, | |
| the stuff here is trying to illuminate C's darkest corners. | |
| Config #defines referenced here: | |
| SIGNED_RIGHT_SHIFT_ZERO_FILLS | |
| Meaning: To be defined iff i>>j does not extend the sign bit when i is a | |
| signed integral type and i < 0. | |
| Used in: Py_ARITHMETIC_RIGHT_SHIFT | |
| Py_DEBUG | |
| Meaning: Extra checks compiled in for debug mode. | |
| Used in: Py_SAFE_DOWNCAST | |
| **************************************************************************/ | |
| /* typedefs for some C9X-defined synonyms for integral types. | |
| * | |
| * The names in Python are exactly the same as the C9X names, except with a | |
| * Py_ prefix. Until C9X is universally implemented, this is the only way | |
| * to ensure that Python gets reliable names that don't conflict with names | |
| * in non-Python code that are playing their own tricks to define the C9X | |
| * names. | |
| * | |
| * NOTE: don't go nuts here! Python has no use for *most* of the C9X | |
| * integral synonyms. Only define the ones we actually need. | |
| */ | |
| /* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */ | |
| /* If LLONG_MAX is defined in limits.h, use that. */ | |
| /* Signed variants of the above */ | |
| /* PYLONG_BITS_IN_DIGIT describes the number of bits per "digit" (limb) in the | |
| * PyLongObject implementation (longintrepr.h). It's currently either 30 or 15, | |
| * defaulting to 30. The 15-bit digit option may be removed in the future. | |
| */ | |
| /* uintptr_t is the C9X name for an unsigned integral type such that a | |
| * legitimate void* can be cast to uintptr_t and then back to void* again | |
| * without loss of information. Similarly for intptr_t, wrt a signed | |
| * integral type. | |
| */ | |
| typedef uintptr_t Py_uintptr_t; | |
| typedef intptr_t Py_intptr_t; | |
| /* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) == | |
| * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an | |
| * unsigned integral type). See PEP 353 for details. | |
| * PY_SSIZE_T_MAX is the largest positive value of type Py_ssize_t. | |
| */ | |
| typedef ssize_t Py_ssize_t; | |
| typedef Py_intptr_t Py_ssize_t; | |
| /* Smallest negative value of type Py_ssize_t. */ | |
| /* Py_hash_t is the same size as a pointer. */ | |
| typedef Py_ssize_t Py_hash_t; | |
| /* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */ | |
| typedef size_t Py_uhash_t; | |
| /* Now PY_SSIZE_T_CLEAN is mandatory. This is just for backward compatibility. */ | |
| typedef Py_ssize_t Py_ssize_clean_t; | |
| /* Largest possible value of size_t. */ | |
| /* Macro kept for backward compatibility: use directly "z" in new code. | |
| * | |
| * PY_FORMAT_SIZE_T is a modifier for use in a printf format to convert an | |
| * argument with the width of a size_t or Py_ssize_t: "z" (C99). | |
| */ | |
| /* Py_LOCAL can be used instead of static to get the fastest possible calling | |
| * convention for functions that are local to a given module. | |
| * | |
| * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining, | |
| * for platforms that support that. | |
| * | |
| * NOTE: You can only use this for functions that are entirely local to a | |
| * module; functions that are exported via method tables, callbacks, etc, | |
| * should keep using static. | |
| */ | |
| /* ignore warnings if the compiler decides not to inline a function */ | |
| /* fastest possible local call under MSVC */ | |
| /* Move this down here since some C++ #include's don't like to be included | |
| inside an extern "C" */ | |
| extern "C" { | |
| /* Py_ARITHMETIC_RIGHT_SHIFT | |
| * C doesn't define whether a right-shift of a signed integer sign-extends | |
| * or zero-fills. Here a macro to force sign extension: | |
| * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) | |
| * Return I >> J, forcing sign extension. Arithmetically, return the | |
| * floor of I/2**J. | |
| * Requirements: | |
| * I should have signed integer type. In the terminology of C99, this can | |
| * be either one of the five standard signed integer types (signed char, | |
| * short, int, long, long long) or an extended signed integer type. | |
| * J is an integer >= 0 and strictly less than the number of bits in the | |
| * type of I (because C doesn't define what happens for J outside that | |
| * range either). | |
| * TYPE used to specify the type of I, but is now ignored. It's been left | |
| * in for backwards compatibility with versions <= 2.6 or 3.0. | |
| * Caution: | |
| * I may be evaluated more than once. | |
| */ | |
| /* Py_FORCE_EXPANSION(X) | |
| * "Simply" returns its argument. However, macro expansions within the | |
| * argument are evaluated. This unfortunate trickery is needed to get | |
| * token-pasting to work as desired in some cases. | |
| */ | |
| /* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) | |
| * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this | |
| * assert-fails if any information is lost. | |
| * Caution: | |
| * VALUE may be evaluated more than once. | |
| */ | |
| /* Py_DEPRECATED(version) | |
| * Declare a variable, type, or function deprecated. | |
| * The macro must be placed before the declaration. | |
| * Usage: | |
| * Py_DEPRECATED(3.3) extern int old_var; | |
| * Py_DEPRECATED(3.4) typedef int T1; | |
| * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); | |
| */ | |
| // _Py_DEPRECATED_EXTERNALLY(version) | |
| // Deprecated outside CPython core. | |
| /* _Py_HOT_FUNCTION | |
| * The hot attribute on a function is used to inform the compiler that the | |
| * function is a hot spot of the compiled program. The function is optimized | |
| * more aggressively and on many target it is placed into special subsection of | |
| * the text section so all hot functions appears close together improving | |
| * locality. | |
| * | |
| * Usage: | |
| * int _Py_HOT_FUNCTION x(void) { return 3; } | |
| * | |
| * Issue #28618: This attribute must not be abused, otherwise it can have a | |
| * negative effect on performance. Only the functions were Python spend most of | |
| * its time must use it. Use a profiler when running performance benchmark | |
| * suite to find these functions. | |
| */ | |
| // Ask the compiler to always inline a static inline function. The compiler can | |
| // ignore it and decides to not inline the function. | |
| // | |
| // It can be used to inline performance critical static inline functions when | |
| // building Python in debug mode with function inlining disabled. For example, | |
| // MSC disables function inlining when building in debug mode. | |
| // | |
| // Marking blindly a static inline function with Py_ALWAYS_INLINE can result in | |
| // worse performances (due to increased code size for example). The compiler is | |
| // usually smarter than the developer for the cost/benefit analysis. | |
| // | |
| // If Python is built in debug mode (if the Py_DEBUG macro is defined), the | |
| // Py_ALWAYS_INLINE macro does nothing. | |
| // | |
| // It must be specified before the function return type. Usage: | |
| // | |
| // static inline Py_ALWAYS_INLINE int random(void) { return 4; } | |
| // If Python is built in debug mode, usually compiler optimizations are | |
| // disabled. In this case, Py_ALWAYS_INLINE can increase a lot the stack | |
| // memory usage. For example, forcing inlining using gcc -O0 increases the | |
| // stack usage from 6 KB to 15 KB per Python function call. | |
| // Py_NO_INLINE | |
| // Disable inlining on a function. For example, it reduces the C stack | |
| // consumption: useful on LTO+PGO builds which heavily inline code (see | |
| // bpo-33720). | |
| // | |
| // Usage: | |
| // | |
| // Py_NO_INLINE static int random(void) { return 4; } | |
| // The internal C API must not be used with the limited C API: make sure | |
| // that Py_BUILD_CORE macro is not defined in this case. These 3 macros are | |
| // used by exports.h, so only undefine them afterwards. | |
| /* limits.h constants that may be missing */ | |
| /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent | |
| * 32-bit platforms using gcc. We try to catch that here at compile-time | |
| * rather than waiting for integer multiplication to trigger bogus | |
| * overflows. | |
| */ | |
| } | |
| /* | |
| * Hide GCC attributes from compilers that don't support them. | |
| */ | |
| /* | |
| * Specify alignment on compilers that support it. | |
| */ | |
| /* Eliminate end-of-loop code not reached warnings from SunPro C | |
| * when using do{...}while(0) macros | |
| */ | |
| /* | |
| * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is | |
| * detected by configure and defined in pyconfig.h. The code in pyconfig.h | |
| * also takes care of Apple's universal builds. | |
| */ | |
| /* The Android langinfo.h header is not used. */ | |
| /* Maximum value of the Windows DWORD type */ | |
| /* This macro used to tell whether Python was built with multithreading | |
| * enabled. Now multithreading is always enabled, but keep the macro | |
| * for compatibility. | |
| */ | |
| /* Some WebAssembly platforms do not provide a working pthread implementation. | |
| * Thread support is stubbed and any attempt to create a new thread fails. | |
| */ | |
| // fall back to the PyThread_tss_*() API, or ignore. | |
| // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. | |
| // See _Py_GetLocaleEncoding(), PyUnicode_DecodeLocale() | |
| // and PyUnicode_EncodeLocale(). | |
| // Use UTF-8 as the filesystem encoding. | |
| // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), | |
| // Py_DecodeLocale() and Py_EncodeLocale(). | |
| /* Mark a function which cannot return. Example: | |
| PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); | |
| XLC support is intentionally omitted due to bpo-40244 */ | |
| // Preprocessor check for a builtin preprocessor function. Always return 0 | |
| // if __has_builtin() macro is not defined. | |
| // | |
| // __has_builtin() is available on clang and GCC 10. | |
| // Preprocessor check for a compiler __attribute__. Always return 0 | |
| // if __has_attribute() macro is not defined. | |
| // _Py_TYPEOF(expr) gets the type of an expression. | |
| // | |
| // Example: _Py_TYPEOF(x) x_copy = (x); | |
| // | |
| // The macro is only defined if GCC or clang compiler is used. | |
| /* A convenient way for code to know if sanitizers are enabled. */ | |
| /* AIX has __bool__ redefined in it's system header file. */ | |
| // Make sure we have maximum alignment, even if the current compiler | |
| // does not support max_align_t. Note that: | |
| // - Autoconf reports alignment of unknown types to 0. | |
| // - 'long double' has maximum alignment on *most* platforms, | |
| // looks like the best we can do for pre-C11 compilers. | |
| // - The value is tested, see test_alignof_max_align_t | |
| // _Py_NONSTRING: The nonstring variable attribute specifies that an object or | |
| // member declaration with type array of char, signed char, or unsigned char, | |
| // or pointer to such a type is intended to store character arrays that do not | |
| // necessarily contain a terminating NUL. | |
| // | |
| // Usage: | |
| // | |
| // char name [8] _Py_NONSTRING; | |
Xet Storage Details
- Size:
- 20.3 kB
- Xet hash:
- 2eb5e176cc0fdc8536f688bff0872429fed67a829fe7ce2e6235424d6ace6070
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.