112391Sjason@lowepower.com/* 212391Sjason@lowepower.com pybind11/detail/internals.h: Internal data structure and related functions 312391Sjason@lowepower.com 412391Sjason@lowepower.com Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch> 512391Sjason@lowepower.com 612391Sjason@lowepower.com All rights reserved. Use of this source code is governed by a 712391Sjason@lowepower.com BSD-style license that can be found in the LICENSE file. 812391Sjason@lowepower.com*/ 912391Sjason@lowepower.com 1012391Sjason@lowepower.com#pragma once 1112391Sjason@lowepower.com 1212391Sjason@lowepower.com#include "../pytypes.h" 1312391Sjason@lowepower.com 1412391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE) 1512391Sjason@lowepower.comNAMESPACE_BEGIN(detail) 1612391Sjason@lowepower.com// Forward declarations 1712391Sjason@lowepower.cominline PyTypeObject *make_static_property_type(); 1812391Sjason@lowepower.cominline PyTypeObject *make_default_metaclass(); 1912391Sjason@lowepower.cominline PyObject *make_object_base_type(PyTypeObject *metaclass); 2012391Sjason@lowepower.com 2114299Sbbruce@ucdavis.edu// The old Python Thread Local Storage (TLS) API is deprecated in Python 3.7 in favor of the new 2214299Sbbruce@ucdavis.edu// Thread Specific Storage (TSS) API. 2314299Sbbruce@ucdavis.edu#if PY_VERSION_HEX >= 0x03070000 2414299Sbbruce@ucdavis.edu# define PYBIND11_TLS_KEY_INIT(var) Py_tss_t *var = nullptr 2514299Sbbruce@ucdavis.edu# define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get((key)) 2614299Sbbruce@ucdavis.edu# define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set((key), (value)) 2714299Sbbruce@ucdavis.edu# define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set((key), nullptr) 2814299Sbbruce@ucdavis.edu#else 2914299Sbbruce@ucdavis.edu // Usually an int but a long on Cygwin64 with Python 3.x 3014299Sbbruce@ucdavis.edu# define PYBIND11_TLS_KEY_INIT(var) decltype(PyThread_create_key()) var = 0 3114299Sbbruce@ucdavis.edu# define PYBIND11_TLS_GET_VALUE(key) PyThread_get_key_value((key)) 3214299Sbbruce@ucdavis.edu# if PY_MAJOR_VERSION < 3 3314299Sbbruce@ucdavis.edu# define PYBIND11_TLS_DELETE_VALUE(key) \ 3414299Sbbruce@ucdavis.edu PyThread_delete_key_value(key) 3514299Sbbruce@ucdavis.edu# define PYBIND11_TLS_REPLACE_VALUE(key, value) \ 3614299Sbbruce@ucdavis.edu do { \ 3714299Sbbruce@ucdavis.edu PyThread_delete_key_value((key)); \ 3814299Sbbruce@ucdavis.edu PyThread_set_key_value((key), (value)); \ 3914299Sbbruce@ucdavis.edu } while (false) 4014299Sbbruce@ucdavis.edu# else 4114299Sbbruce@ucdavis.edu# define PYBIND11_TLS_DELETE_VALUE(key) \ 4214299Sbbruce@ucdavis.edu PyThread_set_key_value((key), nullptr) 4314299Sbbruce@ucdavis.edu# define PYBIND11_TLS_REPLACE_VALUE(key, value) \ 4414299Sbbruce@ucdavis.edu PyThread_set_key_value((key), (value)) 4514299Sbbruce@ucdavis.edu# endif 4614299Sbbruce@ucdavis.edu#endif 4714299Sbbruce@ucdavis.edu 4812391Sjason@lowepower.com// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly 4912391Sjason@lowepower.com// other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module 5012391Sjason@lowepower.com// even when `A` is the same, non-hidden-visibility type (e.g. from a common include). Under 5112391Sjason@lowepower.com// libstdc++, this doesn't happen: equality and the type_index hash are based on the type name, 5212391Sjason@lowepower.com// which works. If not under a known-good stl, provide our own name-based hash and equality 5312391Sjason@lowepower.com// functions that use the type name. 5412391Sjason@lowepower.com#if defined(__GLIBCXX__) 5512391Sjason@lowepower.cominline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; } 5612391Sjason@lowepower.comusing type_hash = std::hash<std::type_index>; 5712391Sjason@lowepower.comusing type_equal_to = std::equal_to<std::type_index>; 5812391Sjason@lowepower.com#else 5912391Sjason@lowepower.cominline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { 6012391Sjason@lowepower.com return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0; 6112391Sjason@lowepower.com} 6212391Sjason@lowepower.com 6312391Sjason@lowepower.comstruct type_hash { 6412391Sjason@lowepower.com size_t operator()(const std::type_index &t) const { 6512391Sjason@lowepower.com size_t hash = 5381; 6612391Sjason@lowepower.com const char *ptr = t.name(); 6712391Sjason@lowepower.com while (auto c = static_cast<unsigned char>(*ptr++)) 6812391Sjason@lowepower.com hash = (hash * 33) ^ c; 6912391Sjason@lowepower.com return hash; 7012391Sjason@lowepower.com } 7112391Sjason@lowepower.com}; 7212391Sjason@lowepower.com 7312391Sjason@lowepower.comstruct type_equal_to { 7412391Sjason@lowepower.com bool operator()(const std::type_index &lhs, const std::type_index &rhs) const { 7512391Sjason@lowepower.com return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0; 7612391Sjason@lowepower.com } 7712391Sjason@lowepower.com}; 7812391Sjason@lowepower.com#endif 7912391Sjason@lowepower.com 8012391Sjason@lowepower.comtemplate <typename value_type> 8112391Sjason@lowepower.comusing type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>; 8212391Sjason@lowepower.com 8312391Sjason@lowepower.comstruct overload_hash { 8412391Sjason@lowepower.com inline size_t operator()(const std::pair<const PyObject *, const char *>& v) const { 8512391Sjason@lowepower.com size_t value = std::hash<const void *>()(v.first); 8612391Sjason@lowepower.com value ^= std::hash<const void *>()(v.second) + 0x9e3779b9 + (value<<6) + (value>>2); 8712391Sjason@lowepower.com return value; 8812391Sjason@lowepower.com } 8912391Sjason@lowepower.com}; 9012391Sjason@lowepower.com 9112391Sjason@lowepower.com/// Internal data structure used to track registered instances and types. 9212391Sjason@lowepower.com/// Whenever binary incompatible changes are made to this structure, 9312391Sjason@lowepower.com/// `PYBIND11_INTERNALS_VERSION` must be incremented. 9412391Sjason@lowepower.comstruct internals { 9512391Sjason@lowepower.com type_map<type_info *> registered_types_cpp; // std::type_index -> pybind11's type information 9612391Sjason@lowepower.com std::unordered_map<PyTypeObject *, std::vector<type_info *>> registered_types_py; // PyTypeObject* -> base type_info(s) 9712391Sjason@lowepower.com std::unordered_multimap<const void *, instance*> registered_instances; // void * -> instance* 9812391Sjason@lowepower.com std::unordered_set<std::pair<const PyObject *, const char *>, overload_hash> inactive_overload_cache; 9912391Sjason@lowepower.com type_map<std::vector<bool (*)(PyObject *, void *&)>> direct_conversions; 10012391Sjason@lowepower.com std::unordered_map<const PyObject *, std::vector<PyObject *>> patients; 10112391Sjason@lowepower.com std::forward_list<void (*) (std::exception_ptr)> registered_exception_translators; 10212391Sjason@lowepower.com std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across extensions 10312391Sjason@lowepower.com std::vector<PyObject *> loader_patient_stack; // Used by `loader_life_support` 10412391Sjason@lowepower.com std::forward_list<std::string> static_strings; // Stores the std::strings backing detail::c_str() 10512391Sjason@lowepower.com PyTypeObject *static_property_type; 10612391Sjason@lowepower.com PyTypeObject *default_metaclass; 10712391Sjason@lowepower.com PyObject *instance_base; 10812391Sjason@lowepower.com#if defined(WITH_THREAD) 10914299Sbbruce@ucdavis.edu PYBIND11_TLS_KEY_INIT(tstate); 11012391Sjason@lowepower.com PyInterpreterState *istate = nullptr; 11112391Sjason@lowepower.com#endif 11212391Sjason@lowepower.com}; 11312391Sjason@lowepower.com 11412391Sjason@lowepower.com/// Additional type information which does not fit into the PyTypeObject. 11512391Sjason@lowepower.com/// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`. 11612391Sjason@lowepower.comstruct type_info { 11712391Sjason@lowepower.com PyTypeObject *type; 11812391Sjason@lowepower.com const std::type_info *cpptype; 11914299Sbbruce@ucdavis.edu size_t type_size, type_align, holder_size_in_ptrs; 12012391Sjason@lowepower.com void *(*operator_new)(size_t); 12112391Sjason@lowepower.com void (*init_instance)(instance *, const void *); 12212391Sjason@lowepower.com void (*dealloc)(value_and_holder &v_h); 12312391Sjason@lowepower.com std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions; 12412391Sjason@lowepower.com std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts; 12512391Sjason@lowepower.com std::vector<bool (*)(PyObject *, void *&)> *direct_conversions; 12612391Sjason@lowepower.com buffer_info *(*get_buffer)(PyObject *, void *) = nullptr; 12712391Sjason@lowepower.com void *get_buffer_data = nullptr; 12812391Sjason@lowepower.com void *(*module_local_load)(PyObject *, const type_info *) = nullptr; 12912391Sjason@lowepower.com /* A simple type never occurs as a (direct or indirect) parent 13012391Sjason@lowepower.com * of a class that makes use of multiple inheritance */ 13112391Sjason@lowepower.com bool simple_type : 1; 13212391Sjason@lowepower.com /* True if there is no multiple inheritance in this type's inheritance tree */ 13312391Sjason@lowepower.com bool simple_ancestors : 1; 13412391Sjason@lowepower.com /* for base vs derived holder_type checks */ 13512391Sjason@lowepower.com bool default_holder : 1; 13612391Sjason@lowepower.com /* true if this is a type registered with py::module_local */ 13712391Sjason@lowepower.com bool module_local : 1; 13812391Sjason@lowepower.com}; 13912391Sjason@lowepower.com 14012391Sjason@lowepower.com/// Tracks the `internals` and `type_info` ABI version independent of the main library version 14114299Sbbruce@ucdavis.edu#define PYBIND11_INTERNALS_VERSION 3 14214299Sbbruce@ucdavis.edu 14314299Sbbruce@ucdavis.edu/// On MSVC, debug and release builds are not ABI-compatible! 14414299Sbbruce@ucdavis.edu#if defined(_MSC_VER) && defined(_DEBUG) 14514299Sbbruce@ucdavis.edu# define PYBIND11_BUILD_TYPE "_debug" 14614299Sbbruce@ucdavis.edu#else 14714299Sbbruce@ucdavis.edu# define PYBIND11_BUILD_TYPE "" 14814299Sbbruce@ucdavis.edu#endif 14914299Sbbruce@ucdavis.edu 15014299Sbbruce@ucdavis.edu/// Let's assume that different compilers are ABI-incompatible. 15114299Sbbruce@ucdavis.edu#if defined(_MSC_VER) 15214299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_msvc" 15314299Sbbruce@ucdavis.edu#elif defined(__INTEL_COMPILER) 15414299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_icc" 15514299Sbbruce@ucdavis.edu#elif defined(__clang__) 15614299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_clang" 15714299Sbbruce@ucdavis.edu#elif defined(__PGI) 15814299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_pgi" 15914299Sbbruce@ucdavis.edu#elif defined(__MINGW32__) 16014299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_mingw" 16114299Sbbruce@ucdavis.edu#elif defined(__CYGWIN__) 16214299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_gcc_cygwin" 16314299Sbbruce@ucdavis.edu#elif defined(__GNUC__) 16414299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_gcc" 16514299Sbbruce@ucdavis.edu#else 16614299Sbbruce@ucdavis.edu# define PYBIND11_COMPILER_TYPE "_unknown" 16714299Sbbruce@ucdavis.edu#endif 16814299Sbbruce@ucdavis.edu 16914299Sbbruce@ucdavis.edu#if defined(_LIBCPP_VERSION) 17014299Sbbruce@ucdavis.edu# define PYBIND11_STDLIB "_libcpp" 17114299Sbbruce@ucdavis.edu#elif defined(__GLIBCXX__) || defined(__GLIBCPP__) 17214299Sbbruce@ucdavis.edu# define PYBIND11_STDLIB "_libstdcpp" 17314299Sbbruce@ucdavis.edu#else 17414299Sbbruce@ucdavis.edu# define PYBIND11_STDLIB "" 17514299Sbbruce@ucdavis.edu#endif 17614299Sbbruce@ucdavis.edu 17714299Sbbruce@ucdavis.edu/// On Linux/OSX, changes in __GXX_ABI_VERSION__ indicate ABI incompatibility. 17814299Sbbruce@ucdavis.edu#if defined(__GXX_ABI_VERSION) 17914299Sbbruce@ucdavis.edu# define PYBIND11_BUILD_ABI "_cxxabi" PYBIND11_TOSTRING(__GXX_ABI_VERSION) 18014299Sbbruce@ucdavis.edu#else 18114299Sbbruce@ucdavis.edu# define PYBIND11_BUILD_ABI "" 18214299Sbbruce@ucdavis.edu#endif 18312391Sjason@lowepower.com 18412391Sjason@lowepower.com#if defined(WITH_THREAD) 18512391Sjason@lowepower.com# define PYBIND11_INTERNALS_KIND "" 18612391Sjason@lowepower.com#else 18712391Sjason@lowepower.com# define PYBIND11_INTERNALS_KIND "_without_thread" 18812391Sjason@lowepower.com#endif 18912391Sjason@lowepower.com 19012391Sjason@lowepower.com#define PYBIND11_INTERNALS_ID "__pybind11_internals_v" \ 19114299Sbbruce@ucdavis.edu PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__" 19212391Sjason@lowepower.com 19312391Sjason@lowepower.com#define PYBIND11_MODULE_LOCAL_ID "__pybind11_module_local_v" \ 19414299Sbbruce@ucdavis.edu PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__" 19512391Sjason@lowepower.com 19612391Sjason@lowepower.com/// Each module locally stores a pointer to the `internals` data. The data 19712391Sjason@lowepower.com/// itself is shared among modules with the same `PYBIND11_INTERNALS_ID`. 19814299Sbbruce@ucdavis.eduinline internals **&get_internals_pp() { 19914299Sbbruce@ucdavis.edu static internals **internals_pp = nullptr; 20014299Sbbruce@ucdavis.edu return internals_pp; 20112391Sjason@lowepower.com} 20212391Sjason@lowepower.com 20314299Sbbruce@ucdavis.eduinline void translate_exception(std::exception_ptr p) { 20414299Sbbruce@ucdavis.edu try { 20514299Sbbruce@ucdavis.edu if (p) std::rethrow_exception(p); 20614299Sbbruce@ucdavis.edu } catch (error_already_set &e) { e.restore(); return; 20714299Sbbruce@ucdavis.edu } catch (const builtin_exception &e) { e.set_error(); return; 20814299Sbbruce@ucdavis.edu } catch (const std::bad_alloc &e) { PyErr_SetString(PyExc_MemoryError, e.what()); return; 20914299Sbbruce@ucdavis.edu } catch (const std::domain_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; 21014299Sbbruce@ucdavis.edu } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; 21114299Sbbruce@ucdavis.edu } catch (const std::length_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; 21214299Sbbruce@ucdavis.edu } catch (const std::out_of_range &e) { PyErr_SetString(PyExc_IndexError, e.what()); return; 21314299Sbbruce@ucdavis.edu } catch (const std::range_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return; 21414299Sbbruce@ucdavis.edu } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return; 21514299Sbbruce@ucdavis.edu } catch (...) { 21614299Sbbruce@ucdavis.edu PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!"); 21714299Sbbruce@ucdavis.edu return; 21814299Sbbruce@ucdavis.edu } 21914299Sbbruce@ucdavis.edu} 22014299Sbbruce@ucdavis.edu 22114299Sbbruce@ucdavis.edu#if !defined(__GLIBCXX__) 22214299Sbbruce@ucdavis.eduinline void translate_local_exception(std::exception_ptr p) { 22314299Sbbruce@ucdavis.edu try { 22414299Sbbruce@ucdavis.edu if (p) std::rethrow_exception(p); 22514299Sbbruce@ucdavis.edu } catch (error_already_set &e) { e.restore(); return; 22614299Sbbruce@ucdavis.edu } catch (const builtin_exception &e) { e.set_error(); return; 22714299Sbbruce@ucdavis.edu } 22814299Sbbruce@ucdavis.edu} 22914299Sbbruce@ucdavis.edu#endif 23014299Sbbruce@ucdavis.edu 23112391Sjason@lowepower.com/// Return a reference to the current `internals` data 23212391Sjason@lowepower.comPYBIND11_NOINLINE inline internals &get_internals() { 23314299Sbbruce@ucdavis.edu auto **&internals_pp = get_internals_pp(); 23414299Sbbruce@ucdavis.edu if (internals_pp && *internals_pp) 23514299Sbbruce@ucdavis.edu return **internals_pp; 23614299Sbbruce@ucdavis.edu 23714299Sbbruce@ucdavis.edu // Ensure that the GIL is held since we will need to make Python calls. 23814299Sbbruce@ucdavis.edu // Cannot use py::gil_scoped_acquire here since that constructor calls get_internals. 23914299Sbbruce@ucdavis.edu struct gil_scoped_acquire_local { 24014299Sbbruce@ucdavis.edu gil_scoped_acquire_local() : state (PyGILState_Ensure()) {} 24114299Sbbruce@ucdavis.edu ~gil_scoped_acquire_local() { PyGILState_Release(state); } 24214299Sbbruce@ucdavis.edu const PyGILState_STATE state; 24314299Sbbruce@ucdavis.edu } gil; 24412391Sjason@lowepower.com 24512391Sjason@lowepower.com constexpr auto *id = PYBIND11_INTERNALS_ID; 24612391Sjason@lowepower.com auto builtins = handle(PyEval_GetBuiltins()); 24712391Sjason@lowepower.com if (builtins.contains(id) && isinstance<capsule>(builtins[id])) { 24814299Sbbruce@ucdavis.edu internals_pp = static_cast<internals **>(capsule(builtins[id])); 24912391Sjason@lowepower.com 25012391Sjason@lowepower.com // We loaded builtins through python's builtins, which means that our `error_already_set` 25112391Sjason@lowepower.com // and `builtin_exception` may be different local classes than the ones set up in the 25212391Sjason@lowepower.com // initial exception translator, below, so add another for our local exception classes. 25312391Sjason@lowepower.com // 25412391Sjason@lowepower.com // libstdc++ doesn't require this (types there are identified only by name) 25512391Sjason@lowepower.com#if !defined(__GLIBCXX__) 25614299Sbbruce@ucdavis.edu (*internals_pp)->registered_exception_translators.push_front(&translate_local_exception); 25712391Sjason@lowepower.com#endif 25812391Sjason@lowepower.com } else { 25914299Sbbruce@ucdavis.edu if (!internals_pp) internals_pp = new internals*(); 26014299Sbbruce@ucdavis.edu auto *&internals_ptr = *internals_pp; 26112391Sjason@lowepower.com internals_ptr = new internals(); 26212391Sjason@lowepower.com#if defined(WITH_THREAD) 26312391Sjason@lowepower.com PyEval_InitThreads(); 26412391Sjason@lowepower.com PyThreadState *tstate = PyThreadState_Get(); 26514299Sbbruce@ucdavis.edu #if PY_VERSION_HEX >= 0x03070000 26614299Sbbruce@ucdavis.edu internals_ptr->tstate = PyThread_tss_alloc(); 26714299Sbbruce@ucdavis.edu if (!internals_ptr->tstate || PyThread_tss_create(internals_ptr->tstate)) 26814299Sbbruce@ucdavis.edu pybind11_fail("get_internals: could not successfully initialize the TSS key!"); 26914299Sbbruce@ucdavis.edu PyThread_tss_set(internals_ptr->tstate, tstate); 27014299Sbbruce@ucdavis.edu #else 27114299Sbbruce@ucdavis.edu internals_ptr->tstate = PyThread_create_key(); 27214299Sbbruce@ucdavis.edu if (internals_ptr->tstate == -1) 27314299Sbbruce@ucdavis.edu pybind11_fail("get_internals: could not successfully initialize the TLS key!"); 27414299Sbbruce@ucdavis.edu PyThread_set_key_value(internals_ptr->tstate, tstate); 27514299Sbbruce@ucdavis.edu #endif 27612391Sjason@lowepower.com internals_ptr->istate = tstate->interp; 27712391Sjason@lowepower.com#endif 27814299Sbbruce@ucdavis.edu builtins[id] = capsule(internals_pp); 27914299Sbbruce@ucdavis.edu internals_ptr->registered_exception_translators.push_front(&translate_exception); 28012391Sjason@lowepower.com internals_ptr->static_property_type = make_static_property_type(); 28112391Sjason@lowepower.com internals_ptr->default_metaclass = make_default_metaclass(); 28212391Sjason@lowepower.com internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass); 28312391Sjason@lowepower.com } 28414299Sbbruce@ucdavis.edu return **internals_pp; 28512391Sjason@lowepower.com} 28612391Sjason@lowepower.com 28712391Sjason@lowepower.com/// Works like `internals.registered_types_cpp`, but for module-local registered types: 28812391Sjason@lowepower.cominline type_map<type_info *> ®istered_local_types_cpp() { 28912391Sjason@lowepower.com static type_map<type_info *> locals{}; 29012391Sjason@lowepower.com return locals; 29112391Sjason@lowepower.com} 29212391Sjason@lowepower.com 29312391Sjason@lowepower.com/// Constructs a std::string with the given arguments, stores it in `internals`, and returns its 29412391Sjason@lowepower.com/// `c_str()`. Such strings objects have a long storage duration -- the internal strings are only 29512391Sjason@lowepower.com/// cleared when the program exits or after interpreter shutdown (when embedding), and so are 29612391Sjason@lowepower.com/// suitable for c-style strings needed by Python internals (such as PyTypeObject's tp_name). 29712391Sjason@lowepower.comtemplate <typename... Args> 29812391Sjason@lowepower.comconst char *c_str(Args &&...args) { 29912391Sjason@lowepower.com auto &strings = get_internals().static_strings; 30012391Sjason@lowepower.com strings.emplace_front(std::forward<Args>(args)...); 30112391Sjason@lowepower.com return strings.front().c_str(); 30212391Sjason@lowepower.com} 30312391Sjason@lowepower.com 30412391Sjason@lowepower.comNAMESPACE_END(detail) 30512391Sjason@lowepower.com 30612391Sjason@lowepower.com/// Returns a named pointer that is shared among all extension modules (using the same 30712391Sjason@lowepower.com/// pybind11 version) running in the current interpreter. Names starting with underscores 30812391Sjason@lowepower.com/// are reserved for internal usage. Returns `nullptr` if no matching entry was found. 30912391Sjason@lowepower.cominline PYBIND11_NOINLINE void *get_shared_data(const std::string &name) { 31012391Sjason@lowepower.com auto &internals = detail::get_internals(); 31112391Sjason@lowepower.com auto it = internals.shared_data.find(name); 31212391Sjason@lowepower.com return it != internals.shared_data.end() ? it->second : nullptr; 31312391Sjason@lowepower.com} 31412391Sjason@lowepower.com 31512391Sjason@lowepower.com/// Set the shared data that can be later recovered by `get_shared_data()`. 31612391Sjason@lowepower.cominline PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) { 31712391Sjason@lowepower.com detail::get_internals().shared_data[name] = data; 31812391Sjason@lowepower.com return data; 31912391Sjason@lowepower.com} 32012391Sjason@lowepower.com 32112391Sjason@lowepower.com/// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if 32212391Sjason@lowepower.com/// such entry exists. Otherwise, a new object of default-constructible type `T` is 32312391Sjason@lowepower.com/// added to the shared data under the given name and a reference to it is returned. 32412391Sjason@lowepower.comtemplate<typename T> 32512391Sjason@lowepower.comT &get_or_create_shared_data(const std::string &name) { 32612391Sjason@lowepower.com auto &internals = detail::get_internals(); 32712391Sjason@lowepower.com auto it = internals.shared_data.find(name); 32812391Sjason@lowepower.com T *ptr = (T *) (it != internals.shared_data.end() ? it->second : nullptr); 32912391Sjason@lowepower.com if (!ptr) { 33012391Sjason@lowepower.com ptr = new T(); 33112391Sjason@lowepower.com internals.shared_data[name] = ptr; 33212391Sjason@lowepower.com } 33312391Sjason@lowepower.com return *ptr; 33412391Sjason@lowepower.com} 33512391Sjason@lowepower.com 33612391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE) 337